Changeset 888

Timestamp:

07/05/16 15:59:10 (8 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:

• config/node_type.conf (modified) (1 diff)
• config/reduce_axis_to_scalar_attribute.conf (added)
• distribution_client.cpp (modified) (3 diffs)
• filter/spatial_transform_filter.cpp (modified) (4 diffs)
• group_factory_decl.cpp (modified) (1 diff)
• group_template_decl.cpp (modified) (1 diff)
• node/node_enum.hpp (modified) (1 diff)
• node/node_type.hpp (modified) (1 diff)
• node/reduce_axis_to_scalar.cpp (added)
• node/reduce_axis_to_scalar.hpp (added)
• node/scalar.cpp (modified) (3 diffs)
• node/scalar.hpp (modified) (3 diffs)
• node/transformation_enum.hpp (modified) (1 diff)
• object_factory_decl.cpp (modified) (2 diffs)
• object_template_decl.cpp (modified) (2 diffs)
• transformation/Functions (added)
• transformation/Functions/max.cpp (added)
• transformation/Functions/max.hpp (added)
• transformation/Functions/min.cpp (added)
• transformation/Functions/min.hpp (added)
• transformation/Functions/reduction.cpp (added)
• transformation/Functions/reduction.hpp (added)
• transformation/Functions/reduction_types.hpp (added)
• transformation/Functions/sum.cpp (added)
• transformation/Functions/sum.hpp (added)
• transformation/axis_algorithm_transformation.cpp (modified) (2 diffs)
• transformation/axis_algorithm_transformation.hpp (modified) (1 diff)
• transformation/domain_algorithm_transformation.cpp (modified) (1 diff)
• transformation/domain_algorithm_transformation.hpp (modified) (1 diff)
• transformation/generic_algorithm_transformation.cpp (modified) (6 diffs)
• transformation/generic_algorithm_transformation.hpp (modified) (5 diffs)
• transformation/grid_transformation.cpp (modified) (6 diffs)
• transformation/grid_transformation_selector.hpp (modified) (2 diffs)
• transformation/scalar_algorithm_reduce_axis.cpp (added)
• transformation/scalar_algorithm_reduce_axis.hpp (added)
• transformation/scalar_algorithm_transformation.cpp (added)
• transformation/scalar_algorithm_transformation.hpp (added)
• type/type_util.hpp (modified) (2 diffs)
• xml_parser_decl.cpp (modified) (1 diff)

XIOS/trunk/src/config/node_type.conf

@@ -59 +59 @@
 #endif //__XIOS_CScalar__
 
+#ifdef __XIOS_CReduceAxisToScalar__
+   DECLARE_NODE(ReduceAxisToScalar, reduce_axis)
+#endif //__XIOS_CReduceAxisToScalar__
+
 #ifdef __XIOS_CContext__
    DECLARE_NODE_PAR(Context, context)

XIOS/trunk/src/distribution_client.cpp

@@ -65 +65 @@
   grid->checkMask();
   switch (gridDim) {
+    case 0:
+      gridMask_.resize(1);
+      gridMask_(0) = true;
+      break;
     case 1:
       readGridMaskInfo(grid->mask_1d);
@@ -416 +420 @@
   createLocalDomainDataIndex();
   createLocalAxisDataIndex();
+  createLocalScalarDataIndex();
 
   int idxDomain = 0, idxAxis = 0;
@@ -579 +584 @@
 void CDistributionClient::createGlobalIndex()
 {
-//  size_t ssize = 1, idx = 0;
-//  for (int i = 0; i < this->dims_; ++i)
-//  ssize *= nLocal_[i];
-//
-//  this->globalIndex_.resize(ssize);
-//  std::vector<int> idxLoop(this->numElement_,0);
-//  int innnerLoopSize = (infoIndex_[0]).numElements();
-//  while (idx < ssize)
-//  {
-//    for (int i = 0; i < this->numElement_; ++i)
-////    {
-//      if (idxLoop[i] == (infoIndex_[indexMap_[i]]).numElements())
-//      {
-//        idxLoop[i] = 0;
-//        ++idxLoop[i+1];
-//      }
-//    }
-//
-//    for (int i = 0; i < innnerLoopSize; ++i)
-//    {
-//      size_t globalIndex = (infoIndex_[0])(idxLoop[0]);
-//      size_t mulDim = 1;
-//      for (int idxElement = 0; idxElement < this->numElement_; ++idxElement)
-//      {
-//        if (axisDomainOrder_(idxElement))
-//        {
-//          int jb = (0 == idxElement) ? 1 : 0;
-//          for (int j = jb; j <= 1; ++j)
-//          {
-//            mulDim *= nGlob_[indexMap_[idxElement]+j-1];
-//            globalIndex += ((infoIndex_[indexMap_[idxElement]+j])(idxLoop[idxElement]))*mulDim;
-//          }
-//        }
-//        else
-//        {
-//          if (0 != idxElement)
-//          {
-//            mulDim *= nGlob_[indexMap_[idxElement]-1];
-//            globalIndex += ((infoIndex_[indexMap_[idxElement]])(idxLoop[idxElement]))*mulDim;
-//          }
-//        }
-//      }
-//
-//      this->globalIndex_(idx) = globalIndex;
-//      ++idxLoop[0];
-//      ++idx;
-//    }
-//  }
 }
 

XIOS/trunk/src/filter/spatial_transform_filter.cpp

@@ -122 +122 @@
     const std::list<size_t>& listNbLocalIndexToReceive = gridTransformation->getNbLocalIndexToReceiveOnGridDest();
     const std::list<std::vector<bool> >& listLocalIndexMaskOnDest = gridTransformation->getLocalMaskIndexOnGridDest();
+    const std::vector<CGenericAlgorithmTransformation*>& listAlgos = gridTransformation->getAlgos();
 
     CArray<double,1> dataCurrentDest(dataSrc.copy());
@@ -130 +131 @@
     std::list<size_t>::const_iterator itNbListRecv = listNbLocalIndexToReceive.begin();
     std::list<std::vector<bool> >::const_iterator itLocalMaskIndexOnDest = listLocalIndexMaskOnDest.begin();
-
-    for (; itListSend != iteListSend; ++itListSend, ++itListRecv, ++itNbListRecv, ++itLocalMaskIndexOnDest)
+    std::vector<CGenericAlgorithmTransformation*>::const_iterator itAlgo = listAlgos.begin();
+
+    for (; itListSend != iteListSend; ++itListSend, ++itListRecv, ++itNbListRecv, ++itLocalMaskIndexOnDest, ++itAlgo)
     {
       CArray<double,1> dataCurrentSrc(dataCurrentDest);
@@ -189 +191 @@
         else dataCurrentDest(i) = defaultValue;
 
+      std::vector<bool> localInitFlag(dataCurrentDest.size(), true);
       currentBuff = 0;
       for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
@@ -194 +197 @@
         int countSize = itRecv->second.size();
         const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second;
-        for (int idx = 0; idx < countSize; ++idx)
-        {
-          dataCurrentDest(localIndex_p[idx].first) += *(recvBuff+currentBuff+idx) * localIndex_p[idx].second;
-        }
+//        for (int idx = 0; idx < countSize; ++idx)
+//        {
+//          dataCurrentDest(localIndex_p[idx].first) += *(recvBuff+currentBuff+idx) * localIndex_p[idx].second;
+//        }
+        (*itAlgo)->apply(localIndex_p,
+                         recvBuff+currentBuff,
+                         dataCurrentDest,
+                         localInitFlag);
+
         currentBuff += countSize;
       }

XIOS/trunk/src/group_factory_decl.cpp

@@ -32 +32 @@
   macro(CGenerateRectilinearDomainGroup)
   macro(CScalarGroup)
+  macro(CReduceAxisToScalarGroup)
 }

XIOS/trunk/src/group_template_decl.cpp

@@ -21 +21 @@
   macro(GenerateRectilinearDomain)
   macro(Scalar)
+  macro(ReduceAxisToScalar)
 
 }

