Changeset 622

Timestamp:

06/22/15 13:36:27 (9 years ago)

Author:

mhnguyen

Message:

Final testing transfomation algorithm: inverse axis (local commit)

+) Make some minor change to make sure one element (axis or domain) be able to have several similar transformation

Test
+) On Curie
+) test_new_feature: test passed with correct data written

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (3 diffs)
• src/filter/axis_algorithm_transformation.cpp (modified) (1 diff)
• src/filter/axis_algorithm_transformation.hpp (modified) (2 diffs)
• src/filter/axis_inverse.cpp (modified) (2 diffs)
• src/filter/axis_inverse.hpp (modified) (2 diffs)
• src/filter/axis_zoom.cpp (modified) (1 diff)
• src/filter/axis_zoom.hpp (modified) (1 diff)
• src/filter/generic_algorithm_transformation.hpp (modified) (2 diffs)
• src/filter/grid_transformation.cpp (modified) (7 diffs)
• src/filter/grid_transformation.hpp (modified) (3 diffs)
• src/filter/transformation_mapping.cpp (modified) (3 diffs)
• src/node/axis.cpp (modified) (2 diffs)
• src/node/axis.hpp (modified) (1 diff)
• src/node/domain.cpp (modified) (1 diff)
• src/node/domain.hpp (modified) (1 diff)
• src/node/grid.cpp (modified) (5 diffs)
• src/node/grid.hpp (modified) (1 diff)
• src/node/transformation.hpp (modified) (1 diff)
• src/node/zoom_axis.cpp (modified) (1 diff)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -11 +11 @@
      <field id="field_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Axis" />
      <field id="field_Two_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Two_Axis" />
-     <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_A" grid_ref="grid_Axis_tranformed" />
+     <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_Two_Axis" grid_ref="grid_Axis_tranformed" />
      <field id="field_All_Axis" operation="average" freq_op="3600s" grid_ref="grid_All_Axis" />
      <field id="field_Scalar" operation="average" freq_op="3600s" grid_ref="ScalarGrid" />
@@ -41 +41 @@
      <axis id="axis_C" />
      <axis id="axis_D" />
-     <axis id="axis_E" axis_ref="axis_C">
-<!--        <transformation type="zoom" />-->
+     <axis id="axis_E" axis_ref="axis_B">
         <inverse_axis />
-<!--        <zoom_axis zoom_begin=1 zoom_size=1 />-->
+        <inverse_axis />
+<!--        <zoom_axis zoom_begin="1" zoom_size="3" />-->
+     </axis>
+     <axis id="axis_F" axis_ref="axis_A">
+       <inverse_axis />
      </axis>
    </axis_definition>
@@ -66 +69 @@
        </grid>
        <grid id="grid_Axis_tranformed">
-         <domain domain_ref="domain_A" />
-<!--         <axis axis_ref="axis_A" />-->
-<!--         <axis axis_ref="axis_B" />-->
+<!--         <domain domain_ref="domain_A" />-->
+<!--         <axis axis_ref="axis_E" />-->
+         <axis axis_ref="axis_F" />
          <axis axis_ref="axis_E" />
+
        </grid>
        <grid id="grid_All_Axis">

XIOS/trunk/src/filter/axis_algorithm_transformation.cpp

@@ -5 +5 @@
 namespace xios {
 
-CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>& algos)
+CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource)
  : CGenericAlgorithmTransformation()
 {
-  for (int idx = 0; idx < algos.size(); ++idx)
-  {
-    switch (algos[idx])
-    {
-      case TRANS_ZOOM_AXIS:
-        algosOfAnAxis_.push_back(new CAxisZoom(axisDestination, axisSource));
-        break;
-      case TRANS_INVERSE_AXIS:
-        algosOfAnAxis_.push_back(new CAxisInverse(axisDestination, axisSource));
-        break;
-      default:
-        break;
-    }
-  }
-  computeIndexSourceMapping();
+//  if (axisDestination->size.getValue() != axisSource->size.getValue())
+//  {
+//    ERROR("CAxisZoom::CAxisZoom(CAxis* axisDestination, CAxis* axisSource)",
+//           << "Two axis have different size"
+//           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
+//           << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->size.getValue());
+//  }
+//
+//
+//  axisDestGlobalSize_ = axisDestination->size.getValue();
+//  int niDest = axisDestination->ni.getValue();
+//  int ibeginDest = axisDestination->ibegin.getValue();
+//
+//  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
 }
 
 CAxisAlgorithmTransformation::~CAxisAlgorithmTransformation()
 {
-  for (int idx = 0; idx < algosOfAnAxis_.size(); ++idx) delete algosOfAnAxis_[idx];
+//  for (int idx = 0; idx < algosOfAnAxis_.size(); ++idx) delete algosOfAnAxis_[idx];
 }
 
 void CAxisAlgorithmTransformation::computeIndexSourceMapping()
 {
-  if (!algosOfAnAxis_.empty())
-  {
-    algosOfAnAxis_[0]->computeIndexSourceMapping(this->transformationMapping_);
-    for (int idx = 1; idx < algosOfAnAxis_.size(); ++idx)
-    {
-      algosOfAnAxis_[idx]->computeIndexSourceMapping(algosOfAnAxis_[idx-1]->getTransformationMapping());
-    }
-    this->transformationMapping_ = algosOfAnAxis_[algosOfAnAxis_.size()-1]->getTransformationMapping();
-  }
+//  if (!algosOfAnAxis_.empty())
+//  {
+//    algosOfAnAxis_[0]->computeIndexSourceMapping(this->transformationMapping_);
+//    for (int idx = 1; idx < algosOfAnAxis_.size(); ++idx)
+//    {
+//      algosOfAnAxis_[idx]->computeIndexSourceMapping(algosOfAnAxis_[idx-1]->getTransformationMapping());
+//    }
+//    this->transformationMapping_ = algosOfAnAxis_[algosOfAnAxis_.size()-1]->getTransformationMapping();
+//  }
 }
 

