Changeset 933


Ignore:
Timestamp:
09/22/16 10:58:32 (4 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

Location:
XIOS/trunk/src/transformation
Files:
2 added
23 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/transformation/axis_algorithm_extract_domain.cpp

    r918 r933  
    1111#include "axis.hpp" 
    1212#include "domain.hpp" 
     13#include "grid.hpp" 
     14#include "grid_transformation_factory_impl.hpp" 
    1315 
    1416#include "sum.hpp" 
    1517 
    1618namespace xios { 
     19CGenericAlgorithmTransformation* CAxisAlgorithmExtractDomain::create(CGrid* gridDst, CGrid* gridSrc, 
     20                                                                     CTransformation<CAxis>* transformation, 
     21                                                                     int elementPositionInGrid, 
     22                                                                     std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     23                                                                     std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     24                                                                     std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     25                                                                     std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     26                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     27                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     28{ 
     29  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     30  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains(); 
     31 
     32  CExtractDomainToAxis* extractDomain = dynamic_cast<CExtractDomainToAxis*> (transformation); 
     33  int axisDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     34  int domainSrcIndex = elementPositionInGridSrc2DomainPosition[elementPositionInGrid]; 
     35 
     36  return (new CAxisAlgorithmExtractDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], extractDomain)); 
     37} 
     38 
     39//bool CAxisAlgorithmExtractDomain::_dummyRegistered = CAxisAlgorithmExtractDomain::registerTrans(); 
     40bool CAxisAlgorithmExtractDomain::registerTrans() 
     41{ 
     42  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_EXTRACT_DOMAIN_TO_AXIS, create); 
     43} 
     44 
    1745 
    1846CAxisAlgorithmExtractDomain::CAxisAlgorithmExtractDomain(CAxis* axisDestination, CDomain* domainSource, CExtractDomainToAxis* algo) 
  • XIOS/trunk/src/transformation/axis_algorithm_extract_domain.hpp

    r918 r933  
    1111 
    1212#include "axis_algorithm_transformation.hpp" 
     13#include "transformation.hpp" 
    1314 
    1415namespace xios { 
     
    1819class CExtractDomainToAxis; 
    1920class CReductionAlgorithm; 
     21 
    2022 
    2123/*! 
     
    3638  virtual ~CAxisAlgorithmExtractDomain(); 
    3739 
     40  static bool registerTrans(); 
    3841protected: 
    3942  enum ExtractDirection { 
     
    5154  CReductionAlgorithm* reduction_; 
    5255 
     56private: 
     57  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     58                                                CTransformation<CAxis>* transformation, 
     59                                                int elementPositionInGrid, 
     60                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     61                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     62                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     63                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     64                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     65                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    5366}; 
    5467 
  • XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp

    r918 r933  
    88 */ 
    99#include "axis_algorithm_interpolate.hpp" 
     10#include "axis.hpp" 
     11#include "interpolate_axis.hpp" 
    1012#include <algorithm> 
    1113#include "context.hpp" 
     
    1315#include "utils.hpp" 
    1416#include "grid.hpp" 
     17#include "grid_transformation_factory_impl.hpp" 
    1518#include "distribution_client.hpp" 
    1619 
    1720namespace xios { 
     21CGenericAlgorithmTransformation* CAxisAlgorithmInterpolate::create(CGrid* gridDst, CGrid* gridSrc, 
     22                                                                   CTransformation<CAxis>* transformation, 
     23                                                                   int elementPositionInGrid, 
     24                                                                   std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     25                                                                   std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     26                                                                   std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     27                                                                   std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     28                                                                   std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     29                                                                   std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     30{ 
     31  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     32  std::vector<CAxis*> axisListSrcP  = gridSrc->getAxis(); 
     33 
     34  CInterpolateAxis* interpolateAxis = dynamic_cast<CInterpolateAxis*> (transformation); 
     35  int axisDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     36  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
     37 
     38  return (new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpolateAxis)); 
     39} 
     40 
     41bool CAxisAlgorithmInterpolate::registerTrans() 
     42{ 
     43  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INTERPOLATE_AXIS, create); 
     44} 
     45 
    1846 
    1947CAxisAlgorithmInterpolate::CAxisAlgorithmInterpolate(CAxis* axisDestination, CAxis* axisSource, CInterpolateAxis* interpAxis) 
  • XIOS/trunk/src/transformation/axis_algorithm_interpolate.hpp

    r912 r933  
    1111 
    1212#include "axis_algorithm_transformation.hpp" 
    13 #include "axis.hpp" 
    14 #include "interpolate_axis.hpp" 
     13#include "transformation.hpp" 
    1514 
    1615namespace xios { 
     16 
     17class CAxis; 
     18class CGrid; 
     19class CInterpolateAxis; 
     20 
    1721/*! 
    1822  \class CAxisAlgorithmInterpolate 
     
    2731  virtual ~CAxisAlgorithmInterpolate() {} 
    2832 
     33  static bool registerTrans(); 
    2934protected: 
    3035  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
     
    4348  StdString coordinate_; 
    4449  std::vector<std::vector<int> > transPosition_; 
     50 
     51private: 
     52  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     53                                                CTransformation<CAxis>* transformation, 
     54                                                int elementPositionInGrid, 
     55                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     56                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     57                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     58                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     59                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     60                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    4561}; 
    4662 
  • XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

    r869 r933  
    1111#include "context_client.hpp" 
    1212#include "axis.hpp" 
     13#include "grid.hpp" 
     14#include "grid_transformation_factory_impl.hpp" 
     15#include "inverse_axis.hpp" 
    1316#include "client_client_dht_template.hpp" 
    1417 
    1518namespace xios { 
    1619 
    17 CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource) 
     20CGenericAlgorithmTransformation* CAxisAlgorithmInverse::create(CGrid* gridDst, CGrid* gridSrc, 
     21                                                               CTransformation<CAxis>* transformation, 
     22                                                               int elementPositionInGrid, 
     23                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     24                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     25                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     26                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     27                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     28                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     29{ 
     30  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     31  std::vector<CAxis*> axisListSrcP  = gridSrc->getAxis(); 
     32 
     33  CInverseAxis* inverseAxis = dynamic_cast<CInverseAxis*> (transformation); 
     34  int axisDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     35  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
     36 
     37  return (new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], inverseAxis)); 
     38} 
     39 
     40bool CAxisAlgorithmInverse::registerTrans() 
     41{ 
     42  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_INVERSE_AXIS, create); 
     43} 
     44 
     45 
     46CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis) 
    1847 : CAxisAlgorithmTransformation(axisDestination, axisSource) 
    1948{ 
  • XIOS/trunk/src/transformation/axis_algorithm_inverse.hpp

    r869 r933  
    1111 
    1212#include "axis_algorithm_transformation.hpp" 
     13#include "transformation.hpp" 
    1314 
    1415namespace xios { 
    1516 
    16   class CAxis; 
     17class CAxis; 
     18class CInverseAxis; 
     19 
    1720/*! 
    1821  \class CAxisAlgorithmInverse 
     
    2225{ 
    2326public: 
    24   CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource); 
     27  CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis); 
    2528 
    2629  virtual ~CAxisAlgorithmInverse() {} 
     30 
     31  static bool registerTrans(); 
    2732 
    2833protected: 
     
    3136private: 
    3237  void updateAxisValue(); 
     38 
     39private: 
     40  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     41                                                CTransformation<CAxis>* transformation, 
     42                                                int elementPositionInGrid, 
     43                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     44                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     45                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     46                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     47                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     48                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    3349}; 
    3450 
  • XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.cpp

    r918 r933  
    1111#include "axis.hpp" 
    1212#include "domain.hpp" 
     13#include "grid.hpp" 
     14#include "grid_transformation_factory_impl.hpp" 
    1315 
    1416#include "sum.hpp" 
    1517 
    1618namespace xios { 
     19CGenericAlgorithmTransformation* CAxisAlgorithmReduceDomain::create(CGrid* gridDst, CGrid* gridSrc, 
     20                                                                   CTransformation<CAxis>* transformation, 
     21                                                                   int elementPositionInGrid, 
     22                                                                   std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     23                                                                   std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     24                                                                   std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     25                                                                   std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     26                                                                   std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     27                                                                   std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     28{ 
     29  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     30  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains(); 
     31 
     32  CReduceDomainToAxis* reduceDomain = dynamic_cast<CReduceDomainToAxis*> (transformation); 
     33  int axisDstIndex   = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     34  int domainSrcIndex = elementPositionInGridSrc2DomainPosition[elementPositionInGrid]; 
     35 
     36  return (new CAxisAlgorithmReduceDomain(axisListDestP[axisDstIndex], domainListSrcP[domainSrcIndex], reduceDomain)); 
     37} 
     38 
     39bool CAxisAlgorithmReduceDomain::registerTrans() 
     40{ 
     41  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_REDUCE_DOMAIN_TO_AXIS, create); 
     42} 
     43 
    1744 
    1845CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo) 
  • XIOS/trunk/src/transformation/axis_algorithm_reduce_domain.hpp

    r918 r933  
    1111 
    1212#include "axis_algorithm_transformation.hpp" 
     13#include "transformation.hpp" 
    1314 
    1415namespace xios { 
     
    3637  virtual ~CAxisAlgorithmReduceDomain(); 
    3738 
     39  static bool registerTrans(); 
    3840protected: 
    3941  enum ReduceDirection { 
     
    5052  CReductionAlgorithm* reduction_; 
    5153 
     54private: 
     55  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     56                                                CTransformation<CAxis>* transformation, 
     57                                                int elementPositionInGrid, 
     58                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     59                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     60                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     61                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     62                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     63                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    5264}; 
    5365 
  • XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp

    r833 r933  
    88 */ 
    99#include "axis_algorithm_zoom.hpp" 
     10#include "axis.hpp" 
     11#include "grid.hpp" 
     12#include "grid_transformation_factory_impl.hpp" 
     13#include "zoom_axis.hpp" 
    1014 
    1115namespace xios { 
     16CGenericAlgorithmTransformation* CAxisAlgorithmZoom::create(CGrid* gridDst, CGrid* gridSrc, 
     17                                                           CTransformation<CAxis>* transformation, 
     18                                                           int elementPositionInGrid, 
     19                                                           std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     20                                                           std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     21                                                           std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     22                                                           std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     23                                                           std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     24                                                           std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     25{ 
     26  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
     27  std::vector<CAxis*> axisListSrcP  = gridSrc->getAxis(); 
     28 
     29  CZoomAxis* zoomAxis = dynamic_cast<CZoomAxis*> (transformation); 
     30  int axisDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     31  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
     32 
     33  return (new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis)); 
     34} 
     35bool CAxisAlgorithmZoom::registerTrans() 
     36{ 
     37  CGridTransformationFactory<CAxis>::registerTransformation(TRANS_ZOOM_AXIS, create); 
     38} 
    1239 
    1340CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis) 
     
    2653           << "Zoom size is " << zoomSize_ ); 
    2754  } 
    28  
    29 //  computeIndexSourceMapping(); 
    3055} 
    3156 
  • XIOS/trunk/src/transformation/axis_algorithm_zoom.hpp

    r827 r933  
    1111 
    1212#include "axis_algorithm_transformation.hpp" 
    13 #include "axis.hpp" 
    14 #include "zoom_axis.hpp" 
     13#include "transformation.hpp" 
    1514 
    1615namespace xios { 
     16class CAxis; 
     17class CZoomAxis; 
     18 
    1719/*! 
    1820  \class CAxisAlgorithmZoom 
    1921  Implementing zoom on axis 
    20   A zoomed region can be considered as region that isnt masked. 
     22  A zoomed region can be considered as region that isn't masked. 
    2123  Only this zoomed region is extracted to write on Netcdf. 
    2224*/ 
     
    2830  virtual ~CAxisAlgorithmZoom() {} 
    2931 
     32  static bool registerTrans(); 
    3033protected: 
    3134  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
     
    4447  //! Global zoom size on axis 
    4548  StdSize zoomSize_; 
     49 
     50private: 
     51 
     52  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     53                                                CTransformation<CAxis>* transformation, 
     54                                                int elementPositionInGrid, 
     55                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     56                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     57                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     58                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     59                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     60                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    4661}; 
    4762 
  • XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp

    r827 r933  
    2121: CDomainAlgorithmTransformation(domainDestination, domainSource), nbDomainDistributedPart_(0) 
    2222{ 
     23  type_ = ELEMENT_GENERATION; 
    2324  genRectDomain->checkValid(domainDestination); 
    2425  if (0 != gridSource) computeDistributionGridSource(gridSource); 
  • XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp

    r915 r933  
    1616#include "mapper.hpp" 
    1717#include "mpi_tag.hpp" 
     18#include "domain.hpp" 
     19#include "grid_transformation_factory_impl.hpp" 
     20#include "interpolate_domain.hpp" 
     21#include "grid.hpp" 
    1822 
    1923namespace xios { 
     24CGenericAlgorithmTransformation* CDomainAlgorithmInterpolate::create(CGrid* gridDst, CGrid* gridSrc, 
     25                                                                     CTransformation<CDomain>* transformation, 
     26                                                                     int elementPositionInGrid, 
     27                                                                     std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     28                                                                     std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     29                                                                     std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     30                                                                     std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     31                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     32                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     33{ 
     34  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     35  std::vector<CDomain*> domainListSrcP  = gridSrc->getDomains(); 
     36 
     37  CInterpolateDomain* interpolateDomain = dynamic_cast<CInterpolateDomain*> (transformation); 
     38  int domainDstIndex = elementPositionInGridDst2AxisPosition[elementPositionInGrid]; 
     39  int domainSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
     40 
     41  return (new CDomainAlgorithmInterpolate(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], interpolateDomain)); 
     42} 
     43 
     44bool CDomainAlgorithmInterpolate::registerTrans() 
     45{ 
     46  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_INTERPOLATE_DOMAIN, create); 
     47} 
    2048 
    2149CDomainAlgorithmInterpolate::CDomainAlgorithmInterpolate(CDomain* domainDestination, CDomain* domainSource, CInterpolateDomain* interpDomain) 
  • XIOS/trunk/src/transformation/domain_algorithm_interpolate.hpp

    r856 r933  
    1111 
    1212#include "domain_algorithm_transformation.hpp" 
    13 #include "domain.hpp" 
    14 #include "interpolate_domain.hpp" 
     13#include "transformation.hpp" 
    1514 
    1615namespace xios { 
     16 
     17class CDomain; 
     18class CInterpolateDomain; 
     19 
    1720/*! 
    1821  \class CDomainAlgorithmInterpolate 
     
    2629  virtual ~CDomainAlgorithmInterpolate() {} 
    2730 
     31  static bool registerTrans(); 
    2832protected: 
    2933  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
     
    3943  CInterpolateDomain* interpDomain_; 
    4044 
     45private: 
     46 
     47  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     48                                                CTransformation<CDomain>* transformation, 
     49                                                int elementPositionInGrid, 
     50                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     51                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     52                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     53                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     54                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     55                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    4156}; 
    4257 
  • XIOS/trunk/src/transformation/domain_algorithm_zoom.cpp

    r833 r933  
    88 */ 
    99#include "domain_algorithm_zoom.hpp" 
     10#include "zoom_domain.hpp" 
     11#include "domain.hpp" 
     12#include "grid.hpp" 
     13#include "grid_transformation_factory_impl.hpp" 
    1014 
    1115namespace xios { 
     16CGenericAlgorithmTransformation* CDomainAlgorithmZoom::create(CGrid* gridDst, CGrid* gridSrc, 
     17                                                             CTransformation<CDomain>* transformation, 
     18                                                             int elementPositionInGrid, 
     19                                                             std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     20                                                             std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     21                                                             std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     22                                                             std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     23                                                             std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     24                                                             std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     25{ 
     26  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
     27  std::vector<CDomain*> domainListSrcP  = gridSrc->getDomains(); 
     28 
     29  CZoomDomain* zoomDomain = dynamic_cast<CZoomDomain*> (transformation); 
     30  int domainDstIndex = elementPositionInGridDst2DomainPosition[elementPositionInGrid]; 
     31  int domainSrcIndex = elementPositionInGridSrc2DomainPosition[elementPositionInGrid]; 
     32 
     33  return (new CDomainAlgorithmZoom(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], zoomDomain)); 
     34} 
     35 
     36bool CDomainAlgorithmZoom::registerTrans() 
     37{ 
     38  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_ZOOM_DOMAIN, create); 
     39} 
    1240 
    1341CDomainAlgorithmZoom::CDomainAlgorithmZoom(CDomain* domainDestination, CDomain* domainSource, CZoomDomain* zoomDomain) 
     
    3967           << "Zoom size is " << zoomNj_ ); 
    4068  } 
    41  
    42 //  computeIndexSourceMapping(); 
    4369} 
    4470 
     
    75101  TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
    76102 
    77 //  std::map<int, std::vector<int> >& transMap = this->transformationMapping_; 
    78 //  std::map<int, std::vector<double> >& transWeight = this->transformationWeight_; 
    79103  int domainGlobalIndex; 
    80104  for (int j = 0; j < nj; ++j) 
  • XIOS/trunk/src/transformation/domain_algorithm_zoom.hpp

    r827 r933  
    1111 
    1212#include "domain_algorithm_transformation.hpp" 
    13 #include "zoom_domain.hpp" 
    14 #include "domain.hpp" 
     13#include "transformation.hpp" 
    1514 
    1615namespace xios { 
     16 
     17class CDomain; 
     18class CZoomDomain; 
     19 
    1720/*! 
    1821  \class CDomainAlgorithmZoom 
     
    2831  virtual ~CDomainAlgorithmZoom() {} 
    2932 
     33  static bool registerTrans(); 
    3034protected: 
    3135  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
     
    4751  int zoomNi_; 
    4852  int zoomNj_; 
     53 
     54private: 
     55 
     56  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     57                                                CTransformation<CDomain>* transformation, 
     58                                                int elementPositionInGrid, 
     59                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     60                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     61                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     62                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     63                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     64                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    4965}; 
    5066 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r918 r933  
    1515 
    1616CGenericAlgorithmTransformation::CGenericAlgorithmTransformation() 
    17  : transformationMapping_(), transformationWeight_(), transformationPosition_(), idAuxInputs_() 
     17 : transformationMapping_(), transformationWeight_(), transformationPosition_(), 
     18   idAuxInputs_(), type_(ELEMENT_NO_MODIFICATION_WITH_DATA) 
    1819{ 
    1920} 
     
    658659} 
    659660 
    660 } 
     661CGenericAlgorithmTransformation::AlgoTransType CGenericAlgorithmTransformation::type() 
     662{ 
     663  return type_; 
     664} 
     665 
     666} 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

    r918 r933  
    2323  /*! 
    2424  \class CGenericAlgorithmTransformation 
    25   This class defines the interface for all other inherted algorithms class 
     25  This class defines the interface for all other inherited algorithms class 
    2626  */ 
    2727class CGenericAlgorithmTransformation 
    2828{ 
    29 protected: 
    30   typedef std::vector<std::pair<int, std::pair<size_t,double> > > DestinationGlobalIndex; 
    3129public: 
    32   // Stupid global index map, it must be replaced by tuple 
     30  enum AlgoTransType { 
     31    ELEMENT_GENERATION = 0, 
     32    ELEMENT_MODIFICATION_WITHOUT_DATA = 1, 
     33    ELEMENT_MODIFICATION_WITH_DATA = 2, 
     34    ELEMENT_NO_MODIFICATION_WITH_DATA = 3, 
     35    ELEMENT_NO_MODIFICATION_WITHOUT_DATA = 4 
     36  } ; 
     37 
     38public: 
    3339  // Mapping between global index map of DESTINATION and its local index with pair of global index of SOURCE and weights 
    34   typedef boost::unordered_map<size_t, DestinationGlobalIndex> DestinationIndexMap; 
    35   // 
    3640  typedef boost::unordered_map<int, boost::unordered_map<size_t, std::vector<std::pair<size_t,double> > > > SourceDestinationIndexMap; 
    3741 
     
    5458 
    5559    /*! 
    56     Apply a reduction operation on local data. 
     60    Apply a operation on local data. 
    5761    \param [in] localIndex vector contains local index of local data output and the corresponding weight 
    5862    \param [in] dataInput Pointer to the first element of data input array (in form of buffer) 
     
    6771 
    6872  std::vector<StdString> getIdAuxInputs(); 
    69  
     73  AlgoTransType type(); 
    7074  /*! 
    7175  Compute global index mapping from one element of destination grid to the corresponding element of source grid 
     
    123127  //! Id of auxillary inputs which helps doing transformation dynamically 
    124128  std::vector<StdString> idAuxInputs_; 
     129  AlgoTransType type_; 
     130 
    125131 
    126132  std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_; 
  • 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; 
  • XIOS/trunk/src/transformation/grid_transformation.hpp

    r887 r933  
    3737  typedef std::map<int,std::vector<std::pair<int,double> > > RecvIndexGridDestinationMap; 
    3838  typedef CGenericAlgorithmTransformation::SourceDestinationIndexMap SourceDestinationIndexMap; 
     39  typedef CGenericAlgorithmTransformation::AlgoTransType AlgoTransType; 
    3940 
    4041public: 
     
    6061  virtual void selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder); 
    6162 
    62   void setUpGridSource(int elementPositionInGrid, ETranformationType transType, int nbTransformation); 
    63   void setUpGridDestination(int elementPositionInGrid, ETranformationType transType, int nbTransformation); 
     63  void setUpGridSource(int elementPositionInGrid, AlgoType); 
     64  void setUpGridDestination(int elementPositionInGrid, ETranformationType, AlgoType); 
    6465  void computeTransformationMapping(const SourceDestinationIndexMap& globalIndexWeightFromSrcToDest); 
    6566 
     
    7172 
    7273protected: 
    73   //! Mapping of (grid) global index representing tranformation. 
     74  //! Mapping of (grid) global index representing transformation. 
    7475  std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource_; 
    7576 
  • XIOS/trunk/src/transformation/grid_transformation_selector.cpp

    r897 r933  
    99#include "grid_transformation_selector.hpp" 
    1010#include "grid.hpp" 
    11 //#include <boost/unordered_map.hpp> 
     11#include "algo_types.hpp" 
    1212 
    1313namespace xios { 
     
    2727       << "Number of elements of grid source " <<gridSource_->getId() << " is " << gridSource_->axis_domain_order.numElements()  << std::endl 
    2828       << "Number of elements of grid destination " <<gridDestination_->getId() << " is " << numElement); 
     29  registerTransformations(); 
    2930  initializeTransformations(type); 
    3031} 
     
    306307} 
    307308 
    308 } 
     309 
     310void CGridTransformationSelector::registerTransformations() 
     311{ 
     312  //! Scalar 
     313  CScalarAlgorithmReduceScalar::registerTrans(); 
     314 
     315  //! Axis 
     316  CAxisAlgorithmZoom::registerTrans(); 
     317  CAxisAlgorithmExtractDomain::registerTrans(); 
     318  CAxisAlgorithmInterpolate::registerTrans(); 
     319  CAxisAlgorithmInverse::registerTrans(); 
     320  CAxisAlgorithmReduceDomain::registerTrans(); 
     321 
     322  //! Domain 
     323//  CDomainAlgorithmComputeConnectivity::registerTrans(); 
     324  CDomainAlgorithmInterpolate::registerTrans(); 
     325  CDomainAlgorithmZoom::registerTrans(); 
     326 
     327} 
     328 
     329} 
  • XIOS/trunk/src/transformation/grid_transformation_selector.hpp

    r897 r933  
    2222/*! 
    2323  \class CGridTransformationSelector 
    24   This class is a helper class to chose a algorithm (transformation) from the alogrithm list of 
     24  This class is a helper class to chose a algorithm (transformation) from the algorithm list of 
    2525specific grid. 
    2626*/ 
     
    5757  void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, AlgoType algo); 
    5858  bool isSpecialTransformation(ETranformationType transType); 
     59  void registerTransformations(); 
    5960 
    6061protected: 
  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.cpp

    r918 r933  
    1212#include "reduce_axis_to_scalar.hpp" 
    1313#include "sum.hpp" 
     14#include "grid.hpp" 
     15#include "grid_transformation_factory_impl.hpp" 
    1416 
    1517namespace xios { 
     18CGenericAlgorithmTransformation* CScalarAlgorithmReduceScalar::create(CGrid* gridDst, CGrid* gridSrc, 
     19                                                                     CTransformation<CScalar>* transformation, 
     20                                                                     int elementPositionInGrid, 
     21                                                                     std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     22                                                                     std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     23                                                                     std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     24                                                                     std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     25                                                                     std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     26                                                                     std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     27{ 
     28  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
     29  std::vector<CAxis*> axisListSrcP  = gridSrc->getAxis(); 
     30 
     31  CReduceAxisToScalar* reduceAxis = dynamic_cast<CReduceAxisToScalar*> (transformation); 
     32  int scalarDstIndex = elementPositionInGridDst2ScalarPosition[elementPositionInGrid]; 
     33  int axisSrcIndex = elementPositionInGridSrc2AxisPosition[elementPositionInGrid]; 
     34 
     35  return (new CScalarAlgorithmReduceScalar(scalarListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis)); 
     36} 
     37 
     38bool CScalarAlgorithmReduceScalar::registerTrans() 
     39{ 
     40  CGridTransformationFactory<CScalar>::registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, create); 
     41} 
    1642 
    1743CScalarAlgorithmReduceScalar::CScalarAlgorithmReduceScalar(CScalar* scalarDestination, CAxis* axisSource, CReduceAxisToScalar* algo) 
  • XIOS/trunk/src/transformation/scalar_algorithm_reduce_axis.hpp

    r918 r933  
    1111 
    1212#include "scalar_algorithm_transformation.hpp" 
     13#include "transformation.hpp" 
    1314 
    1415namespace xios { 
     
    2122/*! 
    2223  \class CScalarAlgorithmReduceScalar 
    23   Inversing an axis to a scalar 
     24  Reducing an axis to a scalar 
    2425*/ 
    2526class CScalarAlgorithmReduceScalar : public CScalarAlgorithmTransformation 
     
    3637  virtual ~CScalarAlgorithmReduceScalar(); 
    3738 
     39  static bool registerTrans(); 
    3840protected: 
    3941  void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
     
    4244  CReductionAlgorithm* reduction_; 
    4345 
     46private: 
     47 
     48  static CGenericAlgorithmTransformation* create(CGrid* gridDst, CGrid* gridSrc, 
     49                                                CTransformation<CScalar>* transformation, 
     50                                                int elementPositionInGrid, 
     51                                                std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     52                                                std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     53                                                std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     54                                                std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     55                                                std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     56                                                std::map<int, int>& elementPositionInGridDst2DomainPosition); 
    4457}; 
    4558 
Note: See TracChangeset for help on using the changeset viewer.