XIOS/trunk/src/node/node_enum.hpp

@@ -26 +26 @@
          eInterpolateDomain,
          eGenerateRectilinearDomain,
-         eScalar
+         eScalar,
+         eReduceAxisToScalar
 
       } ENodeType;

XIOS/trunk/src/node/node_type.hpp

@@ -17 +17 @@
 #include "generate_rectilinear_domain.hpp"
 #include "scalar.hpp"
+#include "reduce_axis_to_scalar.hpp"
 
 

XIOS/trunk/src/node/scalar.cpp

@@ -27 +27 @@
    { /* Ne rien faire de plus */ }
 
+   std::map<StdString, ETranformationType> CScalar::transformationMapList_ = std::map<StdString, ETranformationType>();
+   bool CScalar::dummyTransformationMapList_ = CScalar::initializeTransformationMap(CScalar::transformationMapList_);
+   bool CScalar::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+   {
+     m["reduce_axis"] = TRANS_REDUCE_AXIS_TO_SCALAR;
+   }
+
    StdString CScalar::GetName(void)   { return (StdString("scalar")); }
    StdString CScalar::GetDefName(void){ return (CScalar::GetName()); }
@@ -49 +56 @@
    void CScalar::checkAttributes(void)
    {
-//      if (this->value.isEmpty())
-//      {
-//        this->value.setValue(0);
-//      }
    }
 