XIOS/trunk/src/filter/axis_algorithm_transformation.hpp

@@ -11 +11 @@
 {
 public:
-  CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>&);
+  CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource);
 
   virtual ~CAxisAlgorithmTransformation();
@@ -25 +25 @@
   void computeIndexSourceMapping();
 protected:
-  std::vector<CConcreteAlgo*> algosOfAnAxis_;
+  std::vector<int> axisDestGlobalIndex_;
+  int axisDestGlobalSize_;
 
 };

XIOS/trunk/src/filter/axis_inverse.cpp

@@ -4 +4 @@
 
 CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)
- : CConcreteAlgo()
+ : CAxisAlgorithmTransformation(axisDestination, axisSource)
 {
   if (axisDestination->size.getValue() != axisSource->size.getValue())
@@ -20 +20 @@
 
   for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+  this->computeIndexSourceMapping();
 }
 
-void CAxisInverse::computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo)
+void CAxisInverse::computeIndexSourceMapping()
 {
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
-  if (transformationMappingOfPreviousAlgo.empty())
-  {
-    int globalIndexSize = axisDestGlobalIndex_.size();
-    for (int idx = 0; idx < globalIndexSize; ++idx)
-      transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
-  }
-  else
-  {
-    std::map<int, std::vector<int> >::const_iterator itb = transformationMappingOfPreviousAlgo.begin(), it,
-                                                     ite = transformationMappingOfPreviousAlgo.end();
-    for (it = itb; it != ite; ++it)
-    {
-      transMap[it->first].push_back(axisDestGlobalSize_-it->first-1);
-    }
-  }
+
+  int globalIndexSize = axisDestGlobalIndex_.size();
+  for (int idx = 0; idx < globalIndexSize; ++idx)
+    transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
 }
 

XIOS/trunk/src/filter/axis_inverse.hpp

@@ -2 +2 @@
 #define __XIOS_AXIS_ALGORITHM_INVERSE_HPP__
 
-#include "concrete_algo.hpp"
+#include "axis_algorithm_transformation.hpp"
 #include "axis.hpp"
 
 namespace xios {
 
-class CAxisInverse : public CConcreteAlgo
+class CAxisInverse : public CAxisAlgorithmTransformation //public CConcreteAlgo
 {
 public:
@@ -14 +14 @@
   virtual ~CAxisInverse() {}
 
-  virtual void computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo);
-
-protected:
-  std::vector<int> axisDestGlobalIndex_;
-
-private:
-  int axisDestGlobalSize_;
+  virtual void computeIndexSourceMapping();
 };
 

XIOS/trunk/src/filter/axis_zoom.cpp

@@ -3 +3 @@
 namespace xios {
 
-CAxisZoom::CAxisZoom(CAxis* axisDestination, CAxis* axisSource)
- : CConcreteAlgo()
+CAxisZoom::CAxisZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)
+: CAxisAlgorithmTransformation(axisDestination, axisSource), axisDest_(axisDestination), axisSrc_(axisSource)
 {
-  if (axisDestination->size.getValue() != axisSource->size.getValue())
+  zoomAxis->checkValid(axisSource);
+  zoomBegin_ = zoomAxis->zoom_begin.getValue();
+  zoomEnd_   = zoomAxis->zoom_end.getValue();
+  zoomSize_  = zoomAxis->zoom_size.getValue();
+
+  if (zoomSize_ > axisSource->size.getValue())
   {
-    ERROR("CAxisZoom::CAxisZoom(CAxis* axisDestination, CAxis* axisSource)",
-           << "Two axis have different size"
+    ERROR("CAxisZoom::CAxisZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)",
+           << "Zoom size is greater than size of axis source"
            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
-           << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->size.getValue());
+           << "Zoom size is " << zoomSize_ );
   }
 
-
-  axisDestGlobalSize_ = axisDestination->size.getValue();
-  int niDest = axisDestination->ni.getValue();
-  int ibeginDest = axisDestination->ibegin.getValue();
-
-  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+  // Axis destination now must have new size equal to zoom size
+  axisDestination->size.setValue(zoomSize_);
+  computeIndexSourceMapping();
 }
 
