Ignore:
Timestamp:
01/03/21 18:00:43 (3 years ago)
Author:
ymipsl
Message:

Adapt transformation algorithm to new infrastructure (on going...)

YM

Location:
XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_duplicate_scalar.cpp

    r1998 r1999  
    4747{ 
    4848   
    49   CArray<int,1>& axisDstIndex = axisDest_->index; 
     49  CArray<int,1>& axisDstIndex = axisDestination->index; 
    5050 
    5151  int nbAxisIdx = axisDstIndex.numElements(); 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_duplicate_scalar.hpp

    r1998 r1999  
    3636private: 
    3737 
    38   CAxis* axisSrc_; 
    39   CAxis* axisDest_; 
    40  
    4138  static CGenericAlgorithmTransformation* create(bool isSource, CGrid* gridDst, CGrid* gridSrc, 
    4239                                                CTransformation<CAxis>* transformation, 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_extract_domain.cpp

    r1988 r1999  
    4848 
    4949CAxisAlgorithmExtractDomain::CAxisAlgorithmExtractDomain(bool isSource, CAxis* axisDestination, CDomain* domainSource, CExtractDomainToAxis* algo) 
    50  : CAxisAlgorithmTransformation(isSource, axisDestination, domainSource), pos_(-1), reduction_(0) 
     50 : CAlgorithmTransformationTransfer(isSource), pos_(-1), axisDest_(axisDestination), domainSrc_(domainSource) 
    5151TRY 
    5252{ 
    … …  
    6767 
    6868  pos_ = algo->position; 
    69   reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    70 } 
    71 CATCH 
    7269 
    73 void CAxisAlgorithmExtractDomain::apply(const std::vector<std::pair<int,double> >& localIndex, 
    74                                         const double* dataInput, 
    75                                         CArray<double,1>& dataOut, 
    76                                         std::vector<bool>& flagInitial,                      
    77                                         bool ignoreMissingValue, bool firstPass) 
    78 TRY 
    79 { 
    80   reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    81 } 
    82 CATCH 
    83  
    84 CAxisAlgorithmExtractDomain::~CAxisAlgorithmExtractDomain() 
    85 TRY 
    86 { 
    87   if (0 != reduction_) delete reduction_; 
    88 } 
    89 CATCH 
    90  
    91 void CAxisAlgorithmExtractDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    92 TRY 
    93 { 
    94   this->transformationMapping_.resize(1); 
    95   this->transformationWeight_.resize(1); 
    96  
    97   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    98   TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
     70  auto& transMap = this->transformationMapping_; 
    9971 
    10072  CArray<int,1>& axisDstIndex = axisDest_->index; 
    … …  
    10678    { 
    10779      int globalAxisIdx = axisDstIndex(idxAxis); 
    108       transMap[globalAxisIdx].resize(1); 
    109       transWeight[globalAxisIdx].resize(1); 
    110       transMap[globalAxisIdx][0] = globalAxisIdx * ni_glo + pos_; 
    111       transWeight[globalAxisIdx][0] = 1.0; 
    112  
     80      transMap[globalAxisIdx] = globalAxisIdx * ni_glo + pos_; 
    11381    } 
    11482  } 
    … …  
    11987    { 
    12088      int globalAxisIdx = axisDstIndex(idxAxis); 
    121       transMap[globalAxisIdx].resize(1); 
    122       transWeight[globalAxisIdx].resize(1); 
    123       transMap[globalAxisIdx][0] = globalAxisIdx + ni_glo * pos_; 
    124       transWeight[globalAxisIdx][0] = 1.0; 
     89      transMap[globalAxisIdx] = globalAxisIdx + ni_glo * pos_; 
    12590    } 
    12691  } 
    12792  else 
    12893  {} 
     94 
     95  axisDestination->checkAttributes() ; 
     96  this->computeAlgorithm(domainSource->getLocalView(CElementView::WORKFLOW), axisDestination->getLocalView(CElementView::WORKFLOW)) ; 
    12997} 
    13098CATCH 
     99 
     100 
     101CAxisAlgorithmExtractDomain::~CAxisAlgorithmExtractDomain() 
     102TRY 
     103{ 
    131104} 
     105CATCH 
     106 
     107} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_extract_domain.hpp

    r1988 r1999  
    1010#define __XIOS_AXIS_ALGORITHM_EXTRACT_DOMAIN_HPP__ 
    1111 
    12 #include "axis_algorithm_transformation.hpp" 
     12#include "algorithm_transformation_transfer.hpp" 
    1313#include "transformation.hpp" 
    1414 
    … …  
    2525  Extract a domain to an axis 
    2626*/ 
    27 class CAxisAlgorithmExtractDomain : public CAxisAlgorithmTransformation 
     27class CAxisAlgorithmExtractDomain : public CAlgorithmTransformationTransfer 
    2828{ 
    2929public: 
    3030  CAxisAlgorithmExtractDomain(bool isSource, CAxis* axisDestination, CDomain* domainSource, CExtractDomainToAxis* algo); 
    3131 
    32   virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
    33                      const double* dataInput, 
    34                      CArray<double,1>& dataOut, 
    35                      std::vector<bool>& flagInitial,                      
    36                      bool ignoreMissingValue, bool firstPass); 
    37  
    38   virtual ~CAxisAlgorithmExtractDomain(); 
     32   virtual ~CAxisAlgorithmExtractDomain(); 
    3933 
    4034  static bool registerTrans(); 
    … …  
    4842  ExtractDirection dir_; 
    4943  int pos_; //! Position to extract 
    50 protected: 
    51   void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
    52  
    53 protected: 
    54   CReductionAlgorithm* reduction_; 
    55  
     44   
    5645private: 
     46  CDomain* domainSrc_; 
     47  CAxis* axisDest_ ; 
    5748  static CGenericAlgorithmTransformation* create(bool isSource, CGrid* gridDst, CGrid* gridSrc, 
    5849                                                CTransformation<CAxis>* transformation, 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_inverse.cpp

    r1988 r1999  
    4949 
    5050CAxisAlgorithmInverse::CAxisAlgorithmInverse(bool isSource, CAxis* axisDestination, CAxis* axisSource, CInverseAxis* inverseAxis) 
    51  : CAxisAlgorithmTransformation(isSource, axisDestination, axisSource) 
     51 : CAlgorithmTransformationTransfer(isSource), axisDest_(axisDestination), axisSrc_(axisSource) 
    5252TRY 
    5353{ 
    … …  
    5959           << "Size of axis destination " <<axisDestination->getId() << " is " << axisDestination->n_glo.getValue()); 
    6060  } 
    61 } 
    62 CATCH 
    63  
    64 void CAxisAlgorithmInverse::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    65 TRY 
    66 { 
    67   this->transformationMapping_.resize(1); 
    68   this->transformationWeight_.resize(1); 
    69  
    70   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    71   TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
    72  
    73   int globalIndexSize = axisDestGlobalIndex_.size(); 
     61 
     62  auto& transMap = this->transformationMapping_; 
     63 
     64  int globalIndexSize = axisDestination->index.size(); 
    7465  for (int idx = 0; idx < globalIndexSize; ++idx) 
    7566  { 
    76     transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1); 
    77     transWeight[axisDestGlobalIndex_[idx]].push_back(1.0); 
     67    transMap[axisDestination->index(idx)] = globalIndexSize-axisDestination->index(idx)-1; 
    7868  } 
    7969 
    … …  
    8878    } 
    8979  } 
    90 } 
    91 CATCH 
     80 
     81  axisDestination->checkAttributes() ; 
     82  this->computeAlgorithm(axisSource->getLocalView(CElementView::WORKFLOW), axisDestination->getLocalView(CElementView::WORKFLOW)) ; 
     83 
     84} 
     85CATCH 
     86 
    9287 
    9388/*! 
    … …  
    118113  typedef std::unordered_map<size_t, std::vector<double> > GlobalIndexMapFromSrcToDest; 
    119114  GlobalIndexMapFromSrcToDest globalIndexMapFromSrcToDest; 
    120   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    121   TransformationIndexMap::const_iterator itb = transMap.begin(), ite = transMap.end(), it; 
     115  auto& transMap = this->transformationMapping_; 
    122116  CArray<size_t,1> globalSrcIndex(transMap.size()); 
    123117  int localIndex = 0; 
    124   for (it = itb; it != ite; ++it) 
    125   { 
    126     size_t srcIndex = it->second[0]; 
     118  for (auto it = transMap.begin(); it != transMap.end(); ++it) 
     119  { 
     120    size_t srcIndex = it->second; 
    127121    globalIndexMapFromSrcToDest[srcIndex].resize(1); 
    128122    globalIndexMapFromSrcToDest[srcIndex][0] = it->first; 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_inverse.hpp

    r1988 r1999  
    1010#define __XIOS_AXIS_ALGORITHM_INVERSE_HPP__ 
    1111 
    12 #include "axis_algorithm_transformation.hpp" 
     12#include "algorithm_transformation_transfer.hpp" 
    1313#include "transformation.hpp" 
    1414 
    … …  
    2222  Inversing an axis 
    2323*/ 
    24 class CAxisAlgorithmInverse : public CAxisAlgorithmTransformation 
     24class CAxisAlgorithmInverse : public CAlgorithmTransformationTransfer 
    2525{ 
    2626public: 
    … …  
    3131  static bool registerTrans(); 
    3232 
    33 protected: 
    34   void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs); 
    3533 
    3634private: 
     35  CAxis* axisSrc_; 
     36  CAxis* axisDest_; 
    3737  void updateAxisValue(); 
    3838 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_reduce_axis.cpp

    r1988 r1999  
    1212#include "grid.hpp" 
    1313#include "grid_transformation_factory_impl.hpp" 
    14 #include "reduction.hpp" 
     14 
    1515 
    1616namespace xios { 
    … …  
    4747 
    4848CAxisAlgorithmReduceAxis::CAxisAlgorithmReduceAxis(bool isSource, CAxis* axisDestination, CAxis* axisSource, CReduceAxisToAxis* algo) 
    49  : CAxisAlgorithmTransformation(isSource, axisDestination, axisSource), reduction_(0) 
     49 : CAlgorithmTransformationReduce(isSource) 
    5050TRY 
    5151{ 
    5252  eliminateRedondantSrc_= false ; 
    5353  algo->checkValid(axisDestination, axisSource); 
    54   StdString op; 
     54 
    5555  switch (algo->operation) 
    5656  { 
    5757    case CReduceAxisToAxis::operation_attr::sum: 
    58       op = "sum"; 
     58      operator_ = EReduction::sum; 
    5959      break; 
    6060    case CReduceAxisToAxis::operation_attr::min: 
    61       op = "min"; 
     61      operator_ = EReduction::min; 
    6262      break; 
    6363    case CReduceAxisToAxis::operation_attr::max: 
    64       op = "max"; 
     64      operator_ = EReduction::max; 
    6565      break; 
    6666    case CReduceAxisToAxis::operation_attr::average: 
    67       op = "average"; 
     67      operator_ = EReduction::average; 
    6868      break; 
    6969    default: 
    … …  
    7373         << "Axis destination " << axisDestination->getId()); 
    7474 
     75    TransformationIndexMap& transMap = this->transformationMapping_; 
     76    CArray<int,1>& axisDstIndex = axisDestination->index; 
     77    int nbAxisIdx = axisDstIndex.numElements(); 
     78    for (int idxAxis = 0; idxAxis < nbAxisIdx; ++idxAxis) 
     79    { 
     80      int globalAxisIdx = axisDstIndex(idxAxis); 
     81      transMap[globalAxisIdx].resize(1); 
     82      transMap[globalAxisIdx][0]=globalAxisIdx ;       
     83    } 
     84 
    7585  } 
    76  
    77   reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
     86  
     87  axisDestination->checkAttributes() ; 
     88  this->computeAlgorithm(axisSource->getLocalView(CElementView::WORKFLOW), axisDestination->getLocalView(CElementView::WORKFLOW)) ; 
    7889} 
    7990CATCH 
    8091 
    81 void CAxisAlgorithmReduceAxis::apply(const std::vector<std::pair<int,double> >& localIndex, 
    82                                        const double* dataInput, 
    83                                        CArray<double,1>& dataOut, 
    84                                        std::vector<bool>& flagInitial,                      
    85                                        bool ignoreMissingValue, bool firstPass) 
    86 TRY 
    87 { 
    88   reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    89 } 
    90 CATCH 
    91  
    92 void CAxisAlgorithmReduceAxis::updateData(CArray<double,1>& dataOut) 
    93 TRY 
    94 { 
    95   reduction_->updateData(dataOut); 
    96 } 
    97 CATCH 
    9892 
    9993CAxisAlgorithmReduceAxis::~CAxisAlgorithmReduceAxis() 
    10094TRY 
    10195{ 
    102   if (0 != reduction_) delete reduction_; 
     96  
    10397} 
    10498CATCH 
    10599 
    106 void CAxisAlgorithmReduceAxis::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    107 TRY 
    108 { 
    109   this->transformationMapping_.resize(1); 
    110   this->transformationWeight_.resize(1); 
    111  
    112   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    113   TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
    114   CArray<int,1>& axisDstIndex = axisDest_->index; 
    115   int nbAxisIdx = axisDstIndex.numElements(); 
    116   for (int idxAxis = 0; idxAxis < nbAxisIdx; ++idxAxis) 
    117   { 
    118     int globalAxisIdx = axisDstIndex(idxAxis); 
    119     transMap[globalAxisIdx].resize(1); 
    120     transWeight[globalAxisIdx].resize(1); 
    121     transMap[globalAxisIdx][0]=globalAxisIdx ;       
    122     transWeight[globalAxisIdx][0] = 1.0 ;       
    123   } 
    124 } 
    125 CATCH 
    126100 
    127101} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_reduce_axis.hpp

    r1988 r1999  
    1010#define __XIOS_AXIS_ALGORITHM_REDUCE_AXIS_HPP__ 
    1111 
    12 #include "axis_algorithm_transformation.hpp" 
     12#include "algorithm_transformation_reduce.hpp" 
    1313#include "transformation.hpp" 
    1414 
    … …  
    2323  Reduce a axis to an axis 
    2424*/ 
    25 class CAxisAlgorithmReduceAxis : public CAxisAlgorithmTransformation 
     25class CAxisAlgorithmReduceAxis : public CAlgorithmTransformationReduce 
    2626{ 
    2727public: 
    2828  CAxisAlgorithmReduceAxis(bool isSource, CAxis* axisDestination, CAxis* axisSource, CReduceAxisToAxis* algo); 
    2929 
    30   virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
    31                      const double* dataInput, 
    32                      CArray<double,1>& dataOut, 
    33                      std::vector<bool>& flagInitial,                      
    34                      bool ignoreMissingValue, bool firstPass); 
    35  
    36   virtual void updateData(CArray<double,1>& dataOut); 
    3730   
    3831  virtual ~CAxisAlgorithmReduceAxis(); 
    3932 
    4033  static bool registerTrans(); 
    41 protected: 
    4234   
    43 protected: 
    44   void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs);  
    45    
    46 protected: 
    47   CReductionAlgorithm* reduction_; 
    48  
    4935private: 
    5036  static CGenericAlgorithmTransformation* create(bool isSource, CGrid* gridDst, CGrid* gridSrc, 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_reduce_domain.cpp

    r1988 r1999  
    4848 
    4949CAxisAlgorithmReduceDomain::CAxisAlgorithmReduceDomain(bool isSource, CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo) 
    50  : CAxisAlgorithmTransformation(isSource, axisDestination, domainSource), reduction_(0) 
     50 : CAlgorithmTransformationReduce(isSource), domainSrc_(domainSource), axisDest_(axisDestination) 
    5151TRY 
    5252{ 
    5353  algo->checkValid(axisDestination, domainSource); 
    54   StdString op; 
    5554  switch (algo->operation) 
    5655  { 
    5756    case CReduceDomainToAxis::operation_attr::sum: 
    58       op = "sum"; 
     57       operator_ = EReduction::sum; 
    5958      break; 
    6059    case CReduceDomainToAxis::operation_attr::min: 
    61       op = "min"; 
     60       operator_ = EReduction::min; 
    6261      break; 
    6362    case CReduceDomainToAxis::operation_attr::max: 
    64       op = "max"; 
     63       operator_ = EReduction::max; 
    6564      break; 
    6665    case CReduceDomainToAxis::operation_attr::average: 
    67       op = "average"; 
     66       operator_ = EReduction::average; 
    6867      break; 
    6968    default: 
    … …  
    7675 
    7776  dir_ = (CReduceDomainToAxis::direction_attr::iDir == algo->direction)  ? iDir : jDir; 
    78   reduction_ = CReductionAlgorithm::createOperation(CReductionAlgorithm::ReductionOperations[op]); 
    79   local = algo->local ; 
    80 } 
    81 CATCH 
     77  bool local = algo->local ; 
    8278 
    83 void CAxisAlgorithmReduceDomain::apply(const std::vector<std::pair<int,double> >& localIndex, 
    84                                        const double* dataInput, 
    85                                        CArray<double,1>& dataOut, 
    86                                        std::vector<bool>& flagInitial,                      
    87                                        bool ignoreMissingValue, bool firstPass) 
    88 TRY 
    89 { 
    90   reduction_->apply(localIndex, dataInput, dataOut, flagInitial, ignoreMissingValue, firstPass); 
    91 } 
    92 CATCH 
    93  
    94 void CAxisAlgorithmReduceDomain::updateData(CArray<double,1>& dataOut) 
    95 TRY 
    96 { 
    97   reduction_->updateData(dataOut); 
    98 } 
    99 CATCH 
    100  
    101 CAxisAlgorithmReduceDomain::~CAxisAlgorithmReduceDomain() 
    102 TRY 
    103 { 
    104   if (0 != reduction_) delete reduction_; 
    105 } 
    106 CATCH 
    107  
    108 void CAxisAlgorithmReduceDomain::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs) 
    109 TRY 
    110 { 
    111   this->transformationMapping_.resize(1); 
    112   this->transformationWeight_.resize(1); 
    113  
    114   TransformationIndexMap& transMap = this->transformationMapping_[0]; 
    115   TransformationWeightMap& transWeight = this->transformationWeight_[0]; 
     79  TransformationIndexMap& transMap = transformationMapping_; 
    11680 
    11781  CArray<int,1>& axisDstIndex = axisDest_->index; 
    … …  
    13195        {  
    13296          transMap[j_index(idxDomain)].push_back(j_index(idxDomain)* ni_glo + i_index(idxDomain)); 
    133           transWeight[j_index(idxDomain)].push_back(1.0) ; 
    13497        } 
    13598      } 
    … …  
    142105        int globalAxisIdx = axisDstIndex(idxAxis); 
    143106        transMap[globalAxisIdx].resize(ni_glo); 
    144         transWeight[globalAxisIdx].resize(ni_glo); 
    145107        for (int idx = 0; idx < ni_glo; ++idx) 
    146108        { 
    147109          transMap[globalAxisIdx][idx] = globalAxisIdx * ni_glo + idx; 
    148           transWeight[globalAxisIdx][idx] = 1.0; 
    149110        } 
    150111      } 
    … …  
    166127        {  
    167128          transMap[i_index(idxDomain)].push_back(j_index(idxDomain)* ni_glo + i_index(idxDomain)); 
    168           transWeight[i_index(idxDomain)].push_back(1.0) ; 
    169129        } 
    170130      } 
    … …  
    176136        int globalAxisIdx = axisDstIndex(idxAxis); 
    177137        transMap[globalAxisIdx].resize(nj_glo); 
    178         transWeight[globalAxisIdx].resize(nj_glo); 
    179138        for (int idx = 0; idx < nj_glo; ++idx) 
    180139        { 
    181140          transMap[globalAxisIdx][idx] = globalAxisIdx + ni_glo*idx; 
    182           transWeight[globalAxisIdx][idx] = 1.0; 
    183141        } 
    184142      } 
    … …  
    187145  else 
    188146  {} 
     147 
     148  axisDestination->checkAttributes() ; 
     149  this->computeAlgorithm(domainSource->getLocalView(CElementView::WORKFLOW), axisDestination->getLocalView(CElementView::WORKFLOW)) ; 
     150 
    189151} 
    190152CATCH 
    191153 
     154 
     155CAxisAlgorithmReduceDomain::~CAxisAlgorithmReduceDomain() 
     156TRY 
     157{ 
    192158} 
     159CATCH 
     160 
     161 
     162} 

  • XIOS/dev/dev_ym/XIOS_COUPLING/src/transformation/axis_algorithm/axis_algorithm_reduce_domain.hpp

    r1988 r1999  
    1010#define __XIOS_AXIS_ALGORITHM_REDUCE_DOMAIN_HPP__ 
    1111 
    12 #include "axis_algorithm_transformation.hpp" 
     12#include "algorithm_transformation_reduce.hpp" 
    1313#include "transformation.hpp" 
    1414 
    … …  
    2424  Reduce a domain to an axis 
    2525*/ 
    26 class CAxisAlgorithmReduceDomain : public CAxisAlgorithmTransformation 
     26class CAxisAlgorithmReduceDomain : public CAlgorithmTransformationReduce 
    2727{ 
    2828public: 
    2929  CAxisAlgorithmReduceDomain(bool isSource, CAxis* axisDestination, CDomain* domainSource, CReduceDomainToAxis* algo); 
    30  
    31   virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
    32                      const double* dataInput, 
    33                      CArray<double,1>& dataOut, 
    34                      std::vector<bool>& flagInitial,                      
    35                      bool ignoreMissingValue, bool firstPass); 
    36  
    37   virtual void updateData(CArray<double,1>& dataOut); 
    3830   
    3931  virtual ~CAxisAlgorithmReduceDomain(); 
    … …  
    5042  bool local ; 
    5143   
    52 protected: 
    53   void computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs);  
    54    
    55 protected: 
    56   CReductionAlgorithm* reduction_; 
     44  CDomain* domainSrc_ ; 
     45  CAxis* axisDest_ ; 
    5746 
    5847private: 
Note: See TracChangeset for help on using the changeset viewer.