@@ -124 +127 @@
   }
 
+  /*!
+    Parse children nodes of a scalar in xml file.
+    \param node child node to process
+  */
+  void CScalar::parse(xml::CXMLNode & node)
+  {
+    SuperClass::parse(node);
+
+    if (node.goToChildElement())
+    {
+      StdString nodeElementName;
+      do
+      {
+        StdString nodeId("");
+        if (node.getAttributes().end() != node.getAttributes().find("id"))
+        { nodeId = node.getAttributes()["id"]; }
+
+        nodeElementName = node.getElementName();
+        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it;
+        it = transformationMapList_.find(nodeElementName);
+        if (ite != it)
+        {
+          transformationMap_.push_back(std::make_pair(it->second, CTransformation<CScalar>::createTransformation(it->second,
+                                                                                                                 nodeId,
+                                                                                                                 &node)));
+        }
+      } while (node.goToNextElement()) ;
+      node.goToParentElement();
+    }
+  }
 
   // Definition of some macros

XIOS/trunk/src/node/scalar.hpp

@@ -68 +68 @@
             bool IsWritten(const StdString& filename) const;
             void checkAttributesOnClient();
+            virtual void parse(xml::CXMLNode & node);
 
          public:
@@ -75 +76 @@
            void duplicateTransformation(CScalar*);
            CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id="");
+
          private:
            std::set<StdString> relFiles;
@@ -82 +84 @@
             void checkTransformations();
             void setTransformations(const TransMapTypes&);
-         private:
+
+       private:
+           static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+           static std::map<StdString, ETranformationType> transformationMapList_;
+           static bool dummyTransformationMapList_;
+
+
             DECLARE_REF_FUNC(Scalar,scalar)
 

XIOS/trunk/src/node/transformation_enum.hpp

@@ -12 +12 @@
         TRANS_ZOOM_DOMAIN = 3,
         TRANS_INTERPOLATE_DOMAIN = 4,
-        TRANS_GENERATE_RECTILINEAR_DOMAIN = 5
+        TRANS_GENERATE_RECTILINEAR_DOMAIN = 5,
+        TRANS_REDUCE_AXIS_TO_SCALAR = 6
       } ETranformationType;
 

XIOS/trunk/src/object_factory_decl.cpp

@@ -33 +33 @@
   macro(CGenerateRectilinearDomain)
   macro(CScalar)
+  macro(CReduceAxisToScalar)
 
   macro(CFieldGroup)