-void CAxisZoom::computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo)
+void CAxisZoom::computeIndexSourceMapping()
 {
-//  std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
-//  if (transformationMappingOfPreviousAlgo.empty())
-//  {
-//    int globalIndexSize = axisDestGlobalIndex_.size();
-//    for (int idx = 0; idx < globalIndexSize; ++idx)
-//      transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
-//  }
-//  else
-//  {
-//    std::map<int, std::vector<int> >::const_iterator itb = transformationMappingOfPreviousAlgo.begin(), it,
-//                                                     ite = transformationMappingOfPreviousAlgo.end();
-//    for (it = itb; it != ite; ++it)
-//    {
-//      transMap[it->first].push_back(axisDestGlobalSize_-it->first-1);
-//    }
-//  }
+  StdSize niSource = axisSrc_->ni.getValue();
+  StdSize ibeginSource = axisSrc_->ibegin.getValue();
+  StdSize iendSource = ibeginSource + niSource - 1;
+
+  StdSize ibegin = std::max(ibeginSource, zoomBegin_);
+  StdSize iend = std::min(iendSource, zoomEnd_);
+  StdSize ni = iend + 1 - ibegin;
+  if (ibeginSource > zoomEnd_)
+  {
+    axisDest_->ibegin.setValue(0);
+    axisDest_->ni.setValue(0);
+  }
+  else
+  {
+    axisDest_->ibegin.setValue(ibegin - zoomBegin_);
+    axisDest_->ni.setValue(ni);
+  }
+
+  std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
+  StdSize axisDestIBegin = axisDest_->ibegin.getValue();
+  for (StdSize idx = 0; idx < ni; ++idx)
+  {
+    transMap[axisDestIBegin+idx].push_back(ibegin+idx);
+  }
 }
 

XIOS/trunk/src/filter/axis_zoom.hpp

@@ -2 +2 @@
 #define __XIOS_AXIS_ALGORITHM_ZOOM_HPP__
 
-#include "concrete_algo.hpp"
+#include "axis_algorithm_transformation.hpp"
 #include "axis.hpp"
+#include "zoom_axis.hpp"
 
 namespace xios {
 
-class CAxisZoom : public CConcreteAlgo
+class CAxisZoom : public CAxisAlgorithmTransformation
 {
 public:
-  CAxisZoom(CAxis* axisDestination, CAxis* axisSource);
+  CAxisZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis);
 
   virtual ~CAxisZoom() {}
 
-  virtual void computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo);
-
-protected:
-  std::vector<int> axisDestGlobalIndex_;
+  virtual void computeIndexSourceMapping();
 
 private:
-  int axisDestGlobalSize_;
+  StdSize zoomBegin_;
+  StdSize zoomEnd_;
+  StdSize zoomSize_;
+
+private:
+  CAxis* axisDest_;
+  CAxis* axisSrc_;
 };
 

XIOS/trunk/src/filter/generic_algorithm_transformation.hpp

@@ -19 +19 @@
                                 const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                 std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
+
+                                  /*!
+  Compute global index mapping from one element of destination grid to the corresponding element of source grid
+  */
+  virtual void computeIndexSourceMapping() = 0;
+
 protected:
   /*!
@@ -38 +44 @@
                                                         std::vector<CArray<size_t,1> >& globalIndexSrcGrid) = 0;
 
-  /*!
-  Compute global index mapping from one element of destination grid to the corresponding element of source grid
-  */
-  virtual void computeIndexSourceMapping() = 0;
+
 
 protected:

XIOS/trunk/src/filter/grid_transformation.cpp

@@ -1 +1 @@
 #include "grid_transformation.hpp"
 #include "axis_inverse.hpp"
+#include "axis_zoom.hpp"
+#include "context.hpp"
+#include "context_client.hpp"
 #include "transformation_mapping.hpp"
-#include "transformation_enum.hpp"
+
 #include "axis_algorithm_transformation.hpp"
 
 namespace xios {
 CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source)
-: gridSource_(source), gridDestination_(destination)
+: gridSource_(source), gridDestination_(destination), originalGridSource_(source),
+  globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0)
 {
   //Verify the compatibity between two grids
@@ -26 +30 @@
   }
 
