Ignore:
Timestamp:
09/22/16 10:58:32 (8 years ago)
Author:
mhnguyen
Message:

Improving transformation selection. Instead of modifying directly grid_transformation
we only need to register a new transformation with the framework

+) Update all transformations with this new method

Test
+) On Curie
+) Basic tests pass

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r895 r933  
    88 */ 
    99#include "grid_transformation.hpp" 
     10#include "grid_transformation_factory_impl.hpp" 
    1011#include "algo_types.hpp" 
    1112#include "context.hpp" 
    … …  
    3031 
    3132/*! 
    32   Select algorithm of a scalar correspoding to its transformation type and its position in each element 
     33  Select algorithm of a scalar corresponding to its transformation type and its position in each element 
    3334  \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 
    3435  \param [in] transType transformation type, for now we have 
    … …  
    3738void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    3839{ 
    39   int scalarSrcIndex = -1, axisSrcIndex = -1, domainSrcIndex = -1; 
    4040  std::vector<CScalar*> scaListDestP = gridDestination_->getScalars(); 
    41   std::vector<CScalar*> scaListSrcP  = gridSource_->getScalars(); 
    42   std::vector<CAxis*> axisListSrcP   = gridSource_->getAxis(); 
    43   std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
    44  
    4541  int scalarDstIndex =  elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
    4642  CScalar::TransMapTypes trans = scaListDestP[scalarDstIndex]->getAllTransformations(); 
    … …  
    4844 
    4945  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation 
    50  
    51   CReduceAxisToScalar* reduceAxis = 0; 
    5246  CGenericAlgorithmTransformation* algo = 0; 
    53   switch (transType) 
    54   { 
    55     case TRANS_REDUCE_AXIS_TO_SCALAR: 
    56       reduceAxis = dynamic_cast<CReduceAxisToScalar*> (it->second); 
    57       axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
    58       algo = new CScalarAlgorithmReduceScalar(scaListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis); 
    59       break; 
    60     default: 
    61       break; 
    62   } 
     47  algo = CGridTransformationFactory<CScalar>::createTransformation(transType, 
     48                                                                  gridDestination_, 
     49                                                                  gridSource_, 
     50                                                                  it->second, 
     51                                                                  elementPositionInGrid, 
     52                                                                  elementPositionInGridSrc2ScalarPosition_, 
     53                                                                  elementPositionInGridSrc2AxisPosition_, 
     54                                                                  elementPositionInGridSrc2DomainPosition_, 
     55                                                                  elementPositionInGridDst2ScalarPosition_, 
     56                                                                  elementPositionInGridDst2AxisPosition_, 
     57                                                                  elementPositionInGridDst2DomainPosition_); 
    6358  algoTransformation_.push_back(algo); 
    6459} 
    6560 
    6661/*! 
    67   Select algorithm of an axis correspoding to its transformation type and its position in each element 
     62  Select algorithm of an axis corresponding to its transformation type and its position in each element 
    6863  \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 
    6964  \param [in] transType transformation type, for now we have zoom_axis, inverse_axis, interpolate_axis 
    … …  
    7267void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    7368{ 
    74   int axisSrcIndex = -1, domainSrcIndex = -1; 
    7569  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    76   std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    77   std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
    78  
    7970  int axisDstIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    8071  CAxis::TransMapTypes trans = axisListDestP[axisDstIndex]->getAllTransformations(); 
    8172  CAxis::TransMapTypes::const_iterator it = trans.begin(); 
    82  
    8373  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation 
    8474 
    85   CZoomAxis* zoomAxis = 0; 
    86   CInterpolateAxis* interpAxis = 0; 
    87   CReduceDomainToAxis* reduceDomain = 0; 
    88   CExtractDomainToAxis* extractDomain = 0; 
    8975  CGenericAlgorithmTransformation* algo = 0; 
    90   switch (transType) 
    91   { 
    92     case TRANS_INTERPOLATE_AXIS: 
    93       interpAxis = dynamic_cast<CInterpolateAxis*> (it->second); 
    94       axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
    95       algo = new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpAxis); 
    96       break; 
    97     case TRANS_ZOOM_AXIS: 
    98       zoomAxis = dynamic_cast<CZoomAxis*> (it->second); 
    99       axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
    100       algo = new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis); 
    101       break; 
    102     case TRANS_INVERSE_AXIS: 
    103       axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
    104       algo = new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex]); 
    105       break; 
    106     case TRANS_REDUCE_DOMAIN_TO_AXIS: 
    107       reduceDomain = dynamic_cast<CReduceDomainToAxis*> (it->second); 
    108       domainSrcIndex = elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]; 
    109       algo = new CAxisAlgorithmReduceDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], reduceDomain); 
    110       break; 
    111     case TRANS_EXTRACT_DOMAIN_TO_AXIS: 
    112       extractDomain = dynamic_cast<CExtractDomainToAxis*> (it->second); 
    113       domainSrcIndex = elementPositionInGridSrc2DomainPosition_[elementPositionInGrid]; 
    114       algo = new CAxisAlgorithmExtractDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], extractDomain); 
    115       break; 
    116     default: 
    117       break; 
    118   } 
     76  algo = CGridTransformationFactory<CAxis>::createTransformation(transType, 
     77                                                                 gridDestination_, 
     78                                                                 gridSource_, 
     79                                                                 it->second, 
     80                                                                 elementPositionInGrid, 
     81                                                                 elementPositionInGridSrc2ScalarPosition_, 
     82                                                                 elementPositionInGridSrc2AxisPosition_, 
     83                                                                 elementPositionInGridSrc2DomainPosition_, 
     84                                                                 elementPositionInGridDst2ScalarPosition_, 
     85                                                                 elementPositionInGridDst2AxisPosition_, 
     86                                                                 elementPositionInGridDst2DomainPosition_); 
    11987  algoTransformation_.push_back(algo); 
    12088} 
    12189 
    12290/*! 
    123   Select algorithm of a domain correspoding to its transformation type and its position in each element 
     91  Select algorithm of a domain corresponding to its transformation type and its position in each element 
    12492  \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 
    12593  \param [in] transType transformation type, for now we have zoom_domain, interpolate_domain 
    … …  
    12997{ 
    13098  std::vector<CDomain*> domainListDestP = gridDestination_->getDomains(); 
    131   std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
    132  
    13399  int domainIndex =  elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    134100  CDomain::TransMapTypes trans = domainListDestP[domainIndex]->getAllTransformations(); 
    135101  CDomain::TransMapTypes::const_iterator it = trans.begin(); 
    136  
    137102  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation 
    138103 
    139   CZoomDomain* zoomDomain = 0; 
    140   CInterpolateDomain* interpFileDomain = 0; 
    141104  CGenericAlgorithmTransformation* algo = 0; 
    142   switch (transType) 
    143   { 
    144     case TRANS_INTERPOLATE_DOMAIN: 
    145       interpFileDomain = dynamic_cast<CInterpolateDomain*> (it->second); 
    146       algo = new CDomainAlgorithmInterpolate(domainListDestP[domainIndex], domainListSrcP[domainIndex],interpFileDomain); 
    147       break; 
    148     case TRANS_ZOOM_DOMAIN: 
    149       zoomDomain = dynamic_cast<CZoomDomain*> (it->second); 
    150       algo = new CDomainAlgorithmZoom(domainListDestP[domainIndex], domainListSrcP[domainIndex], zoomDomain); 
    151       break; 
    152     default: 
    153       break; 
    154   } 
     105  algo = CGridTransformationFactory<CDomain>::createTransformation(transType, 
     106                                                                   gridDestination_, 
     107                                                                   gridSource_, 
     108                                                                   it->second, 
     109                                                                   elementPositionInGrid, 
     110                                                                   elementPositionInGridSrc2ScalarPosition_, 
     111                                                                   elementPositionInGridSrc2AxisPosition_, 
     112                                                                   elementPositionInGridSrc2DomainPosition_, 
     113                                                                   elementPositionInGridDst2ScalarPosition_, 
     114                                                                   elementPositionInGridDst2AxisPosition_, 
     115                                                                   elementPositionInGridDst2DomainPosition_); 
    155116  algoTransformation_.push_back(algo); 
    156117} 
    … …  
    162123  \param [in] transType transformation type 
    163124*/ 
    164 void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType, int nbTransformation) 
     125void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType, AlgoType algoType) 
    165126{ 
    166127  if (isSpecialTransformation(transType)) return; 
    … …  
    184145 
    185146  int scalarIndex = -1, axisIndex = -1, domainIndex = -1; 
    186   switch (transType) 
    187   { 
    188     case TRANS_INTERPOLATE_DOMAIN: 
    189     case TRANS_ZOOM_DOMAIN: 
     147  switch (algoType) 
     148  { 
     149    case domainType: 
    190150      domainIndex = elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    191151      break; 
    192  
    193     case TRANS_INTERPOLATE_AXIS: 
    194     case TRANS_ZOOM_AXIS: 
    195     case TRANS_INVERSE_AXIS: 
    196     case TRANS_REDUCE_DOMAIN_TO_AXIS: 
    197     case TRANS_EXTRACT_DOMAIN_TO_AXIS: 
     152    case axisType: 
    198153      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    199154      break; 
    200  
    201     case TRANS_REDUCE_AXIS_TO_SCALAR: 
     155    case scalarType: 
    202156      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
    203157      break; 
    … …  
    244198  \param [in] transType transformation type 
    245199*/ 
    246 void CGridTransformation::setUpGridSource(int elementPositionInGrid, ETranformationType transType, int nbTransformation) 
     200void CGridTransformation::setUpGridSource(int elementPositionInGrid, AlgoType algoType) 
    247201{ 
    248202  if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size()) 
    … …  
    264218  int axisIndex = -1, domainIndex = -1, scalarIndex = -1; 
    265219  int axisListIndex = 0, domainListIndex = 0, scalarListIndex = 0; 
    266   switch (transType) 
    267   { 
    268     case TRANS_INTERPOLATE_DOMAIN: 
    269     case TRANS_ZOOM_DOMAIN: 
     220  switch (algoType) 
     221  { 
     222    case domainType: 
    270223      domainIndex = elementPositionInGridDst2DomainPosition_[elementPositionInGrid]; 
    271224      break; 
    272  
    273     case TRANS_INTERPOLATE_AXIS: 
    274     case TRANS_ZOOM_AXIS: 
    275     case TRANS_INVERSE_AXIS: 
    276     case TRANS_REDUCE_DOMAIN_TO_AXIS: 
    277     case TRANS_EXTRACT_DOMAIN_TO_AXIS: 
     225    case axisType: 
    278226      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    279227      break; 
    280  
    281     case TRANS_REDUCE_AXIS_TO_SCALAR: 
     228    case scalarType: 
    282229      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
    283230      break; 
    … …  
    378325    int transformationOrder = (it->second).second; 
    379326    SourceDestinationIndexMap globaIndexWeightFromSrcToDst; 
     327    AlgoType algoType = algoTypes_[std::distance(itb, it)]; 
    380328 
    381329    // Create a temporary grid destination which contains transformed element of grid destination and 
    382     // non-transformed elements fo grid source 
    383     setUpGridDestination(elementPositionInGrid, transType, nbAgloTransformation); 
     330    // non-transformed elements to grid source 
     331    setUpGridDestination(elementPositionInGrid, transType, algoType); 
    384332 
    385333    // First of all, select an algorithm 
    386334    if (!dynamicalTransformation_ || (algoTransformation_.size() < listAlgos_.size())) 
    387335    { 
    388       selectAlgo(elementPositionInGrid, transType, transformationOrder, algoTypes_[std::distance(itb, it)]); 
     336      selectAlgo(elementPositionInGrid, transType, transformationOrder, algoType); 
    389337      algo = algoTransformation_.back(); 
    390338    } 
    … …  
    392340      algo = algoTransformation_[std::distance(itb, it)]; 
    393341 
    394     if (0 != algo) // Only registered transformation can be executed 
     342    if ((0 != algo) && (CGenericAlgorithmTransformation::ELEMENT_NO_MODIFICATION_WITH_DATA == algo->type())) // Only registered transformation can be executed 
    395343    { 
    396344      algo->computeIndexSourceMapping(dataAuxInputs); 
    … …  
    409357      { 
    410358        // Now grid destination becomes grid source in a new transformation 
    411         if (nbAgloTransformation != (nbNormalAlgos_-1)) setUpGridSource(elementPositionInGrid, transType, nbAgloTransformation); 
     359        if (nbAgloTransformation != (nbNormalAlgos_-1)) setUpGridSource(elementPositionInGrid, algoType); 
    412360      } 
    413361      ++nbAgloTransformation; 
Note: See TracChangeset for help on using the changeset viewer.