@@ -48 +49 @@
   macro(CGenerateRectilinearDomainGroup)
   macro(CScalarGroup)
+  macro(CReduceAxisToScalarGroup)
 }

XIOS/trunk/src/object_template_decl.cpp

@@ -20 +20 @@
   template class CObjectTemplate<CGenerateRectilinearDomain>;
   template class CObjectTemplate<CScalar>;
+  template class CObjectTemplate<CReduceAxisToScalar>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -35 +36 @@
   template class CObjectTemplate<CGenerateRectilinearDomainGroup>;
   template class CObjectTemplate<CScalarGroup>;
+  template class CObjectTemplate<CReduceAxisToScalarGroup>;
 }

XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

@@ -43 +43 @@
 */
 void CAxisAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex,
+                                                              int elementType,
                                                               CClientClientDHTInt::Index2VectorInfoTypeMap& globalAxisIndexOnProc)
 {
@@ -49 +50 @@
   int clientRank = client->clientRank;
   int clientSize = client->clientSize;
+
 
   size_t globalIndex;

XIOS/trunk/src/transformation/axis_algorithm_transformation.hpp

@@ -30 +30 @@
 
   virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalAxisIndex,
+                                          int elementType,
                                           CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc);
 

XIOS/trunk/src/transformation/domain_algorithm_transformation.cpp

@@ -34 +34 @@
 */
 void CDomainAlgorithmTransformation::computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex,
+                                                                int elementType,
                                                                 CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc)
 {

XIOS/trunk/src/transformation/domain_algorithm_transformation.hpp

@@ -31 +31 @@
 
   virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalDomainIndex,
-                                  CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc);
+                                          int elementType,
+                                          CClientClientDHTInt::Index2VectorInfoTypeMap& globalDomainIndexOnProc);
 
 protected:

XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

@@ -17 +17 @@
  : transformationMapping_(), transformationWeight_(), transformationPosition_(), idAuxInputs_()
 {
+}
+
+void CGenericAlgorithmTransformation::apply(const std::vector<std::pair<int,double> >& localIndex,
+                                            const double* dataInput,
+                                            CArray<double,1>& dataOut,
+                                            std::vector<bool>& flagInitial)
+{
+  int nbLocalIndex = localIndex.size();
+  for (int idx = 0; idx < nbLocalIndex; ++idx)
+  {
+    dataOut(localIndex[idx].first) = *(dataInput + idx) * localIndex[idx].second;
+  }
+}
+
+void CGenericAlgorithmTransformation::computePositionElements(CGrid* dst, CGrid* src)
+{
+  int idxScalar = 0, idxAxis = 0, idxDomain = 0;
+  CArray<int,1> axisDomainOrderDst = dst->axis_domain_order;
+  for (int i = 0; i < axisDomainOrderDst.numElements(); ++i)
+  {
+    int dimElement = axisDomainOrderDst(i);
+    if (2 == dimElement)
+    {
+      elementPositionInGridDst2DomainPosition_[i] = idxDomain;
+      ++idxDomain;
+    }
+    else if (1 == dimElement)
+    {
+      elementPositionInGridDst2AxisPosition_[i] = idxAxis;
+      ++idxAxis;
+    }
+    else
+    {
+      elementPositionInGridDst2ScalarPosition_[i] = idxScalar;
+      ++idxScalar;
+    }
+  }
+
+  idxScalar = idxAxis = idxDomain = 0;
+  CArray<int,1> axisDomainOrderSrc = src->axis_domain_order;
+  for (int i = 0; i < axisDomainOrderSrc.numElements(); ++i)
+  {
+    int dimElement = axisDomainOrderSrc(i);
+    if (2 == dimElement)
+    {
+      elementPositionInGridSrc2DomainPosition_[i] = idxDomain;
+      ++idxDomain;
+    }
+    else if (1 == dimElement)
+    {
+      elementPositionInGridSrc2AxisPosition_[i] = idxAxis;
+      ++idxAxis;
+    }
+    else
+    {
+      elementPositionInGridSrc2ScalarPosition_[i] = idxScalar;
+      ++idxScalar;
+    }
+  }
 }
 