+  std::vector<CAxis*> axisSrcTmp = gridSource_->getAxis(), axisSrc;
+  std::vector<CDomain*> domainSrcTmp = gridSource_->getDomains(), domainSrc;
+  for (int idx = 0; idx < axisSrcTmp.size(); ++idx)
+  {
+    CAxis* axis = CAxis::createAxis();
+    axisSrcTmp[idx]->duplicateAttributes(axis);
+    axisSrc.push_back(axis);
+  }
+
+  for (int idx = 0; idx < domainSrcTmp.size(); ++idx)
+  {
+    CDomain* domain = CDomain::createDomain();
+    domainSrcTmp[idx]->duplicateAttributes(domain);
+    domainSrc.push_back(domain);
+  }
+
+  gridSource_ = CGrid::createGrid(domainSrc, axisSrc, gridDestination_->axis_domain_order);
   gridSourceDimensionSize_ = gridSource_->getGlobalDimension();
   gridDestinationDimensionSize_ = gridDestination_->getGlobalDimension();
+
+  initializeMappingOfOriginalGridSource();
   initializeAlgorithms();
 }
 
+void CGridTransformation::initializeMappingOfOriginalGridSource()
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  CDistributionClient distribution(client->clientRank, originalGridSource_);
+  const CArray<size_t,1>& globalIndexGridDestSendToServer = distribution.getGlobalDataIndexSendToServer();
+
+  globalIndexOfCurrentGridSource_   = new CArray<size_t,1>(globalIndexGridDestSendToServer.numElements());
+  globalIndexOfOriginalGridSource_  = new CArray<size_t,1>(globalIndexGridDestSendToServer.numElements());
+  *globalIndexOfCurrentGridSource_  = globalIndexGridDestSendToServer;
+  *globalIndexOfOriginalGridSource_ = globalIndexGridDestSendToServer;
+}
+
 CGridTransformation::~CGridTransformation()
 {
-  std::map<int, std::vector<CGenericAlgorithmTransformation*> >::const_iterator itb = algoTransformation_.begin(), it,
-                                                                                ite = algoTransformation_.end();
-  for (it = itb; it != ite; ++it)
-    for (int idx = 0; idx < (it->second).size(); ++idx)
-      delete (it->second)[idx];
+  std::list<CGenericAlgorithmTransformation*>::const_iterator itb = algoTransformation_.begin(), it,
+                                                              ite = algoTransformation_.end();
+  for (it = itb; it != ite; ++it) delete (*it);
 
   std::map<int, std::vector<CArray<int,1>* > >::const_iterator itMapRecv, iteMapRecv;
@@ -52 +87 @@
   iteMap = localIndexToSendFromGridSource_.end();
   for (; itMap != iteMap; ++itMap) delete (itMap->second);
+
+  if (0 != globalIndexOfCurrentGridSource_) delete globalIndexOfCurrentGridSource_;
+  if (0 != globalIndexOfOriginalGridSource_) delete globalIndexOfOriginalGridSource_;
 }
 
@@ -86 +124 @@
     for (int i = 0; i < axisListDestP.size(); ++i)
     {
+      elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i;
       if (axisListDestP[i]->hasTransformation())
       {
-        CGenericAlgorithmTransformation* algo = 0;
         CAxis::TransMapTypes trans = axisListDestP[i]->getAllTransformations();
         CAxis::TransMapTypes::const_iterator itb = trans.begin(), it,
                                              ite = trans.end();
-        std::vector<ETranformationType> algoAxis;
+        int transformationOrder = 0;
         for (it = itb; it != ite; ++it)
         {
-          algoAxis.push_back(it->first);
+          listAlgos_.push_back(std::make_pair(axisPositionInGrid[i], std::make_pair(it->first, transformationOrder)));
+          ++transformationOrder;
         }
-        algo = new CAxisAlgorithmTransformation(axisListDestP[i], axisListSrcP[i], algoAxis);
-        algoTransformation_[axisPositionInGrid[i]].push_back(algo);
       }
     }
@@ -108 +145 @@
 
 }
