Ignore:
Timestamp:
07/05/16 15:59:02 (8 years ago)
Author:
mhnguyen
Message:

Adding a new type of element into grid: Scalar

+) Add a new node Scalar for xml
+) Make some change on writing scalar value
+) Reorganize some codes
+) Remove some redundant codes

Test
+) On Curie
+) All tests pass

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r873 r887  
    2323namespace xios { 
    2424CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source) 
    25 : gridSource_(source), gridDestination_(destination), tmpGridDestination_(destination), 
    26   originalGridSource_(source), algoTypes_(), nbAlgos_(0), tempGridSrcs_(), tempGridDests_(), 
    27   auxInputs_(), dynamicalTransformation_(false), timeStamp_() 
    28  
    29 { 
    30   //Verify the compatibity between two grids 
    31   int numElement = gridDestination_->axis_domain_order.numElements(); 
    32   if (numElement != gridSource_->axis_domain_order.numElements()) 
    33     ERROR("CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source)", 
    34        << "Two grids have different number of elements" 
    35        << "Number of elements of grid source " <<gridSource_->getId() << " is " << gridSource_->axis_domain_order.numElements()  << std::endl 
    36        << "Number of elements of grid destination " <<gridDestination_->getId() << " is " << numElement); 
    37  
    38   for (int i = 0; i < numElement; ++i) 
    39   { 
    40     if (gridDestination_->axis_domain_order(i) != gridSource_->axis_domain_order(i)) 
    41       ERROR("CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source)", 
    42          << "Transformed grid and its grid source have incompatible elements" 
    43          << "Grid source " <<gridSource_->getId() << std::endl 
    44          << "Grid destination " <<gridDestination_->getId()); 
    45   } 
    46  
    47   initializeTransformations(); 
    48 } 
    49  
    50 /*! 
    51   Initialize the mapping between the first grid source and the original one 
    52   In a series of transformation, for each step, there is a need to "create" a new grid that plays a role of "temporary" source. 
    53 Because at the end of the series, we need to know about the index mapping between the final grid destination and original grid source, 
    54 for each transformation, we need to make sure that the current "temporary source" maps its global index correctly to the original one. 
    55 */ 
    56 void CGridTransformation::initializeTransformations() 
    57 { 
    58   CContext* context = CContext::getCurrent(); 
    59   CContextClient* client = context->client; 
    60  
    61   // Initialize algorithms 
    62   initializeAlgorithms(); 
    63  
    64   ListAlgoType::const_iterator itb = listAlgos_.begin(), 
    65                                ite = listAlgos_.end(), it; 
    66  
    67   for (it = itb; it != ite; ++it) 
    68   { 
    69     ETranformationType transType = (it->second).first; 
    70     if (!isSpecialTransformation(transType)) ++nbAlgos_; 
    71   } 
     25 : CGridTransformationSelector(destination, source), 
     26  tmpGridDestination_(destination), originalGridSource_(source), 
     27  tempGridSrcs_(), tempGridDests_(), 
     28  dynamicalTransformation_(false), timeStamp_() 
     29{ 
    7230} 
    7331 
    7432CGridTransformation::~CGridTransformation() 
    7533{ 
    76   std::vector<CGenericAlgorithmTransformation*>::const_iterator itb = algoTransformation_.begin(), it, 
    77                                                                 ite = algoTransformation_.end(); 
    78   for (it = itb; it != ite; ++it) delete (*it); 
    79 } 
    80  
    81 /*! 
    82   Initialize the algorithms (transformations) 
    83 */ 
    84 void CGridTransformation::initializeAlgorithms() 
    85 { 
    86   std::vector<int> axisPositionInGrid; 
    87   std::vector<int> domPositionInGrid; 
    88   std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    89   std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
    90  
    91   int idx = 0; 
    92   for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i) 
    93   { 
    94     if (false == (gridDestination_->axis_domain_order)(i)) 
    95     { 
    96       axisPositionInGrid.push_back(i); 
    97     } 
    98     else 
    99     { 
    100       domPositionInGrid.push_back(i); 
    101     } 
    102   } 
    103  
    104   for (int i = 0; i < axisListDestP.size(); ++i) 
    105   { 
    106     elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i; 
    107   } 
    108  
    109   for (int i = 0; i < domListDestP.size(); ++i) 
    110   { 
    111     elementPosition2DomainPositionInGrid_[domPositionInGrid[i]] = i; 
    112   } 
    113  
    114   idx = 0; 
    115   for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i) 
    116   { 
    117     if (false == (gridDestination_->axis_domain_order)(i)) 
    118     { 
    119       initializeAxisAlgorithms(i); 
    120     } 
    121     else 
    122     { 
    123       initializeDomainAlgorithms(i); 
    124     } 
    125   } 
    126 } 
    127  
    128 /*! 
    129   Initialize the algorithms corresponding to transformation info contained in each axis. 
    130 If an axis has transformations, these transformations will be represented in form of vector of CTransformation pointers 
    131 In general, each axis can have several transformations performed on itself. However, should they be done seperately or combinely (of course in order)? 
    132 For now, one approach is to do these combinely but maybe this needs changing. 
    133 \param [in] axisPositionInGrid position of an axis in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2) 
    134 */ 
    135 void CGridTransformation::initializeAxisAlgorithms(int axisPositionInGrid) 
     34} 
     35 
     36/*! 
     37  Select algorithm of a scalar correspoding to its transformation type and its position in each element 
     38  \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 0 and position of axis is 1 
     39  \param [in] transType transformation type, for now we have 
     40  \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
     41*/ 
     42void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
     43{ 
     44 
     45} 
     46 
     47/*! 
     48  Select algorithm of an axis correspoding to its transformation type and its position in each element 
     49  \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 0 and position of axis is 1 
     50  \param [in] transType transformation type, for now we have zoom_axis, inverse_axis, interpolate_axis 
     51  \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
     52*/ 
     53void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    13654{ 
    13755  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    13856  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    139   if (!axisListDestP.empty()) 
    140   { 
    141     // If source and destination grid share the same axis 
    142     if (axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]] == 
    143         axisListSrcP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]) return; 
    144  
    145     if (axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->hasTransformation()) 
    146     { 
    147       CAxis::TransMapTypes trans = axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->getAllTransformations(); 
    148       CAxis::TransMapTypes::const_iterator itb = trans.begin(), it, 
    149                                            ite = trans.end(); 
    150       int transformationOrder = 0; 
    151       for (it = itb; it != ite; ++it) 
    152       { 
    153         listAlgos_.push_back(std::make_pair(axisPositionInGrid, std::make_pair(it->first, transformationOrder))); 
    154         algoTypes_.push_back(false); 
    155         ++transformationOrder; 
    156         std::vector<StdString> auxInput = (it->second)->checkAuxInputs(); 
    157         for (int idx = 0; idx < auxInput.size(); ++idx) auxInputs_.push_back(auxInput[idx]); 
    158       } 
    159     } 
    160   } 
    161 } 
    162  
    163 /*! 
    164   Initialize the algorithms corresponding to transformation info contained in each domain. 
    165 If a domain has transformations, they will be represented in form of vector of CTransformation pointers 
    166 In general, each domain can have several transformations performed on itself. 
    167 \param [in] domPositionInGrid position of a domain in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2) 
    168 */ 
    169 void CGridTransformation::initializeDomainAlgorithms(int domPositionInGrid) 
    170 { 
    171   std::vector<CDomain*> domListDestP = gridDestination_->getDomains(); 
    172   std::vector<CDomain*> domListSrcP = gridSource_->getDomains(); 
    173   if (!domListDestP.empty()) 
    174   { 
    175     // If source and destination grid share the same domain 
    176     if (domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]] == 
    177         domListSrcP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]) return; 
    178  
    179     if (domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->hasTransformation()) 
    180     { 
    181       CDomain::TransMapTypes trans = domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->getAllTransformations(); 
    182       CDomain::TransMapTypes::const_iterator itb = trans.begin(), it, 
    183                                              ite = trans.end(); 
    184       int transformationOrder = 0; 
    185       for (it = itb; it != ite; ++it) 
    186       { 
    187         listAlgos_.push_back(std::make_pair(domPositionInGrid, std::make_pair(it->first, transformationOrder))); 
    188         algoTypes_.push_back(true); 
    189         ++transformationOrder; 
    190         std::vector<StdString> auxInput = (it->second)->checkAuxInputs(); 
    191         for (int idx = 0; idx < auxInput.size(); ++idx) auxInputs_.push_back(auxInput[idx]); 
    192       } 
    193     } 
    194   } 
    195  
    196 } 
    197  
    198 /*! 
    199   Select algorithm correspoding to its transformation type and its position in each element 
    200   \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 1 (because it contains 2 basic elements) 
    201                                              and position of axis is 2 
    202   \param [in] transType transformation type, for now we have Zoom_axis, inverse_axis 
    203   \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
    204   \param [in] isDomainAlgo flag to specify type of algorithm (for domain or axis) 
    205 */ 
    206 void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, bool isDomainAlgo) 
    207 { 
    208    if (isDomainAlgo) selectDomainAlgo(elementPositionInGrid, transType, transformationOrder); 
    209    else selectAxisAlgo(elementPositionInGrid, transType, transformationOrder); 
    210 } 
    211  
    212 /*! 
    213   Select algorithm of an axis correspoding to its transformation type and its position in each element 
    214   \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 1 (because it contains 2 basic elements) 
    215                                              and position of axis is 2 
    216   \param [in] transType transformation type, for now we have Zoom_axis, inverse_axis 
    217   \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
    218 */ 
    219 void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    220 { 
    221   std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    222   std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    223  
    224   int axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid]; 
     57 
     58  int axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    22559  CAxis::TransMapTypes trans = axisListDestP[axisIndex]->getAllTransformations(); 
    22660  CAxis::TransMapTypes::const_iterator it = trans.begin(); 
    … …  
    24882  } 
    24983  algoTransformation_.push_back(algo); 
    250  
    25184} 
    25285 
    25386/*! 
    25487  Select algorithm of a domain correspoding to its transformation type and its position in each element 
    255   \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 1 (because it contains 2 basic elements) 
    256                                              and position of axis is 2 
    257   \param [in] transType transformation type, for now we have Zoom_axis, inverse_axis 
     88  \param [in] elementPositionInGrid position of element in grid. e.g: a grid has 1 domain and 1 axis, then position of domain is 0 and position of axis is 1 
     89  \param [in] transType transformation type, for now we have zoom_domain, interpolate_domain 
    25890  \param [in] transformationOrder position of the transformation in an element (an element can have several transformation) 
    25991*/ 
    … …  
    26395  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
    26496 
    265   int domainIndex =  elementPosition2DomainPositionInGrid_[elementPositionInGrid]; 
     97  int domainIndex =  elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    26698  CDomain::TransMapTypes trans = domainListDestP[domainIndex]->getAllTransformations(); 
    26799  CDomain::TransMapTypes::const_iterator it = trans.begin(); 
    … …  
    302134    tempGridDests_.resize(0); 
    303135  } 
     136 
     137  std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars(); 
     138  std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarDst; 
     139 
    304140  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    305141  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisDst; 
    … …  
    308144  std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainDst; 
    309145 
    310   int axisIndex = -1, domainIndex = -1; 
     146  CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order; 
     147  CArray<int,1> axisDomainOrderDst = gridDestination_->axis_domain_order; 
     148 
     149  int scalarIndex = -1, axisIndex = -1, domainIndex = -1; 
    311150  switch (transType) 
    312151  { 
    313152    case TRANS_INTERPOLATE_DOMAIN: 
    314153    case TRANS_ZOOM_DOMAIN: 
    315       domainIndex = elementPosition2DomainPositionInGrid_[elementPositionInGrid]; 
     154      domainIndex = elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    316155      break; 
    317156 
    … …  
    319158    case TRANS_ZOOM_AXIS: 
    320159    case TRANS_INVERSE_AXIS: 
    321       axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid]; 
     160      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    322161      break; 
    323162    default: 
    … …  
    325164  } 
    326165 
    327   for (int idx = 0; idx < axisListSrcP.size(); ++idx) 
    328   { 
    329     CAxis* axis = (axisIndex != idx) ? axisListSrcP[idx] : axisListDestP[idx]; 
    330     axisDst.push_back(axis); 
    331   } 
    332  
    333   for (int idx = 0; idx < domListSrcP.size(); ++idx) 
    334   { 
    335     CDomain* domain = (domainIndex != idx) ? domListSrcP[idx] : domListDestP[idx]; 
    336     domainDst.push_back(domain); 
    337   } 
    338  
    339   tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, gridDestination_->axis_domain_order); 
    340   tmpGridDestination_->computeGridGlobalDimension(domainDst, axisDst, gridDestination_->axis_domain_order); 
     166  for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx) 
     167  { 
     168    int dimElementDst = axisDomainOrderDst(idx); 
     169    if (2 == dimElementDst) 
     170    { 
     171      if (elementPositionInGrid == idx) 
     172        domainDst.push_back(domListDestP[domainIndex]); 
     173      else 
     174        domainDst.push_back(domListSrcP[elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]]); 
     175    } 
     176    else if (1 == dimElementDst) 
     177    { 
     178      if (elementPositionInGrid == idx) 
     179        axisDst.push_back(axisListDestP[axisIndex]); 
     180      else 
     181        axisDst.push_back(axisListSrcP[elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]]); 
     182    } 
     183    else 
     184    { 
     185      if (elementPositionInGrid == idx) 
     186        scalarDst.push_back(scalarListDestP[scalarIndex]); 
     187      else 
     188        scalarDst.push_back(scalarListSrcP[elementPositionInGridSrc2ScalarPosition_[elementPositionInGrid]]); 
     189    } 
     190  } 
     191 
     192  tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, scalarDst, gridDestination_->axis_domain_order); 
     193  tmpGridDestination_->computeGridGlobalDimension(domainDst, axisDst, scalarDst, gridDestination_->axis_domain_order); 
    341194  tempGridDests_.push_back(tmpGridDestination_); 
    342195} 
    … …  
    356209  } 
    357210 
     211  std::vector<CScalar*> scalarListDestP = tmpGridDestination_->getScalars(); 
     212  std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarSrc; 
     213 
    358214  std::vector<CAxis*> axisListDestP = tmpGridDestination_->getAxis(); 
    359215  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisSrc; 
    … …  
    362218  std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainSrc; 
    363219 
    364   int axisIndex = -1, domainIndex = -1; 
     220  CArray<int,1> axisDomainOrderDst = gridDestination_->axis_domain_order; 
     221 
     222  int axisIndex = -1, domainIndex = -1, scalarIndex = -1; 
     223  int axisListIndex = 0, domainListIndex = 0, scalarListIndex = 0; 
    365224  switch (transType) 
    366225  { 
    367226    case TRANS_INTERPOLATE_DOMAIN: 
    368227    case TRANS_ZOOM_DOMAIN: 
    369       domainIndex = elementPosition2DomainPositionInGrid_[elementPositionInGrid]; 
     228      domainIndex = elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    370229      break; 
    371230 
    … …  
    373232    case TRANS_ZOOM_AXIS: 
    374233    case TRANS_INVERSE_AXIS: 
    375       axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid]; 
     234      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    376235      break; 
    377236    default: 
    … …  
    379238  } 
    380239 
    381   for (int idx = 0; idx < axisListSrcP.size(); ++idx) 
    382   { 
    383     if (axisIndex != idx) 
    384     { 
    385       CAxis* axis = axisListDestP[idx]; 
    386       axisSrc.push_back(axis); 
     240  for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx) 
     241  { 
     242    int dimElementDst = axisDomainOrderDst(idx); 
     243    if (2 == dimElementDst) 
     244    { 
     245      if (elementPositionInGrid == idx) 
     246        domainSrc.push_back(domListDestP[domainIndex]); 
     247      else 
     248      { 
     249        CDomain* domain = CDomain::createDomain(); 
     250        domain->domain_ref.setValue(domListDestP[domainListIndex]->getId()); 
     251        domain->solveRefInheritance(true); 
     252        domain->checkAttributesOnClient(); 
     253        domainSrc.push_back(domain); 
     254      } 
     255      ++domainListIndex; 
     256    } 
     257    else if (1 == dimElementDst) 
     258    { 
     259      if (elementPositionInGrid == idx) 
     260        axisSrc.push_back(axisListDestP[axisIndex]); 
     261      else 
     262      { 
     263        CAxis* axis = CAxis::createAxis(); 
     264        axis->axis_ref.setValue(axisListDestP[axisListIndex]->getId()); 
     265        axis->solveRefInheritance(true); 
     266        axis->checkAttributesOnClient(); 
     267        axisSrc.push_back(axis); 
     268      } 
     269      ++axisListIndex; 
    387270    } 
    388271    else 
    389272    { 
    390       CAxis* axis = CAxis::createAxis(); 
    391       axis->axis_ref.setValue(axisListDestP[idx]->getId()); 
    392       axis->solveRefInheritance(true); 
    393       axis->checkAttributesOnClient(); 
    394       axisSrc.push_back(axis); 
    395     } 
    396   } 
    397  
    398   for (int idx = 0; idx < domListSrcP.size(); ++idx) 
    399   { 
    400     if (domainIndex != idx) 
    401     { 
    402       CDomain* domain = domListDestP[idx]; 
    403       domainSrc.push_back(domain); 
    404     } 
    405     else 
    406     { 
    407       CDomain* domain = CDomain::createDomain(); 
    408       domain->domain_ref.setValue(domListDestP[idx]->getId()); 
    409       domain->solveRefInheritance(true); 
    410       domain->checkAttributesOnClient(); 
    411       domainSrc.push_back(domain); 
    412     } 
    413   } 
    414  
    415   gridSource_ = CGrid::createGrid(domainSrc, axisSrc, tmpGridDestination_->axis_domain_order); 
    416   gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, tmpGridDestination_->axis_domain_order); 
     273      if (elementPositionInGrid == idx) 
     274        scalarSrc.push_back(scalarListDestP[scalarIndex]); 
     275      else 
     276      { 
     277        CScalar* scalar = CScalar::createScalar(); 
     278        scalar->scalar_ref.setValue(scalarListDestP[scalarListIndex]->getId()); 
     279        scalar->solveRefInheritance(true); 
     280        scalar->checkAttributesOnClient(); 
     281        scalarSrc.push_back(scalar); 
     282      } 
     283      ++scalarListIndex; 
     284    } 
     285  } 
     286 
     287  gridSource_ = CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order); 
     288  gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order); 
    417289 
    418290  tempGridSrcs_.push_back(gridSource_); 
    … …  
    429301void CGridTransformation::computeAll(const std::vector<CArray<double,1>* >& dataAuxInputs, Time timeStamp) 
    430302{ 
    431   if (nbAlgos_ < 1) return; 
     303  if (nbNormalAlgos_ < 1) return; 
    432304  if (!auxInputs_.empty() && !dynamicalTransformation_) { dynamicalTransformation_ = true; return; } 
    433305  if (dynamicalTransformation_) 
    … …  
    486358      computeTransformationMapping(globaIndexWeightFromSrcToDst); 
    487359 
    488       if (1 < nbAlgos_) 
     360      if (1 < nbNormalAlgos_) 
    489361      { 
    490362        // Now grid destination becomes grid source in a new transformation 
    491         if (nbAgloTransformation != (nbAlgos_-1)) setUpGridSource(elementPositionInGrid, transType, nbAgloTransformation); 
     363        if (nbAgloTransformation != (nbNormalAlgos_-1)) setUpGridSource(elementPositionInGrid, transType, nbAgloTransformation); 
    492364      } 
    493365      ++nbAgloTransformation; 
    … …  
    725597} 
    726598 
    727 bool CGridTransformation::isSpecialTransformation(ETranformationType transType) 
    728 { 
    729   bool res; 
    730   switch (transType) 
    731   { 
    732     case TRANS_GENERATE_RECTILINEAR_DOMAIN: 
    733      res = true; 
    734      break; 
    735     default: 
    736      res = false; 
    737      break; 
    738   } 
    739  
    740   return res; 
    741 } 
    742  
    743599/*! 
    744600  Local index of data which need sending from the grid source 
Note: See TracChangeset for help on using the changeset viewer.