@@ -82 +141 @@
   }
 
+  // compute position of elements on grids
+  computePositionElements(gridDst, gridSrc);
+  std::vector<CScalar*> scalarListDestP = gridDst->getScalars();
   std::vector<CAxis*> axisListDestP = gridDst->getAxis();
   std::vector<CDomain*> domainListDestP = gridDst->getDomains();
   CArray<int,1> axisDomainDstOrder = gridDst->axis_domain_order;
+  std::vector<CScalar*> scalarListSrcP  = gridSrc->getScalars();
   std::vector<CAxis*> axisListSrcP = gridSrc->getAxis();
   std::vector<CDomain*> domainListSrcP = gridSrc->getDomains();
+  CArray<int,1> axisDomainSrcOrder = gridSrc->axis_domain_order;
 
   // Find out global index source of transformed element on corresponding process.
@@ -95 +159 @@
   {
     if (idx == elementPositionInGrid)
-      computeExchangeGlobalIndex(indexSrc, globalIndexOfTransformedElementOnProc); //globalElementIndexOnProc[idx]);
+      computeExchangeGlobalIndex(indexSrc, axisDomainSrcOrder(idx), globalIndexOfTransformedElementOnProc); //globalElementIndexOnProc[idx]);
     if (2 == axisDomainDstOrder(idx)) // It's domain
     {
       if (idx != elementPositionInGrid)
-        computeExchangeDomainIndex(domainListDestP[domainIndex],
-                                   domainListSrcP[domainIndex],
+        computeExchangeDomainIndex(domainListDestP[elementPositionInGridDst2DomainPosition_[idx]],
+                                   domainListSrcP[elementPositionInGridSrc2DomainPosition_[idx]],
                                    transPos,
                                    globalElementIndexOnProc[idx]);
@@ -109 +173 @@
     {
       if (idx != elementPositionInGrid)
-        computeExchangeAxisIndex(axisListDestP[axisIndex],
-                                 axisListSrcP[axisIndex],
+        computeExchangeAxisIndex(axisListDestP[elementPositionInGridDst2AxisPosition_[idx]],
+                                 axisListSrcP[elementPositionInGridSrc2AxisPosition_[idx]],
                                  transPos,
                                  globalElementIndexOnProc[idx]);
       ++axisIndex;
+
+    }
+    else //it's a scalar
+    {
+      if (idx != elementPositionInGrid)
+        computeExchangeScalarIndex(scalarListDestP[elementPositionInGridDst2ScalarPosition_[idx]],
+                                   scalarListSrcP[elementPositionInGridSrc2ScalarPosition_[idx]],
+                                   transPos,
+                                   globalElementIndexOnProc[idx]);
 
     }
@@ -269 +342 @@
   {
     nGlobDst[idx] = globalDstSize;
-    int elementDimension = axisDomainSrcOrder(idx);
+    int elementDimension = axisDomainDstOrder(idx);
 
     // If this is a domain
@@ -359 +432 @@
 /*!
   Find out proc and global index of axis source which axis destination is on demande
+  \param[in] scalar Scalar destination
+  \param[in] scalar Scalar source
+  \param[in] destGlobalIndexPositionInGrid Relative position of axis corresponds to other element of grid.
+  \param[out] globalScalarIndexOnProc Global index of axis source on different procs
+*/
+void CGenericAlgorithmTransformation::computeExchangeScalarIndex(CScalar* scalarDst,
+                                                                 CScalar* scalarSrc,
+                                                                 CArray<size_t,1>& destGlobalIndexPositionInGrid,
+                                                                 boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc)
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+  int clientRank = client->clientRank;
+  int clientSize = client->clientSize;
+
+  globalScalarIndexOnProc.rehash(std::ceil(clientSize/globalScalarIndexOnProc.max_load_factor()));
+  for (int idx = 0; idx < clientSize; ++idx)
+  {
+    globalScalarIndexOnProc[idx].push_back(0);
+  }
+}
+
+/*!
+  Find out proc and global index of axis source which axis destination is on demande
   \param[in] axisDst Axis destination
   \param[in] axisSrc Axis source

XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

@@ -19 +19 @@
   class CDomain;
   class CAxis;
+  class CScalar;
 
   /*!
@@ -52 +53 @@
                                SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
 
+    /*!
+    Apply a reduction operation on local data.
+    \param [in] localIndex vector contains local index of local data output and the corresponding weight
+    \param [in] dataInput Pointer to the first element of data input array (in form of buffer)
+    \param [in/out] dataOut Array contains local data
+    \param [in/out] flagInitial vector of boolean to mark the local index already initialized. True means there is a need for initalization
+  */
+  virtual void apply(const std::vector<std::pair<int,double> >& localIndex,
+                     const double* dataInput,
+                     CArray<double,1>& dataOut,
+                     std::vector<bool>& flagInitial);
+
   std::vector<StdString> getIdAuxInputs();
 
@@ -65 +78 @@
   Compute proc which contains global index of an element
     \param[in] globalElementIndex demanding global index of an element of source grid
+    \param[in] elementType type of source element, 2: domain, 1: axis and 0: scalar
     \param[out] globalElementIndexOnProc Proc contains the demanding global index
   */
   virtual void computeExchangeGlobalIndex(const CArray<size_t,1>& globalElementIndex,
+                                          int elementType,
                                           CClientClientDHTInt::Index2VectorInfoTypeMap& globalElementIndexOnProc) = 0;
 
@@ -89 +104 @@
                                 boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc);
 
+  void computeExchangeScalarIndex(CScalar* scalarDst,
+                                  CScalar* scalarSrc,
+                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
+                                  boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc);
+
+  void computePositionElements(CGrid* dst, CGrid* src);
+
 protected:
   //! Map between global index of destination element and source element
@@ -100 +122 @@
   //! Id of auxillary inputs which helps doing transformation dynamically
   std::vector<StdString> idAuxInputs_;
+
+  std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_;
+  std::map<int, int> elementPositionInGridDst2AxisPosition_, elementPositionInGridDst2DomainPosition_, elementPositionInGridDst2ScalarPosition_;
 };
 

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -8 +8 @@
  */
 #include "grid_transformation.hpp"
+#include "reduce_axis_to_scalar.hpp"
+#include "scalar_algorithm_reduce_axis.hpp"
 #include "axis_algorithm_inverse.hpp"
 #include "axis_algorithm_zoom.hpp"
@@ -42 +44 @@
 void CGridTransformation::selectScalarAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
 {
-
+  int scalarSrcIndex = -1, axisSrcIndex = -1, domainSrcIndex = -1;
+  std::vector<CScalar*> scaListDestP = gridDestination_->getScalars();
+  std::vector<CScalar*> scaListSrcP  = gridSource_->getScalars();
+  std::vector<CAxis*> axisListSrcP   = gridSource_->getAxis();
+  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains();
+
+  int scalarDstIndex =  elementPositionInGridDst2ScalarPosition_[elementPositionInGrid];
+  CScalar::TransMapTypes trans = scaListDestP[scalarDstIndex]->getAllTransformations();
+  CScalar::TransMapTypes::const_iterator it = trans.begin();
+
+  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation
+
+  CReduceAxisToScalar* reduceAxis = 0;
+  CGenericAlgorithmTransformation* algo = 0;
+  switch (transType)
+  {
+    case TRANS_REDUCE_AXIS_TO_SCALAR:
+      reduceAxis = dynamic_cast<CReduceAxisToScalar*> (it->second);
+      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid];
+      algo = new CScalarAlgorithmReduceScalar(scaListDestP[scalarDstIndex], axisListSrcP[axisSrcIndex], reduceAxis);
+      break;
+    default:
+      break;
+  }
+  algoTransformation_.push_back(algo);
 }
 
@@ -53 +79 @@
 void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
 {
+  int axisSrcIndex = -1, domainSrcIndex = -1;
   std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
   std::vector<CAxis*> axisListSrcP = gridSource_->getAxis();
-
-  int axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid];
-  CAxis::TransMapTypes trans = axisListDestP[axisIndex]->getAllTransformations();
+  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains();
+
+  int axisDstIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid];
+  CAxis::TransMapTypes trans = axisListDestP[axisDstIndex]->getAllTransformations();
   CAxis::TransMapTypes::const_iterator it = trans.begin();
 