+
+void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+{
+   selectAxisAlgo(elementPositionInGrid, transType, transformationOrder);
+}
+
+void CGridTransformation::selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+{
+  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
+  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis();
+
+  int axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid];
+  CAxis::TransMapTypes trans = axisListDestP[axisIndex]->getAllTransformations();
+  CAxis::TransMapTypes::const_iterator it = trans.begin();
+
+  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation
+
+  CZoomAxis* zoomAxis = 0;
+  CGenericAlgorithmTransformation* algo = 0;
+  switch (transType)
+  {
+    case TRANS_ZOOM_AXIS:
+      zoomAxis = dynamic_cast<CZoomAxis*> (it->second);
+      algo = new CAxisZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
+      break;
+    case TRANS_INVERSE_AXIS:
+      algo = new CAxisInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
+      break;
+    default:
+      break;
+  }
+  algoTransformation_.push_back(algo);
+
+}
+
+void CGridTransformation::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
+{
+
+}
+
+void CGridTransformation::setUpGrid(int elementPositionInGrid, ETranformationType transType)
+{
+  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
+  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis();
+
+  int axisIndex;
+  switch (transType)
+  {
+    case TRANS_ZOOM_AXIS:
+    case TRANS_INVERSE_AXIS:
+      axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid];
+      axisListDestP[axisIndex]->duplicateAttributes(axisListSrcP[axisIndex]);
+      break;
+    default:
+      break;
+  }
+}
+
+void CGridTransformation::computeAll()
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  ListAlgoType::const_iterator itb = listAlgos_.begin(),
+                               ite = listAlgos_.end(), it;
+  CGenericAlgorithmTransformation* algo = 0;
+  for (it = itb; it != ite; ++it)
+  {
+    std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource;
+    int elementPositionInGrid = it->first;
+    ETranformationType transType = (it->second).first;
+    int transformationOrder = (it->second).second;
+
+    // First of all, select an algorithm
+    selectAlgo(elementPositionInGrid, transType, transformationOrder);
+    algo = algoTransformation_.back();
+
+    // Recalculate the distribution of grid destination
+    CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
+    const CArray<size_t,1>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
+
+    // ComputeTransformation of global index of each element
+    std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
+    int elementPosition = it->first;
+    algo->computeGlobalSourceIndex(elementPosition,
+                                   gridDestinationDimensionSize,
+                                   globalIndexGridDestSendToServer,
+                                   globaIndexMapFromDestToSource);
+
+    // Compute transformation of global indexes among grids
+    computeTransformationFromOriginalGridSource(globaIndexMapFromDestToSource);
+
+    // Now grid destination becomes grid source in a new transformation
+    setUpGrid(elementPositionInGrid, transType);
+  }
+
+ std::cout << "global index destination 0 " << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 " << *globalIndexOfOriginalGridSource_ << std::endl;
+  computeFinalTransformationMapping();
+}
+
 
 /*!
@@ -116 +254 @@
 void CGridTransformation::computeTransformation()
 {
-  const CArray<size_t,1>& globalIndexGridDestSendToServer = gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
-  std::map<int, std::vector<CGenericAlgorithmTransformation*> >::const_iterator itbMap, itMap, iteMap;
-  itbMap = algoTransformation_.begin();
-  iteMap = algoTransformation_.end();
-
-  std::vector<CGenericAlgorithmTransformation*>::const_iterator itbVec, itVec, iteVec;
-
-  for (itMap = itbMap; itMap != iteMap; ++itMap)
-  {
-    int elementPosition = itMap->first;
-    itbVec = (itMap->second).begin();
-    iteVec = (itMap->second).end();
-    for (itVec = itbVec; itVec != iteVec; ++itVec)
-    {
-      (*itVec)->computeGlobalSourceIndex(elementPosition,
-                                         gridDestinationDimensionSize_,
-                                         globalIndexGridDestSendToServer,
-                                         globaIndexMapFromDestToSource_);
-    }
-  }
+//  const CArray<size_t,1>& globalIndexGridDestSendToServer = gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
+//  std::list<std::pair<int,CGenericAlgorithmTransformation*> >::const_iterator itbMap, itMap, iteMap;
+//  itbMap = algoTransformation_.begin();
+//  iteMap = algoTransformation_.end();
+//
+//  std::vector<CGenericAlgorithmTransformation*>::const_iterator itbVec, itVec, iteVec;
+//
+//  for (itMap = itbMap; itMap != iteMap; ++itMap)
+//  {
+//    int elementPosition = itMap->first;
+//    itbVec = (itMap->second).begin();
+//    iteVec = (itMap->second).end();
+//    for (itVec = itbVec; itVec != iteVec; ++itVec)
+//    {
+//      (*itVec)->computeGlobalSourceIndex(elementPosition,
+//                                         gridDestinationDimensionSize_,
+//                                         globalIndexGridDestSendToServer,
+//                                         globaIndexMapFromDestToSource_);
+//    }
+//  }
+}
+
+/*!
+  A transformation from a grid source to grid destination often passes several intermediate grids, which play a role of
+temporary grid source and/or grid destination. This function makes sure that global index of original grid source are mapped correctly to
+the final grid destination
+*/
+void CGridTransformation::computeTransformationFromOriginalGridSource(const std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource)
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  CTransformationMapping transformationMap(gridDestination_, gridSource_);
+
+    // Then compute transformation mapping among clients
+  transformationMap.computeTransformationMapping(globaIndexMapFromDestToSource);
+
+  const std::map<int,std::vector<std::vector<size_t> > >& globalIndexToReceive = transformationMap.getGlobalIndexReceivedOnGridDestMapping();
+  const std::map<int,std::vector<size_t> >& globalIndexToSend = transformationMap.getGlobalIndexSendToGridDestMapping();
+
+ // Sending global index of original grid source
+  std::map<int,std::vector<size_t> >::const_iterator itbSend = globalIndexToSend.begin(), itSend,
+                                                     iteSend = globalIndexToSend.end();
+  CArray<size_t,1>::const_iterator itbArr = globalIndexOfCurrentGridSource_->begin(), itArr,
+                                   iteArr = globalIndexOfCurrentGridSource_->end();
+ int sendBuffSize = 0;
+ for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize += (itSend->second).size();
+
+ unsigned long* sendBuff, *currentSendBuff;
+ if (0 != sendBuffSize) sendBuff = new unsigned long [sendBuffSize];
+ int currentBuffPosition = 0;
+ for (itSend = itbSend; itSend != iteSend; ++itSend)
+ {
+   int destRank = itSend->first;
+   const std::vector<size_t>& globalIndexOfCurrentGridSourceToSend = itSend->second;
+   int countSize = globalIndexOfCurrentGridSourceToSend.size();
+   for (int idx = 0; idx < (countSize); ++idx)
+   {
+     itArr = std::find(itbArr, iteArr, globalIndexOfCurrentGridSourceToSend[idx]);
+     if (iteArr != itArr)
+     {
+       int index = std::distance(itbArr, itArr);
+       sendBuff[idx+currentBuffPosition] = (*globalIndexOfOriginalGridSource_)(index);
+     }
+   }
+   currentSendBuff = sendBuff + currentBuffPosition;
+   MPI_Send(currentSendBuff, countSize, MPI_UNSIGNED_LONG, destRank, 14, client->intraComm);
+   currentBuffPosition += countSize;
+ }
+
+ // Receiving global index of grid source sending from current grid source
+ std::map<int,std::vector<std::vector<size_t> > >::const_iterator itbRecv = globalIndexToReceive.begin(), itRecv,
+                                                                  iteRecv = globalIndexToReceive.end();
+ int recvBuffSize = 0;
+ for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize += (itRecv->second).size();
+
+ unsigned long* recvBuff, *currentRecvBuff;
+ if (0 != recvBuffSize) recvBuff = new unsigned long [recvBuffSize];
+ int currentRecvBuffPosition = 0;
+ for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
+ {
+   MPI_Status status;
+   int srcRank = itRecv->first;
+   int countSize = (itRecv->second).size();
+   currentRecvBuff = recvBuff + currentRecvBuffPosition;
+   MPI_Recv(currentRecvBuff, countSize, MPI_UNSIGNED_LONG, srcRank, 14, client->intraComm, &status);
+   currentRecvBuffPosition += countSize;
+ }
+
+ int nbCurrentGridSource = 0;
+ for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
+ {
+   int ssize = (itRecv->second).size();
+   for (int idx = 0; idx < ssize; ++idx)
+   {
+     nbCurrentGridSource += (itRecv->second)[idx].size();
+   }
+ }
+
+ globalIndexOfCurrentGridSource_->resize(nbCurrentGridSource);
+ globalIndexOfOriginalGridSource_->resize(nbCurrentGridSource);
+ int k = 0;
+ currentRecvBuff = recvBuff;
+ for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
+ {
+   int countSize = (itRecv->second).size();
+   for (int idx = 0; idx < countSize; ++idx, ++currentRecvBuff)
+   {
+     int ssize = (itRecv->second)[idx].size();
+     for (int i = 0; i < ssize; ++i)
+     {
+       (*globalIndexOfCurrentGridSource_)(k) = (itRecv->second)[idx][i];
+       (*globalIndexOfOriginalGridSource_)(k) = *currentRecvBuff;
+       ++k;
+     }
+   }
+ }
+
+ if (0 != sendBuffSize) delete [] sendBuff;
+ if (0 != recvBuffSize) delete [] recvBuff;
 }
 
