Ignore:
Timestamp:
01/12/21 23:05:02 (3 years ago)
Author:
ymipsl
Message:
  • bug fix when createing mask on server side when overlapping grid
  • implement axis interpolation on pressure coordinate
  • big cleaning in transformation

YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src/node
Files:
44 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/compute_connectivity_domain.cpp

    r1984 r2011  
    11#include "compute_connectivity_domain.hpp" 
     2#include "domain_algorithm_compute_connectivity.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    5152  } 
    5253 
     54  CGenericAlgorithmTransformation* CComputeConnectivityDomain::createAlgorithm(bool isSource, 
     55                                                        CGrid* gridDst, CGrid* gridSrc, 
     56                                                        int elementPositionInGrid, 
     57                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     58                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     59                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     60                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     61                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     62                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     63  { 
     64    return CDomainAlgorithmComputeConnectivity::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     65                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     66                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     67  } 
    5368} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/compute_connectivity_domain.hpp

    r1984 r2011  
    2020  class CComputeConnectivityDomain; 
    2121  class CDomain; 
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2224 
    2325  ///-------------------------------------------------------------- 
    … …  
    6264      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6365      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     66      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     67                                                               CGrid* gridDst, CGrid* gridSrc, 
     68                                                               int elementPositionInGrid, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     71                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     74                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6475    private: 
    6576      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/duplicate_scalar_to_axis.cpp

    r1984 r2011  
    11#include "duplicate_scalar_to_axis.hpp" 
     2#include "axis_algorithm_duplicate_scalar.hpp" 
    23#include "type.hpp" 
    34#include "axis.hpp" 
    … …  
    4344    
    4445  } 
    45  
     46   
     47  CGenericAlgorithmTransformation* CDuplicateScalarToAxis::createAlgorithm(bool isSource, 
     48                                                        CGrid* gridDst, CGrid* gridSrc, 
     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) 
     56  { 
     57    return CAxisAlgorithmDuplicateScalar::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
     58                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     59                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     60  } 
    4661} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/duplicate_scalar_to_axis.hpp

    r1984 r2011  
    2020  class CAxis; 
    2121  class CScalar; 
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2224 
    2325  ///-------------------------------------------------------------- 
    … …  
    6264      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6365      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     66      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     67                                                               CGrid* gridDst, CGrid* gridSrc, 
     68                                                               int elementPositionInGrid, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     71                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     74                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6475    private: 
    6576      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/expand_domain.cpp

    r1984 r2011  
    11#include "expand_domain.hpp" 
     2#include "domain_algorithm_expand.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    4748    if (this->type.isEmpty()) this->type.setValue(CExpandDomain::type_attr::edge); 
    4849  } 
    49  
     50   
     51  CGenericAlgorithmTransformation* CExpandDomain::createAlgorithm(bool isSource, 
     52                                                        CGrid* gridDst, CGrid* gridSrc, 
     53                                                        int elementPositionInGrid, 
     54                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     55                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     56                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     57                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     58                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     59                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     60  { 
     61    return CDomainAlgorithmExpand::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     62                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     63                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     64  } 
    5065} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/expand_domain.hpp

    r1984 r2011  
    2020  class CExpandDomain; 
    2121  class CDomain; 
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2224 
    2325  ///-------------------------------------------------------------- 
    … …  
    6264      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6365      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     66      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     67                                                               CGrid* gridDst, CGrid* gridSrc, 
     68                                                               int elementPositionInGrid, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     71                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     74                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6475    private: 
    6576      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_axis.cpp

    r1984 r2011  
    11#include "extract_axis.hpp" 
     2#include "axis_algorithm_extract.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    7778  } 
    7879 
     80  CGenericAlgorithmTransformation* CExtractAxis::createAlgorithm(bool isSource, 
     81                                                        CGrid* gridDst, CGrid* gridSrc, 
     82                                                        int elementPositionInGrid, 
     83                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     84                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     85                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     86                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     87                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     88                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     89  { 
     90    return CAxisAlgorithmExtract::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
     91                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     92                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     93  } 
    7994} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_axis.hpp

    r1984 r2011  
    2020  class CExtractAxis; 
    2121  class CAxis; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_axis_to_scalar.cpp

    r1984 r2011  
    11#include "extract_axis_to_scalar.hpp" 
     2#include "scalar_algorithm_extract_axis.hpp" 
     3 
    24#include "type.hpp" 
    35#include "axis.hpp" 
    … …  
    5759  } 
    5860 
     61  CGenericAlgorithmTransformation* CExtractAxisToScalar::createAlgorithm(bool isSource, 
     62                                                        CGrid* gridDst, CGrid* gridSrc, 
     63                                                        int elementPositionInGrid, 
     64                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     65                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     66                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     67                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     68                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     69                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     70  { 
     71    return CScalarAlgorithmExtractAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     72                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     73                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     74  } 
    5975} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_axis_to_scalar.hpp

    r1984 r2011  
    2020  class CAxis; 
    2121  class CScalar; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_domain.cpp

    r1984 r2011  
    11#include "extract_domain.hpp" 
     2#include "domain_algorithm_extract.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    7273  } 
    7374 
     75  CGenericAlgorithmTransformation* CExtractDomain::createAlgorithm(bool isSource, 
     76                                                        CGrid* gridDst, CGrid* gridSrc, 
     77                                                        int elementPositionInGrid, 
     78                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     79                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     80                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     81                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     82                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     83                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     84  { 
     85    return CDomainAlgorithmExtract::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     86                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     87                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     88  } 
    7489} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_domain.hpp

    r1984 r2011  
    2020  class CExtractDomain; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474     private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_domain_to_axis.cpp

    r1984 r2011  
    11#include "extract_domain_to_axis.hpp" 
     2#include "axis_algorithm_extract_domain.hpp" 
    23#include "type.hpp" 
    34#include "axis.hpp" 
    … …  
    9899  } 
    99100 
     101  CGenericAlgorithmTransformation* CExtractDomainToAxis::createAlgorithm(bool isSource, 
     102                                                        CGrid* gridDst, CGrid* gridSrc, 
     103                                                        int elementPositionInGrid, 
     104                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     105                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     106                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     107                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     108                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     109                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     110  { 
     111    return CAxisAlgorithmExtractDomain::create(isSource, gridDst, gridSrc, this, elementPositionInGrid,  
     112                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     113                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     114  } 
    100115} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/extract_domain_to_axis.hpp

    r1984 r2011  
    2020  class CAxis; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.cpp

    r2002 r2011  
    383383  CATCH_DUMP_ATTR 
    384384 
    385   //---------------------------------------------------------------- 
    386  
    387   std::shared_ptr<COutputPin> CField::getInstantDataFilter() 
    388   TRY 
    389   { 
    390     return instantDataFilter; 
    391   } 
    392   CATCH_DUMP_ATTR 
    393  
     385   
    394386  //---------------------------------------------------------------- 
    395387 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.hpp

    r2002 r2011  
    107107         template <int N> void getData(CArray<double, N>& _data) const; 
    108108 
    109          std::shared_ptr<COutputPin> getInstantDataFilter(); 
    110  
    111109         std::map<int, StdSize> getGridAttributesBufferSize(CContextClient* client, bool bufferForWriting = false); 
    112110         // Grid data buffer size for each connection of contextclient 
    … …  
    352350         //! The output pin of the filter providing the instant data for the field 
    353351         std::shared_ptr<COutputPin> instantDataFilter; 
    354           
     352      public: 
     353          std::shared_ptr<COutputPin> getInstantDataFilter(void) { return instantDataFilter;} 
     354 
     355      private: 
     356 
    355357         //! The output pin of the filters providing the result of the field's temporal operation 
    356358         std::map<CDuration, std::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/generate_rectilinear_domain.cpp

    r1984 r2011  
    11#include "generate_rectilinear_domain.hpp" 
     2#include "domain_algorithm_generate_rectilinear.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    138139  } 
    139140 
     141  CGenericAlgorithmTransformation* CGenerateRectilinearDomain::createAlgorithm(bool isSource, 
     142                                                        CGrid* gridDst, CGrid* gridSrc, 
     143                                                        int elementPositionInGrid, 
     144                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     145                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     146                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     147                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     148                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     149                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     150  { 
     151    return CDomainAlgorithmGenerateRectilinear::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     152                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     153                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     154  } 
    140155} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/generate_rectilinear_domain.hpp

    r1984 r2011  
    2020  class CGenerateRectilinearDomain; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp

    r2007 r2011  
    1616#include "client_server_mapping_distributed.hpp" 
    1717#include "distribution_client.hpp" 
    18 #include "grid_transformation.hpp" 
    1918#include "server.hpp" 
    2019#include "distribution_type.hpp" 
    … …  
    4645      , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_() 
    4746            , isCompressible_(false) 
    48       , transformations_(0), isTransformed_(false) 
    4947      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false) 
    50       , gridSrc_(), hasTransform_(false), order_() 
     48      , gridSrc_(), order_() 
    5149      , clients() 
    5250   { 
    … …  
    6563      , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_() 
    6664            , isCompressible_(false) 
    67       , transformations_(0), isTransformed_(false) 
    6865      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false) 
    69       , gridSrc_(), hasTransform_(false), order_() 
     66      , gridSrc_(), order_() 
    7067      , clients() 
    7168   { 
    … …  
    7875   { 
    7976    if (0 != clientDistribution_) delete clientDistribution_; 
    80     if (0 != transformations_) delete transformations_; 
    8177   } 
    8278 
    … …  
    13631359 
    13641360    CArray<bool,1> maskOut ; 
    1365     gridGathererConnector.transfer(event,maskOut,false) ; 
     1361    gridGathererConnector.transfer_or(event,maskOut) ; 
    13661362    gridMaskConnector.computeConnector(maskOut) ; 
    13671363 
    … …  
    16881684  CATCH_DUMP_ATTR 
    16891685 
    1690    
    1691  
    1692   vector<std::string> CGrid::getAuxInputTransformGrid(void) 
    1693   TRY 
    1694   { 
    1695     if (transformations_ != nullptr) return transformations_->getAuxInputs() ; 
    1696   } 
    1697   CATCH_DUMP_ATTR 
    1698  
    16991686 
    17001687 
    … …  
    17101697                                        // big mystery why it doesn't work witout that... 
    17111698                                        // problem with the linker ??  
    1712      
     1699 
    17131700    std::shared_ptr<CFilter> inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc)); 
    17141701    std::shared_ptr<CFilter> outputFilter = inputFilter ; 
    … …  
    17921779            tmpGridDst->addDomain(dstDomain->getId()) ; 
    17931780 
     1781            algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,  
     1782                                                     posInGrid,posInGrid,posInGrid, 
     1783                                                     posInGrid,posInGrid,posInGrid ); 
    17941784            //reuse existing algorithm interface for, now 
    1795             algo = CGridTransformationFactory<CDomain>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
     1785         /*   algo = CGridTransformationFactory<CDomain>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
    17961786                                                                             transformation, 0,  
    17971787                                                                             posInGrid,posInGrid,posInGrid, 
    17981788                                                                             posInGrid,posInGrid,posInGrid ); 
     1789           */ 
    17991790            dstDomain->setTransformationAlgorithm(algo) ; 
    18001791            transformationPath.removeNextTransform() ; 
    … …  
    18191810            tmpGridDst->addAxis(dstAxis->getId()) ; 
    18201811 
     1812             algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,  
     1813                                                     posInGrid,posInGrid,posInGrid, 
     1814                                                     posInGrid,posInGrid,posInGrid ); 
     1815 
    18211816            //reuse existing algorithm interface for, now 
    1822             algo = CGridTransformationFactory<CAxis>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
     1817           /* algo = CGridTransformationFactory<CAxis>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
    18231818                                                                           transformation, 0,  
    18241819                                                                           posInGrid,posInGrid,posInGrid, 
    1825                                                                            posInGrid,posInGrid,posInGrid ); 
     1820                                                                           posInGrid,posInGrid,posInGrid );*/ 
    18261821            dstAxis->setTransformationAlgorithm(algo) ; 
    18271822            transformationPath.removeNextTransform() ; 
    … …  
    18461841            tmpGridDst->addScalar(dstScalar->getId()) ; 
    18471842 
     1843            algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,  
     1844                                                     posInGrid,posInGrid,posInGrid, 
     1845                                                     posInGrid,posInGrid,posInGrid ); 
    18481846            //reuse existing algorithm interface for, now 
    1849             algo = CGridTransformationFactory<CScalar>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
     1847           /* algo = CGridTransformationFactory<CScalar>::createTransformation(transType, false, tmpGridDst, tmpGridSrc, 
    18501848                                                                             transformation, 0,  
    18511849                                                                             posInGrid,posInGrid,posInGrid, 
    1852                                                                              posInGrid,posInGrid,posInGrid ); 
     1850                                                                             posInGrid,posInGrid,posInGrid );*/ 
    18531851            dstScalar->setTransformationAlgorithm(algo) ; 
    18541852            transformationPath.removeNextTransform() ; 
    … …  
    19171915    if (hadTransform) 
    19181916    { 
     1917       
    19191918      if (!isSource) 
    19201919      { 
    … …  
    19291928        shared_ptr<CTransformFilter> transformFilter = shared_ptr<CTransformFilter>(gridAlgorithm->createTransformFilter(gc, detectMissingValues, defaultValue)) ; 
    19301929        outputFilter->connectOutput(transformFilter,0) ; 
     1930        vector<string> auxFieldId = algo->getAuxFieldId() ; // better to do that at transformation not algo ?? 
     1931        int i=1;  
     1932        for (auto& it : auxFieldId) 
     1933        { 
     1934          CField* auxField = CField::get(it) ; 
     1935          auxField->buildWorkflowGraph(gc) ; 
     1936          auxField->getInstantDataFilter()->connectOutput(transformFilter,i) ; 
     1937          i++ ; 
     1938        } 
    19311939        outputFilter = transformFilter ; 
    19321940      } 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp

    r2002 r2011  
    3939   class CServerDistributionDescription; 
    4040   class CClientServerMapping; 
    41    class CGridTransformation; 
    42  
     41   
    4342   ///-------------------------------------------------------------- 
    4443 
    … …  
    215214         /////////////////////////////////////////// 
    216215      public: 
    217          CGridTransformation* getTransformations(); 
    218  
    219          std::vector<std::string> getAuxInputTransformGrid(void) ;  
    220          void setTransformationAlgorithms(); 
    221216         pair<shared_ptr<CFilter>, shared_ptr<CFilter> > buildTransformationGraph(CGarbageCollector& gc, bool isSource, CGrid* gridSrc, double detectMissingValues, 
    222217                                                                                  double defaultValue, CGrid*& newGrid) ; 
    … …  
    226221        void setGridAlgorithm(CGridAlgorithm* gridAlgorithm) {gridAlgorithm_ = gridAlgorithm;} 
    227222        CGridAlgorithm* getGridAlgorithm(void) { return gridAlgorithm_ ;} 
    228       private: 
    229          bool isTransformed_; 
    230          CGridTransformation* transformations_; 
    231          bool hasTransform_; 
    232223        
    233224        /////////////////////////////////////////// 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_axis.cpp

    r1984 r2011  
    11#include "interpolate_axis.hpp" 
     2#include "axis_algorithm_interpolate_coordinate.hpp" 
     3#include "axis_algorithm_interpolate.hpp" 
    24#include "type.hpp" 
    35#include "field.hpp" 
    … …  
    8486    return auxInputs; 
    8587  } 
     88 
     89  CGenericAlgorithmTransformation* CInterpolateAxis::createAlgorithm(bool isSource, 
     90                                                        CGrid* gridDst, CGrid* gridSrc, 
     91                                                        int elementPositionInGrid, 
     92                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     93                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     94                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     95                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     96                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     97                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     98  { 
     99    if (!coordinate.isEmpty())  return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
     100                                      elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     101                                      elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     102    else return CAxisAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
     103                elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     104                elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     105  } 
    86106} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_axis.hpp

    r1984 r2011  
    2020  class CInterpolateAxis; 
    2121  class CAxis; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6465      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6566      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     67      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     68                                                               CGrid* gridDst, CGrid* gridSrc, 
     69                                                               int elementPositionInGrid, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     71                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     72                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     74                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     75                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6676    private: 
    6777      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_domain.cpp

    r1984 r2011  
    11#include "interpolate_domain.hpp" 
     2#include "domain_algorithm_interpolate.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    6869  } 
    6970 
     71  CGenericAlgorithmTransformation* CInterpolateDomain::createAlgorithm(bool isSource, 
     72                                                        CGrid* gridDst, CGrid* gridSrc, 
     73                                                        int elementPositionInGrid, 
     74                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     75                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     76                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     77                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     78                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     79                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     80  { 
     81    return CDomainAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     82                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     83                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     84  } 
    7085} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/interpolate_domain.hpp

    r1984 r2011  
    2020  class CInterpolateDomain; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/inverse_axis.cpp

    r1984 r2011  
    11#include "inverse_axis.hpp" 
     2#include "axis_algorithm_inverse.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    3940  {} 
    4041 
     42  CGenericAlgorithmTransformation* CInverseAxis::createAlgorithm(bool isSource, 
     43                                                        CGrid* gridDst, CGrid* gridSrc, 
     44                                                        int elementPositionInGrid, 
     45                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     46                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     47                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     48                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     49                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     50                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     51  { 
     52    return CAxisAlgorithmInverse::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     53                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     54                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     55  } 
    4156} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/inverse_axis.hpp

    r1984 r2011  
    1919  class CInverseAxis; 
    2020  class CAxis; 
     21  class CGenericAlgorithmTransformation ; 
     22  class CGrid; 
    2123  ///-------------------------------------------------------------- 
    2224 
    … …  
    6062      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6163      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     64      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     65                                                               CGrid* gridDst, CGrid* gridSrc, 
     66                                                               int elementPositionInGrid, 
     67                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     70                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6273    private: 
    6374      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_axis_to_axis.cpp

    r1984 r2011  
    11#include "reduce_axis_to_axis.hpp" 
     2#include "axis_algorithm_reduce_axis.hpp" 
    23#include "type.hpp" 
    34#include "axis.hpp" 
    … …  
    5657  } 
    5758 
     59  CGenericAlgorithmTransformation* CReduceAxisToAxis::createAlgorithm(bool isSource, 
     60                                                        CGrid* gridDst, CGrid* gridSrc, 
     61                                                        int elementPositionInGrid, 
     62                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     63                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     64                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     65                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     66                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     67                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     68  { 
     69    return CAxisAlgorithmReduceAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     70                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     71                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     72  } 
    5873} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_axis_to_axis.hpp

    r1984 r2011  
    1919  class CReduceAxisToAxis; 
    2020  class CAxis; 
    21  
     21  class CGenericAlgorithmTransformation ; 
     22  class CGrid; 
    2223  ///-------------------------------------------------------------- 
    2324 
    … …  
    6162      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6263      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
    63     private: 
     64      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     65                                                               CGrid* gridDst, CGrid* gridSrc, 
     66                                                               int elementPositionInGrid, 
     67                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     70                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
     73   private: 
    6474      static bool registerTrans(); 
    6575      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_axis_to_scalar.cpp

    r1984 r2011  
    11#include "reduce_axis_to_scalar.hpp" 
     2#include "scalar_algorithm_reduce_axis.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    4142  } 
    4243 
     44  CGenericAlgorithmTransformation* CReduceAxisToScalar::createAlgorithm(bool isSource, 
     45                                                        CGrid* gridDst, CGrid* gridSrc, 
     46                                                        int elementPositionInGrid, 
     47                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     48                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     49                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     50                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     51                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     52                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     53  { 
     54    return CScalarAlgorithmReduceAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     55                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     56                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     57  } 
    4358} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_axis_to_scalar.hpp

    r1984 r2011  
    1919  class CReduceAxisToScalar; 
    2020  class CScalar; 
    21  
     21  class CGenericAlgorithmTransformation ; 
     22  class CGrid; 
    2223  ///-------------------------------------------------------------- 
    2324 
    … …  
    6162      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6263      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     64      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     65                                                               CGrid* gridDst, CGrid* gridSrc, 
     66                                                               int elementPositionInGrid, 
     67                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     70                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6373    private: 
    6474      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_domain_to_axis.cpp

    r1984 r2011  
    11#include "reduce_domain_to_axis.hpp" 
     2#include "axis_algorithm_reduce_domain.hpp" 
    23#include "type.hpp" 
    34#include "axis.hpp" 
    … …  
    8788  } 
    8889 
     90  CGenericAlgorithmTransformation* CReduceDomainToAxis::createAlgorithm(bool isSource, 
     91                                                        CGrid* gridDst, CGrid* gridSrc, 
     92                                                        int elementPositionInGrid, 
     93                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     94                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     95                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     96                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     97                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     98                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     99  { 
     100    return CAxisAlgorithmReduceDomain::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     101                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     102                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     103  } 
    89104} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_domain_to_axis.hpp

    r1984 r2011  
    2020  class CAxis; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474     private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_domain_to_scalar.cpp

    r1984 r2011  
    11#include "reduce_domain_to_scalar.hpp" 
     2#include "scalar_algorithm_reduce_domain.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    4243  } 
    4344 
     45  CGenericAlgorithmTransformation* CReduceDomainToScalar::createAlgorithm(bool isSource, 
     46                                                        CGrid* gridDst, CGrid* gridSrc, 
     47                                                        int elementPositionInGrid, 
     48                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     49                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     50                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     51                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     52                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     53                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     54  { 
     55    return CScalarAlgorithmReduceDomain::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     56                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     57                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ; 
     58  } 
    4459} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_domain_to_scalar.hpp

    r1984 r2011  
    2020  class CDomain; 
    2121  class CScalar; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_scalar_to_scalar.cpp

    r1984 r2011  
    11#include "reduce_scalar_to_scalar.hpp" 
     2#include "scalar_algorithm_reduce_scalar.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    4142  } 
    4243 
     44  CGenericAlgorithmTransformation* CReduceScalarToScalar::createAlgorithm(bool isSource, 
     45                                                        CGrid* gridDst, CGrid* gridSrc, 
     46                                                        int elementPositionInGrid, 
     47                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     48                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     49                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     50                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     51                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     52                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     53  { 
     54    return CScalarAlgorithmReduceScalar::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     55                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     56                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     57  } 
    4358} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reduce_scalar_to_scalar.hpp

    r1984 r2011  
    1919  class CReduceScalarToScalar; 
    2020  class CScalar; 
    21  
     21  class CGenericAlgorithmTransformation ; 
     22  class CGrid; 
    2223  ///-------------------------------------------------------------- 
    2324 
    … …  
    6162      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6263      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     64      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     65                                                               CGrid* gridDst, CGrid* gridSrc, 
     66                                                               int elementPositionInGrid, 
     67                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     70                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6373    private: 
    6474      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reorder_domain.cpp

    r1984 r2011  
    11#include "reorder_domain.hpp" 
     2#include "domain_algorithm_reorder.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    4142  } 
    4243 
     44  CGenericAlgorithmTransformation* CReorderDomain::createAlgorithm(bool isSource, 
     45                                                        CGrid* gridDst, CGrid* gridSrc, 
     46                                                        int elementPositionInGrid, 
     47                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     48                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     49                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     50                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     51                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     52                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     53  { 
     54    return CDomainAlgorithmReorder::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     55                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     56                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     57  } 
    4358} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/reorder_domain.hpp

    r1984 r2011  
    2020  class CReorderDomain; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474     private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/temporal_splitting.cpp

    r1984 r2011  
    11#include "temporal_splitting.hpp" 
     2#include "axis_algorithm_temporal_splitting.hpp" 
    23#include "type.hpp" 
    34#include "axis.hpp" 
    … …  
    4546  } 
    4647 
     48  CGenericAlgorithmTransformation* CTemporalSplitting::createAlgorithm(bool isSource, 
     49                                                        CGrid* gridDst, CGrid* gridSrc, 
     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) 
     57  { 
     58    return CAxisAlgorithmTemporalSplitting::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     59                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     60                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     61  } 
    4762} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/temporal_splitting.hpp

    r1984 r2011  
    2020  class CAxis; 
    2121  class CScalar; 
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2224  ///-------------------------------------------------------------- 
    2325 
    … …  
    6163      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6264      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6374    private: 
    6475      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/zoom_axis.cpp

    r1984 r2011  
    11#include "zoom_axis.hpp" 
     2#include "axis_algorithm_zoom.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    7778  } 
    7879 
     80  CGenericAlgorithmTransformation* CZoomAxis::createAlgorithm(bool isSource, 
     81                                                        CGrid* gridDst, CGrid* gridSrc, 
     82                                                        int elementPositionInGrid, 
     83                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     84                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     85                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     86                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     87                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     88                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     89  { 
     90    return CAxisAlgorithmZoom::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     91                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     92                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     93  } 
    7994} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/zoom_axis.hpp

    r1984 r2011  
    2020  class CZoomAxis; 
    2121  class CAxis; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
    6364      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/zoom_domain.cpp

    r1984 r2011  
    11#include "zoom_domain.hpp" 
     2#include "domain_algorithm_zoom.hpp" 
    23#include "type.hpp" 
    34 
    … …  
    7273  } 
    7374 
     75  CGenericAlgorithmTransformation* CZoomDomain::createAlgorithm(bool isSource, 
     76                                                        CGrid* gridDst, CGrid* gridSrc, 
     77                                                        int elementPositionInGrid, 
     78                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     79                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     80                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     81                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     82                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     83                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
     84  { 
     85    return CDomainAlgorithmZoom::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid, 
     86                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     87                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     88  } 
    7489} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/node/zoom_domain.hpp

    r1984 r2011  
    2020  class CZoomDomain; 
    2121  class CDomain; 
    22  
     22  class CGenericAlgorithmTransformation ; 
     23  class CGrid; 
    2324  ///-------------------------------------------------------------- 
    2425 
    … …  
    6263      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;} 
    6364      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);} 
     65      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource, 
     66                                                               CGrid* gridDst, CGrid* gridSrc, 
     67                                                               int elementPositionInGrid, 
     68                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition, 
     69                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition, 
     70                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition, 
     71                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition, 
     72                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition, 
     73                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ; 
    6474    private: 
    6575      static bool registerTrans(); 
Note: See TracChangeset for help on using the changeset viewer.