@@ -69 +97 @@
     case TRANS_INTERPOLATE_AXIS:
       interpAxis = dynamic_cast<CInterpolateAxis*> (it->second);
-      algo = new CAxisAlgorithmInterpolate(axisListDestP[axisIndex], axisListSrcP[axisIndex], interpAxis);
+      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid];
+      algo = new CAxisAlgorithmInterpolate(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], interpAxis);
       break;
     case TRANS_ZOOM_AXIS:
       zoomAxis = dynamic_cast<CZoomAxis*> (it->second);
-      algo = new CAxisAlgorithmZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
+      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid];
+      algo = new CAxisAlgorithmZoom(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex], zoomAxis);
       break;
     case TRANS_INVERSE_AXIS:
-      algo = new CAxisAlgorithmInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
+      axisSrcIndex = elementPositionInGridSrc2AxisPosition_[elementPositionInGrid];
+      algo = new CAxisAlgorithmInverse(axisListDestP[axisDstIndex], axisListSrcP[axisSrcIndex]);
       break;
     default:
@@ -159 +190 @@
     case TRANS_INVERSE_AXIS:
       axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid];
+      break;
+
+    case TRANS_REDUCE_AXIS_TO_SCALAR:
+      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid];
       break;
     default:
@@ -233 +268 @@
     case TRANS_INVERSE_AXIS:
       axisIndex =  elementPositionInGridDst2AxisPosition_[elementPositionInGrid];