@@ -143 +381 @@
 of two grids. Then local index mapping between data on each grid will be found out thanks to these global indexes
 */
-void CGridTransformation::computeTransformationMapping()
-{
-  CTransformationMapping transformationMap(gridDestination_, gridSource_);
-
-  // First of all, need to compute global index mapping representing transformation algorithms
-  computeTransformation();
+void CGridTransformation::computeFinalTransformationMapping()
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  CTransformationMapping transformationMap(gridDestination_, originalGridSource_);
+
+  std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource;
+
+  int nb = globalIndexOfCurrentGridSource_->numElements();
+  for (int idx = 0; idx < nb; ++idx)
+  {
+    globaIndexMapFromDestToSource[(*globalIndexOfCurrentGridSource_)(idx)].insert((*globalIndexOfOriginalGridSource_)(idx));
+  }
 
   // Then compute transformation mapping among clients
-  transformationMap.computeTransformationMapping(globaIndexMapFromDestToSource_);
+  transformationMap.computeTransformationMapping(globaIndexMapFromDestToSource);
 
   const std::map<int,std::vector<std::vector<size_t> > >& globalIndexToReceive = transformationMap.getGlobalIndexReceivedOnGridDestMapping();
   const std::map<int,std::vector<size_t> >& globalIndexToSend = transformationMap.getGlobalIndexSendToGridDestMapping();
 
-  CArray<int, 1> localIndexOnClientDest = gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientDest = gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
-
-  CArray<int, 1> localIndexOnClientSrc = gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientSrc = gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
-
+  CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
+  CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
+
+  CArray<int, 1> localIndexOnClientDest = distributionClientDest.getLocalDataIndexOnClient(); //gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
+  CArray<size_t,1> globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); //gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
+
+ std::cout << "dest: local index " << localIndexOnClientDest << std::endl;
+ std::cout << "dest: global index " << globalIndexOnClientDest << std::endl;
+  CArray<int, 1> localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); //gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
+  CArray<size_t,1> globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+ std::cout << "src: local index " << localIndexOnClientSrc << std::endl;
+ std::cout << "src: global index " << globalIndexOnClientSrc << std::endl;
   std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
   CArray<size_t, 1>::iterator itbArr, itArr, iteArr;

