Changeset 888


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

Adding new transformation for scalar: Reducing an axis to a scalar

+) Add new xml node for new transformation
+) Add new algorithms for axis reduction
+) Make change in some place to make sure everything work fine

Test
+) On Curie
+) Tests pass and are correct

Location:
XIOS/trunk/src
Files:
17 added
22 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/config/node_type.conf

    r887 r888  
    5959#endif //__XIOS_CScalar__ 
    6060 
     61#ifdef __XIOS_CReduceAxisToScalar__ 
     62   DECLARE_NODE(ReduceAxisToScalar, reduce_axis) 
     63#endif //__XIOS_CReduceAxisToScalar__ 
     64 
    6165#ifdef __XIOS_CContext__ 
    6266   DECLARE_NODE_PAR(Context, context) 
  • XIOS/trunk/src/distribution_client.cpp

    r887 r888  
    6565  grid->checkMask(); 
    6666  switch (gridDim) { 
     67    case 0: 
     68      gridMask_.resize(1); 
     69      gridMask_(0) = true; 
     70      break; 
    6771    case 1: 
    6872      readGridMaskInfo(grid->mask_1d); 
     
    416420  createLocalDomainDataIndex(); 
    417421  createLocalAxisDataIndex(); 
     422  createLocalScalarDataIndex(); 
    418423 
    419424  int idxDomain = 0, idxAxis = 0; 
     
    579584void CDistributionClient::createGlobalIndex() 
    580585{ 
    581 //  size_t ssize = 1, idx = 0; 
    582 //  for (int i = 0; i < this->dims_; ++i) 
    583 //  ssize *= nLocal_[i]; 
    584 // 
    585 //  this->globalIndex_.resize(ssize); 
    586 //  std::vector<int> idxLoop(this->numElement_,0); 
    587 //  int innnerLoopSize = (infoIndex_[0]).numElements(); 
    588 //  while (idx < ssize) 
    589 //  { 
    590 //    for (int i = 0; i < this->numElement_; ++i) 
    591 ////    { 
    592 //      if (idxLoop[i] == (infoIndex_[indexMap_[i]]).numElements()) 
    593 //      { 
    594 //        idxLoop[i] = 0; 
    595 //        ++idxLoop[i+1]; 
    596 //      } 
    597 //    } 
    598 // 
    599 //    for (int i = 0; i < innnerLoopSize; ++i) 
    600 //    { 
    601 //      size_t globalIndex = (infoIndex_[0])(idxLoop[0]); 
    602 //      size_t mulDim = 1; 
    603 //      for (int idxElement = 0; idxElement < this->numElement_; ++idxElement) 
    604 //      { 
    605 //        if (axisDomainOrder_(idxElement)) 
    606 //        { 
    607 //          int jb = (0 == idxElement) ? 1 : 0; 
    608 //          for (int j = jb; j <= 1; ++j) 
    609 //          { 
    610 //            mulDim *= nGlob_[indexMap_[idxElement]+j-1]; 
    611 //            globalIndex += ((infoIndex_[indexMap_[idxElement]+j])(idxLoop[idxElement]))*mulDim; 
    612 //          } 
    613 //        } 
    614 //        else 
    615 //        { 
    616 //          if (0 != idxElement) 
    617 //          { 
    618 //            mulDim *= nGlob_[indexMap_[idxElement]-1]; 
    619 //            globalIndex += ((infoIndex_[indexMap_[idxElement]])(idxLoop[idxElement]))*mulDim; 
    620 //          } 
    621 //        } 
    622 //      } 
    623 // 
    624 //      this->globalIndex_(idx) = globalIndex; 
    625 //      ++idxLoop[0]; 
    626 //      ++idx; 
    627 //    } 
    628 //  } 
    629586} 
    630587 
  • XIOS/trunk/src/filter/spatial_transform_filter.cpp

    r873 r888  
    122122    const std::list<size_t>& listNbLocalIndexToReceive = gridTransformation->getNbLocalIndexToReceiveOnGridDest(); 
    123123    const std::list<std::vector<bool> >& listLocalIndexMaskOnDest = gridTransformation->getLocalMaskIndexOnGridDest(); 
     124    const std::vector<CGenericAlgorithmTransformation*>& listAlgos = gridTransformation->getAlgos(); 
    124125 
    125126    CArray<double,1> dataCurrentDest(dataSrc.copy()); 
     
    130131    std::list<size_t>::const_iterator itNbListRecv = listNbLocalIndexToReceive.begin(); 
    131132    std::list<std::vector<bool> >::const_iterator itLocalMaskIndexOnDest = listLocalIndexMaskOnDest.begin(); 
    132  
    133     for (; itListSend != iteListSend; ++itListSend, ++itListRecv, ++itNbListRecv, ++itLocalMaskIndexOnDest) 
     133    std::vector<CGenericAlgorithmTransformation*>::const_iterator itAlgo = listAlgos.begin(); 
     134 
     135    for (; itListSend != iteListSend; ++itListSend, ++itListRecv, ++itNbListRecv, ++itLocalMaskIndexOnDest, ++itAlgo) 
    134136    { 
    135137      CArray<double,1> dataCurrentSrc(dataCurrentDest); 
     
    189191        else dataCurrentDest(i) = defaultValue; 
    190192 
     193      std::vector<bool> localInitFlag(dataCurrentDest.size(), true); 
    191194      currentBuff = 0; 
    192195      for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
     
    194197        int countSize = itRecv->second.size(); 
    195198        const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second; 
    196         for (int idx = 0; idx < countSize; ++idx) 
    197         { 
    198           dataCurrentDest(localIndex_p[idx].first) += *(recvBuff+currentBuff+idx) * localIndex_p[idx].second; 
    199         } 
     199//        for (int idx = 0; idx < countSize; ++idx) 
     200//        { 
     201//          dataCurrentDest(localIndex_p[idx].first) += *(recvBuff+currentBuff+idx) * localIndex_p[idx].second; 
     202//        } 
     203        (*itAlgo)->apply(localIndex_p, 
     204                         recvBuff+currentBuff, 
     205                         dataCurrentDest, 
     206                         localInitFlag); 
     207 
    200208        currentBuff += countSize; 
    201209      } 
  • XIOS/trunk/src/group_factory_decl.cpp

    r887 r888  
    3232  macro(CGenerateRectilinearDomainGroup) 
    3333  macro(CScalarGroup) 
     34  macro(CReduceAxisToScalarGroup) 
    3435} 
  • XIOS/trunk/src/group_template_decl.cpp

    r887 r888  
    2121  macro(GenerateRectilinearDomain) 
    2222  macro(Scalar) 
     23  macro(ReduceAxisToScalar) 
    2324 
    2425} 
  • XIOS/trunk/src/node/node_enum.hpp

    r887 r888  
    2626         eInterpolateDomain, 
    2727         eGenerateRectilinearDomain, 
    28          eScalar 
     28         eScalar, 
     29         eReduceAxisToScalar 
    2930 
    3031      } ENodeType; 
  • XIOS/trunk/src/node/node_type.hpp

    r887 r888  
    1717#include "generate_rectilinear_domain.hpp" 
    1818#include "scalar.hpp" 
     19#include "reduce_axis_to_scalar.hpp" 
    1920 
    2021 
  • XIOS/trunk/src/node/scalar.cpp

    r887 r888  
    2727   { /* Ne rien faire de plus */ } 
    2828 
     29   std::map<StdString, ETranformationType> CScalar::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     30   bool CScalar::dummyTransformationMapList_ = CScalar::initializeTransformationMap(CScalar::transformationMapList_); 
     31   bool CScalar::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     32   { 
     33     m["reduce_axis"] = TRANS_REDUCE_AXIS_TO_SCALAR; 
     34   } 
     35 
    2936   StdString CScalar::GetName(void)   { return (StdString("scalar")); } 
    3037   StdString CScalar::GetDefName(void){ return (CScalar::GetName()); } 
     
    4956   void CScalar::checkAttributes(void) 
    5057   { 
    51 //      if (this->value.isEmpty()) 
    52 //      { 
    53 //        this->value.setValue(0); 
    54 //      } 
    5558   } 
    5659 
     
    124127  } 
    125128 
     129  /*! 
     130    Parse children nodes of a scalar in xml file. 
     131    \param node child node to process 
     132  */ 
     133  void CScalar::parse(xml::CXMLNode & node) 
     134  { 
     135    SuperClass::parse(node); 
     136 
     137    if (node.goToChildElement()) 
     138    { 
     139      StdString nodeElementName; 
     140      do 
     141      { 
     142        StdString nodeId(""); 
     143        if (node.getAttributes().end() != node.getAttributes().find("id")) 
     144        { nodeId = node.getAttributes()["id"]; } 
     145 
     146        nodeElementName = node.getElementName(); 
     147        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
     148        it = transformationMapList_.find(nodeElementName); 
     149        if (ite != it) 
     150        { 
     151          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CScalar>::createTransformation(it->second, 
     152                                                                                                                 nodeId, 
     153                                                                                                                 &node))); 
     154        } 
     155      } while (node.goToNextElement()) ; 
     156      node.goToParentElement(); 
     157    } 
     158  } 
    126159 
    127160  // Definition of some macros 
  • XIOS/trunk/src/node/scalar.hpp

    r887 r888  
    6868            bool IsWritten(const StdString& filename) const; 
    6969            void checkAttributesOnClient(); 
     70            virtual void parse(xml::CXMLNode & node); 
    7071 
    7172         public: 
     
    7576           void duplicateTransformation(CScalar*); 
    7677           CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id=""); 
     78 
    7779         private: 
    7880           std::set<StdString> relFiles; 
     
    8284            void checkTransformations(); 
    8385            void setTransformations(const TransMapTypes&); 
    84          private: 
     86 
     87       private: 
     88           static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m); 
     89           static std::map<StdString, ETranformationType> transformationMapList_; 
     90           static bool dummyTransformationMapList_; 
     91 
     92 
    8593            DECLARE_REF_FUNC(Scalar,scalar) 
    8694 
  • XIOS/trunk/src/node/transformation_enum.hpp

    r836 r888  
    1212        TRANS_ZOOM_DOMAIN = 3, 
    1313        TRANS_INTERPOLATE_DOMAIN = 4, 
    14         TRANS_GENERATE_RECTILINEAR_DOMAIN = 5 
     14        TRANS_GENERATE_RECTILINEAR_DOMAIN = 5, 
     15        TRANS_REDUCE_AXIS_TO_SCALAR = 6 
    1516      } ETranformationType; 
    1617 
  • XIOS/trunk/src/object_factory_decl.cpp

    r887 r888  
    3333  macro(CGenerateRectilinearDomain) 
    3434  macro(CScalar) 
     35  macro(CReduceAxisToScalar) 
    3536 
    3637  macro(CFieldGroup) 
     
    4849  macro(CGenerateRectilinearDomainGroup) 
    4950  macro(CScalarGroup) 
     51  macro(CReduceAxisToScalarGroup) 
    5052} 
  • XIOS/trunk/src/object_template_decl.cpp

    r887 r888  
    2020  template class CObjectTemplate<CGenerateRectilinearDomain>; 
    2121  template class CObjectTemplate<CScalar>; 
     22  template class CObjectTemplate<CReduceAxisToScalar>; 
    2223 
    2324  template class CObjectTemplate<CContextGroup>; 
     
    3536  template class CObjectTemplate<CGenerateRectilinearDomainGroup>; 
    3637  template class CObjectTemplate<CScalarGroup>; 
     38  template class CObjectTemplate<CReduceAxisToScalarGroup>; 
    3739} 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

    r867 r888  
    4343*/ 
    4444void CAxisAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex, 
     45                                                              int elementType, 
    4546                                                              CClientClientDHTInt::Index2VectorInfoTypeMap& globalAxisIndexOnProc) 
    4647{ 
     
    4950  int clientRank = client->clientRank; 
    5051  int clientSize = client->clientSize; 
     52 
    5153 
    5254  size_t globalIndex; 
  • XIOS/trunk/src/transformation/axis_algorithm_transformation.hpp

    r867 r888  
    3030 
    3131  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex, 
     32                                          int elementType, 
    3233                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc); 
    3334 
  • XIOS/trunk/src/transformation/domain_algorithm_transformation.cpp

    r867 r888  
    3434*/ 
    3535void CDomainAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex, 
     36                                                                int elementType, 
    3637                                                                CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc) 
    3738{ 
  • XIOS/trunk/src/transformation/domain_algorithm_transformation.hpp

    r867 r888  
    3131 
    3232  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex, 
    33                                   CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc); 
     33                                          int elementType, 
     34                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc); 
    3435 
    3536protected: 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

    r887 r888  
    1717 : transformationMapping_(), transformationWeight_(), transformationPosition_(), idAuxInputs_() 
    1818{ 
     19} 
     20 
     21void CGenericAlgorithmTransformation::apply(const std::vector<std::pair<int,double> >& localIndex, 
     22                                            const double* dataInput, 
     23                                            CArray<double,1>& dataOut, 
     24                                            std::vector<bool>& flagInitial) 
     25{ 
     26  int nbLocalIndex = localIndex.size(); 
     27  for (int idx = 0; idx < nbLocalIndex; ++idx) 
     28  { 
     29    dataOut(localIndex[idx].first) = *(dataInput + idx) * localIndex[idx].second; 
     30  } 
     31} 
     32 
     33void CGenericAlgorithmTransformation::computePositionElements(CGrid* dst, CGrid* src) 
     34{ 
     35  int idxScalar = 0, idxAxis = 0, idxDomain = 0; 
     36  CArray<int,1> axisDomainOrderDst = dst->axis_domain_order; 
     37  for (int i = 0; i < axisDomainOrderDst.numElements(); ++i) 
     38  { 
     39    int dimElement = axisDomainOrderDst(i); 
     40    if (2 == dimElement) 
     41    { 
     42      elementPositionInGridDst2DomainPosition_[i] = idxDomain; 
     43      ++idxDomain; 
     44    } 
     45    else if (1 == dimElement) 
     46    { 
     47      elementPositionInGridDst2AxisPosition_[i] = idxAxis; 
     48      ++idxAxis; 
     49    } 
     50    else 
     51    { 
     52      elementPositionInGridDst2ScalarPosition_[i] = idxScalar; 
     53      ++idxScalar; 
     54    } 
     55  } 
     56 
     57  idxScalar = idxAxis = idxDomain = 0; 
     58  CArray<int,1> axisDomainOrderSrc = src->axis_domain_order; 
     59  for (int i = 0; i < axisDomainOrderSrc.numElements(); ++i) 
     60  { 
     61    int dimElement = axisDomainOrderSrc(i); 
     62    if (2 == dimElement) 
     63    { 
     64      elementPositionInGridSrc2DomainPosition_[i] = idxDomain; 
     65      ++idxDomain; 
     66    } 
     67    else if (1 == dimElement) 
     68    { 
     69      elementPositionInGridSrc2AxisPosition_[i] = idxAxis; 
     70      ++idxAxis; 
     71    } 
     72    else 
     73    { 
     74      elementPositionInGridSrc2ScalarPosition_[i] = idxScalar; 
     75      ++idxScalar; 
     76    } 
     77  } 
    1978} 
    2079 
     
    82141  } 
    83142 
     143  // compute position of elements on grids 
     144  computePositionElements(gridDst, gridSrc); 
     145  std::vector<CScalar*> scalarListDestP = gridDst->getScalars(); 
    84146  std::vector<CAxis*> axisListDestP = gridDst->getAxis(); 
    85147  std::vector<CDomain*> domainListDestP = gridDst->getDomains(); 
    86148  CArray<int,1> axisDomainDstOrder = gridDst->axis_domain_order; 
     149  std::vector<CScalar*> scalarListSrcP  = gridSrc->getScalars(); 
    87150  std::vector<CAxis*> axisListSrcP = gridSrc->getAxis(); 
    88151  std::vector<CDomain*> domainListSrcP = gridSrc->getDomains(); 
     152  CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order; 
    89153 
    90154  // Find out global index source of transformed element on corresponding process. 
     
    95159  { 
    96160    if (idx == elementPositionInGrid) 
    97       computeExchangeGlobalIndex(indexSrc, globalIndexOfTransformedElementOnProc); //globalElementIndexOnProc[idx]); 
     161      computeExchangeGlobalIndex(indexSrc, axisDomainSrcOrder(idx), globalIndexOfTransformedElementOnProc); //globalElementIndexOnProc[idx]); 
    98162    if (2 == axisDomainDstOrder(idx)) // It's domain 
    99163    { 
    100164      if (idx != elementPositionInGrid) 
    101         computeExchangeDomainIndex(domainListDestP[domainIndex], 
    102                                    domainListSrcP[domainIndex], 
     165        computeExchangeDomainIndex(domainListDestP[elementPositionInGridDst2DomainPosition_[idx]], 
     166                                   domainListSrcP[elementPositionInGridSrc2DomainPosition_[idx]], 
    103167                                   transPos, 
    104168                                   globalElementIndexOnProc[idx]); 
     
    109173    { 
    110174      if (idx != elementPositionInGrid) 
    111         computeExchangeAxisIndex(axisListDestP[axisIndex], 
    112                                  axisListSrcP[axisIndex], 
     175        computeExchangeAxisIndex(axisListDestP[elementPositionInGridDst2AxisPosition_[idx]], 
     176                                 axisListSrcP[elementPositionInGridSrc2AxisPosition_[idx]], 
    113177                                 transPos, 
    114178                                 globalElementIndexOnProc[idx]); 
    115179      ++axisIndex; 
     180 
     181    } 
     182    else //it's a scalar 
     183    { 
     184      if (idx != elementPositionInGrid) 
     185        computeExchangeScalarIndex(scalarListDestP[elementPositionInGridDst2ScalarPosition_[idx]], 
     186                                   scalarListSrcP[elementPositionInGridSrc2ScalarPosition_[idx]], 
     187                                   transPos, 
     188                                   globalElementIndexOnProc[idx]); 
    116189 
    117190    } 
     
    269342  { 
    270343    nGlobDst[idx] = globalDstSize; 
    271     int elementDimension = axisDomainSrcOrder(idx); 
     344    int elementDimension = axisDomainDstOrder(idx); 
    272345 
    273346    // If this is a domain 
     
    359432/*! 
    360433  Find out proc and global index of axis source which axis destination is on demande 
     434  \param[in] scalar Scalar destination 
     435  \param[in] scalar Scalar source 
     436  \param[in] destGlobalIndexPositionInGrid Relative position of axis corresponds to other element of grid. 
     437  \param[out] globalScalarIndexOnProc Global index of axis source on different procs 
     438*/ 
     439void CGenericAlgorithmTransformation::computeExchangeScalarIndex(CScalar* scalarDst, 
     440                                                                 CScalar* scalarSrc, 
     441                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid, 
     442                                                                 boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc) 
     443{ 
     444  CContext* context = CContext::getCurrent(); 
     445  CContextClient* client=context->client; 
     446  int clientRank = client->clientRank; 
     447  int clientSize = client->clientSize; 
     448 
     449  globalScalarIndexOnProc.rehash(std::ceil(clientSize/globalScalarIndexOnProc.max_load_factor())); 
     450  for (int idx = 0; idx < clientSize; ++idx) 
     451  { 
     452    globalScalarIndexOnProc[idx].push_back(0); 
     453  } 
     454} 
     455 
     456/*! 
     457  Find out proc and global index of axis source which axis destination is on demande 
    361458  \param[in] axisDst Axis destination 
    362459  \param[in] axisSrc Axis source 
  • XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

    r867 r888  
    1919  class CDomain; 
    2020  class CAxis; 
     21  class CScalar; 
    2122 
    2223  /*! 
     
    5253                               SourceDestinationIndexMap& globaIndexWeightFromSrcToDst); 
    5354 
     55    /*! 
     56    Apply a reduction operation on local data. 
     57    \param [in] localIndex vector contains local index of local data output and the corresponding weight 
     58    \param [in] dataInput Pointer to the first element of data input array (in form of buffer) 
     59    \param [in/out] dataOut Array contains local data 
     60    \param [in/out] flagInitial vector of boolean to mark the local index already initialized. True means there is a need for initalization 
     61  */ 
     62  virtual void apply(const std::vector<std::pair<int,double> >& localIndex, 
     63                     const double* dataInput, 
     64                     CArray<double,1>& dataOut, 
     65                     std::vector<bool>& flagInitial); 
     66 
    5467  std::vector<StdString> getIdAuxInputs(); 
    5568 
     
    6578  Compute proc which contains global index of an element 
    6679    \param[in] globalElementIndex demanding global index of an element of source grid 
     80    \param[in] elementType type of source element, 2: domain, 1: axis and 0: scalar 
    6781    \param[out] globalElementIndexOnProc Proc contains the demanding global index 
    6882  */ 
    6983  virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalElementIndex, 
     84                                          int elementType, 
    7085                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalElementIndexOnProc) = 0; 
    7186 
     
    89104                                boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc); 
    90105 
     106  void computeExchangeScalarIndex(CScalar* scalarDst, 
     107                                  CScalar* scalarSrc, 
     108                                  CArray<size_t,1>& destGlobalIndexPositionInGrid, 
     109                                  boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc); 
     110 
     111  void computePositionElements(CGrid* dst, CGrid* src); 
     112 
    91113protected: 
    92114  //! Map between global index of destination element and source element 
     
    100122  //! Id of auxillary inputs which helps doing transformation dynamically 
    101123  std::vector<StdString> idAuxInputs_; 
     124 
     125  std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_; 
     126  std::map<int, int> elementPositionInGridDst2AxisPosition_, elementPositionInGridDst2DomainPosition_, elementPositionInGridDst2ScalarPosition_; 
    102127}; 
    103128 
  • XIOS/trunk/src/transformation/grid_transformation.cpp

    r887 r888  
    88 */ 
    99#include "grid_transformation.hpp" 
     10#include "reduce_axis_to_scalar.hpp" 
     11#include "scalar_algorithm_reduce_axis.hpp" 
    1012#include "axis_algorithm_inverse.hpp" 
    1113#include "axis_algorithm_zoom.hpp" 
     
    4244void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    4345{ 
    44  
     46  int scalarSrcIndex = -1, axisSrcIndex = -1, domainSrcIndex = -1; 
     47  std::vector<CScalar*> scaListDestP = gridDestination_->getScalars(); 
     48  std::vector<CScalar*> scaListSrcP  = gridSource_->getScalars(); 
     49  std::vector<CAxis*> axisListSrcP   = gridSource_->getAxis(); 
     50  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
     51 
     52  int scalarDstIndex =  elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
     53  CScalar::TransMapTypes trans = scaListDestP[scalarDstIndex]->getAllTransformations(); 
     54  CScalar::TransMapTypes::const_iterator it = trans.begin(); 
     55 
     56  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation 
     57 
     58  CReduceAxisToScalar* reduceAxis = 0; 
     59  CGenericAlgorithmTransformation* algo = 0; 
     60  switch (transType) 
     61  { 
     62    case TRANS_REDUCE_AXIS_TO_SCALAR: 
     63      reduceAxis = dynamic_cast<CReduceAxisToScalar*> (it->second); 
     64      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
     65      algo = new CScalarAlgorithmReduceScalar(scaListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis); 
     66      break; 
     67    default: 
     68      break; 
     69  } 
     70  algoTransformation_.push_back(algo); 
    4571} 
    4672 
     
    5379void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder) 
    5480{ 
     81  int axisSrcIndex = -1, domainSrcIndex = -1; 
    5582  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis(); 
    5683  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(); 
    57  
    58   int axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
    59   CAxis::TransMapTypes trans = axisListDestP[axisIndex]->getAllTransformations(); 
     84  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains(); 
     85 
     86  int axisDstIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
     87  CAxis::TransMapTypes trans = axisListDestP[axisDstIndex]->getAllTransformations(); 
    6088  CAxis::TransMapTypes::const_iterator it = trans.begin(); 
    6189 
     
    6997    case TRANS_INTERPOLATE_AXIS: 
    7098      interpAxis = dynamic_cast<CInterpolateAxis*> (it->second); 
    71       algo = new CAxisAlgorithmInterpolate(axisListDestP[axisIndex], axisListSrcP[axisIndex], interpAxis); 
     99      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
     100      algo = new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpAxis); 
    72101      break; 
    73102    case TRANS_ZOOM_AXIS: 
    74103      zoomAxis = dynamic_cast<CZoomAxis*> (it->second); 
    75       algo = new CAxisAlgorithmZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis); 
     104      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
     105      algo = new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis); 
    76106      break; 
    77107    case TRANS_INVERSE_AXIS: 
    78       algo = new CAxisAlgorithmInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]); 
     108      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid]; 
     109      algo = new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex]); 
    79110      break; 
    80111    default: 
     
    159190    case TRANS_INVERSE_AXIS: 
    160191      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
     192      break; 
     193 
     194    case TRANS_REDUCE_AXIS_TO_SCALAR: 
     195      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
    161196      break; 
    162197    default: 
     
    233268    case TRANS_INVERSE_AXIS: 
    234269      axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid]; 
     270      break; 
     271 
     272    case TRANS_REDUCE_AXIS_TO_SCALAR: 
     273      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid]; 
    235274      break; 
    236275    default: 
  • XIOS/trunk/src/transformation/grid_transformation_selector.hpp

    r887 r888  
    4242  int getNbAlgo() { return nbNormalAlgos_; } 
    4343  const std::vector<StdString>& getAuxInputs() const { return auxInputs_; } 
     44  const std::vector<CGenericAlgorithmTransformation*>& getAlgos() const { return algoTransformation_; } 
    4445 
    4546protected: 
     
    8081  std::vector<CGenericAlgorithmTransformation*> algoTransformation_; 
    8182 
    82   //! Position of axis and domain in grid 
     83  //! Position of scalar, axis and domain in grid 
    8384  std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_; 
    8485  std::map<int, int> elementPositionInGridDst2AxisPosition_, elementPositionInGridDst2DomainPosition_, elementPositionInGridDst2ScalarPosition_; 
  • XIOS/trunk/src/type/type_util.hpp

    r887 r888  
    3434    class CScalar; 
    3535    class CScalarGroup; 
     36    class CReduceAxisToScalar; 
     37    class CReduceAxisToScalarGroup; 
    3638 
    3739  template <typename T> inline string getStrType(void); 
     
    8486  macro(CScalar) 
    8587  macro(CScalarGroup) 
     88  macro(CReduceAxisToScalar) 
     89  macro(CReduceAxisToScalarGroup) 
    8690#undef macro 
    8791} 
  • XIOS/trunk/src/xml_parser_decl.cpp

    r887 r888  
    2626    macro( GenerateRectilinearDomain ) 
    2727    macro( Scalar ) 
     28    macro( ReduceAxisToScalar ) 
    2829  } 
    2930} 
Note: See TracChangeset for help on using the changeset viewer.