+      break;
+
+    case TRANS_REDUCE_AXIS_TO_SCALAR:
+      scalarIndex = elementPositionInGridDst2ScalarPosition_[elementPositionInGrid];
       break;
     default:

XIOS/trunk/src/transformation/grid_transformation_selector.hpp

@@ -42 +42 @@
   int getNbAlgo() { return nbNormalAlgos_; }
   const std::vector<StdString>& getAuxInputs() const { return auxInputs_; }
+  const std::vector<CGenericAlgorithmTransformation*>& getAlgos() const { return algoTransformation_; }
 
 protected:
@@ -80 +81 @@
   std::vector<CGenericAlgorithmTransformation*> algoTransformation_;
 
-  //! Position of axis and domain in grid
+  //! Position of scalar, axis and domain in grid
   std::map<int, int> elementPositionInGridSrc2AxisPosition_, elementPositionInGridSrc2DomainPosition_, elementPositionInGridSrc2ScalarPosition_;
   std::map<int, int> elementPositionInGridDst2AxisPosition_, elementPositionInGridDst2DomainPosition_, elementPositionInGridDst2ScalarPosition_;

XIOS/trunk/src/type/type_util.hpp

@@ -34 +34 @@
     class CScalar;
     class CScalarGroup;
+    class CReduceAxisToScalar;
+    class CReduceAxisToScalarGroup;
 
   template <typename T> inline string getStrType(void);
@@ -84 +86 @@
   macro(CScalar)
   macro(CScalarGroup)
+  macro(CReduceAxisToScalar)
+  macro(CReduceAxisToScalarGroup)
 #undef macro
 }

XIOS/trunk/src/xml_parser_decl.cpp

@@ -26 +26 @@
     macro( GenerateRectilinearDomain )
     macro( Scalar )
+    macro( ReduceAxisToScalar )
   }
 }