XIOS/trunk/src/filter/grid_transformation.hpp

@@ -6 +6 @@
 #include "grid.hpp"
 #include "generic_algorithm_transformation.hpp"
+#include "transformation_enum.hpp"
 
 namespace xios {
@@ -18 +19 @@
   ~CGridTransformation();
 
-  void computeTransformationMapping();
+  void computeAll();
+
+
   std::map<int, CArray<int,1>* > getLocalIndexToSendFromGridSource();
   std::map<int, std::vector<CArray<int,1>* > > getLocalIndexToReceiveOnGridDest();
@@ -27 +30 @@
   void initializeAxisAlgorithms();
   void initializeDomainAlgorithms();
+  void initializeMappingOfOriginalGridSource();
+
+  void selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
+  void selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
+  void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
+  void setUpGrid(int elementPositionInGrid, ETranformationType transType);
+  void computeFinalTransformationMapping();
+  void computeTransformationFromOriginalGridSource(const std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
 
 private:
   CGrid* gridSource_;
   CGrid* gridDestination_;
+  CGrid* originalGridSource_;
 
   std::vector<int> gridSourceDimensionSize_;
   std::vector<int> gridDestinationDimensionSize_;
 
+private:
+  typedef std::list<std::pair<int,std::pair<ETranformationType,int> > > ListAlgoType;
+
   // Mapping between position of an element in grid and its transformation (if any)
-  std::map<int, std::vector<CGenericAlgorithmTransformation*> > algoTransformation_;
+  std::list<CGenericAlgorithmTransformation*> algoTransformation_;
+  ListAlgoType listAlgos_;
   std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource_;
 
   std::map<int, CArray<int,1>* > localIndexToSendFromGridSource_;
   std::map<int, std::vector<CArray<int,1>* > > localIndexToReceiveOnGridDest_;
+
+  std::map<int, int> elementPosition2AxisPositionInGrid_, elementPosition2DomainPositionInGrid_;
+
+  CArray<size_t,1>* globalIndexOfCurrentGridSource_;
+  CArray<size_t,1>* globalIndexOfOriginalGridSource_;
 };
 

XIOS/trunk/src/filter/transformation_mapping.cpp

@@ -3 +3 @@
 #include "context.hpp"
 #include "context_client.hpp"
+#include "distribution_client.hpp"
 
 namespace xios {
@@ -13 +14 @@
   int clientRank = client->clientRank;
 
-  const CArray<size_t,1>& globalIndexGridSrc = gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  CDistributionClient distributionClientDest(client->clientRank, gridSource_);
+
+  const CArray<size_t,1>& globalIndexGridSrc = distributionClientDest.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
   boost::unordered_map<size_t,int> globalIndexOfServer;
   int globalIndexSize = globalIndexGridSrc.numElements();
@@ -35 +38 @@
 this function tries to find out which clients a client needs to send and receive these global indexes to accomplish the transformations.
   The grid destination is the grid whose global indexes demande global indexes from the grid source
-  Grid destination and grid source are also distributed among clients but in a different manner.
+  Grid destination and grid source are also distributed among clients but in different manners.
   \param [in] globaIndexMapFromDestToSource mapping representing the transformations
 */

XIOS/trunk/src/node/axis.cpp

@@ -62 +62 @@
 
    //----------------------------------------------------------------
+
+   CAxis* CAxis::createAxis()
+   {
+     CAxis* axis = CAxisGroup::get("axis_definition")->createChild();
+     return axis;
+   }
+
+   void CAxis::duplicateAttributes(CAxis* axis)
+   {
+     axis->setAttributes(this);
+   }
 
    void CAxis::checkAttributes(void)
@@ -374 +385 @@
           CInverseAxis* tmp = (CInverseAxisGroup::get(inverseAxisDefRoot))->createChild();
           tmp->parse(node);
-          transformationMap_[TRANS_INVERSE_AXIS] = tmp;
+          transformationMap_.push_back(std::make_pair(TRANS_INVERSE_AXIS,tmp));
         } else if (node.getElementName() == zoom) {
           CZoomAxis* tmp = (CZoomAxisGroup::get(zoomAxisDefRoot))->createChild();
           tmp->parse(node);
-          transformationMap_[TRANS_ZOOM_AXIS] = tmp;
+          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_AXIS,tmp));
         }
       } while (node.goToNextElement()) ;

XIOS/trunk/src/node/axis.hpp

@@ -61 +61 @@
          CAxis(const CAxis * const axis); // Not implemented yet.
 
+         static CAxis* createAxis();
+
          /// Accesseurs ///
          const std::set<StdString> & getRelFiles(void) const;
+         void duplicateAttributes(CAxis* axis);
 
          /// Test ///

XIOS/trunk/src/node/domain.cpp

@@ -38 +38 @@
 
    ///---------------------------------------------------------------
+
+   CDomain* CDomain::createDomain()
+   {
+     CDomain* domain = CDomainGroup::get("domain_definition")->createChild();
+     return domain;
+   }
+
+   void CDomain::duplicateAttributes(CDomain* domain)
+   {
+     domain->setAttributes(this);
+   }
 
    const std::set<StdString> & CDomain::getRelFiles(void) const

XIOS/trunk/src/node/domain.hpp

@@ -55 +55 @@
          CDomain(const CDomain & domain);       // Not implemented yet.
          CDomain(const CDomain * const domain); // Not implemented yet.
+
+         static CDomain* createDomain();
+         void duplicateAttributes(CDomain* domain);
 
          /// Vérifications ///

XIOS/trunk/src/node/grid.cpp

@@ -450 +450 @@
       std::vector<CDomain*> vecDom(1,domain);
       std::vector<CAxis*> vecAxis;
-
-      CGrid* grid = createGrid(vecDom, vecAxis);
+      CArray<bool,1> axisDomainOrder;
+      CGrid* grid = createGrid(vecDom, vecAxis, axisDomainOrder);
 
       return (grid);
@@ -460 +460 @@
       std::vector<CDomain*> vecDom(1,domain);
       std::vector<CAxis*> vecAxis(1,axis);
-      CGrid* grid = createGrid(vecDom, vecAxis);
+      CArray<bool,1> axisDomainOrder;
+      CGrid* grid = createGrid(vecDom, vecAxis, axisDomainOrder);
 
       return (grid);
    }
 
-   CGrid* CGrid::createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis)
+   CGrid* CGrid::createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis, CArray<bool,1> axisDomainOrder)
    {
       StdString new_id = StdString("__");
@@ -478 +479 @@
 
       //By default, domains are always the first ones of a grid
-      if (grid->axis_domain_order.isEmpty())
+      if (0 == axisDomainOrder.numElements())
       {
         int size = domains.size()+axis.size();
@@ -487 +488 @@
           else grid->axis_domain_order(i) = false;
         }
+      }
+      else
+      {
+        grid->axis_domain_order.resize(axisDomainOrder.numElements());
+        grid->axis_domain_order = axisDomainOrder;
       }
 
@@ -1151 +1157 @@
 
     transformations_ = new CGridTransformation(transformedGrid, this);
-    transformations_->computeTransformationMapping();
+    transformations_->computeAll();
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -132 +132 @@
          static CGrid* createGrid(CDomain* domain);
          static CGrid* createGrid(CDomain* domain, CAxis* axis);
-         static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis);
+         static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis, CArray<bool,1> axisDomainOrder = CArray<bool,1>());
 
       public :

XIOS/trunk/src/node/transformation.hpp

@@ -16 +16 @@
   {
   public:
-    typedef typename boost::unordered_map<ETranformationType, CTransformation<T>*, boost::hash<int> > TransformationMapTypes;
+    typedef typename std::list<std::pair<ETranformationType, CTransformation<T>* > > TransformationMapTypes;
     typedef TransformationMapTypes TransMapTypes;
 

XIOS/trunk/src/node/zoom_axis.cpp

@@ -26 +26 @@
   {
     StdSize axisIBegin, axisNi, axisSize;
-    StdSize zoom_begin,zoom_end, zoom_size;
+    StdSize zoom_begin, zoom_end, zoom_size;
 
     axisIBegin = axisDest->ibegin.getValue();