Changeset 687

Timestamp:

09/15/15 17:30:55 (9 years ago)

Author:

mhnguyen

Message:

Implementing auto-generate rectilinear domain

+) Add a new special transformation to generate (complete) rectilinear domain

Test
+) On Curie
+) test_new_feature passed

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (3 diffs)
• src/config/domain_attribute.conf (modified) (1 diff)
• src/config/generate_rectilinear_domain_attribute.conf (added)
• src/config/node_type.conf (modified) (1 diff)
• src/group_factory_decl.cpp (modified) (1 diff)
• src/group_template_decl.cpp (modified) (1 diff)
• src/node/domain.cpp (modified) (9 diffs)
• src/node/domain.hpp (modified) (3 diffs)
• src/node/field.cpp (modified) (3 diffs)
• src/node/field.hpp (modified) (1 diff)
• src/node/generate_rectilinear_domain.cpp (added)
• src/node/generate_rectilinear_domain.hpp (added)
• src/node/grid.cpp (modified) (3 diffs)
• src/node/grid.hpp (modified) (1 diff)
• src/node/node_enum.hpp (modified) (1 diff)
• src/node/node_type.hpp (modified) (1 diff)
• src/node/transformation_enum.hpp (modified) (1 diff)
• src/object_factory_decl.cpp (modified) (2 diffs)
• src/object_template_decl.cpp (modified) (2 diffs)
• src/test/diff.txt (added)
• src/test/test_new_features.f90 (modified) (2 diffs)
• src/transformation/domain_algorithm_generate_rectilinear.cpp (added)
• src/transformation/domain_algorithm_generate_rectilinear.hpp (added)
• src/transformation/grid_generate.cpp (added)
• src/transformation/grid_generate.hpp (added)
• src/transformation/grid_transformation.cpp (modified) (4 diffs)
• src/transformation/grid_transformation.hpp (modified) (5 diffs)
• src/type/type_util.hpp (modified) (2 diffs)
• src/utils.hpp (modified) (2 diffs)
• src/xml_parser_decl.cpp (modified) (1 diff)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -28 +28 @@
      </file>
      <file id="output_Axis_transformed" name="output_Axis_transformed" type="one_file">
-        <field field_ref="field_Axis_transformed" />
+<!--        <field field_ref="field_Axis_transformed" />-->
      </file>
      <file id="output_Axis_transformed_interpolated" name="output_Axis_transformed_interpolated">
@@ -34 +34 @@
      </file>
      <file id="output_Domain_transformed_interpolated" name="output_Domain_transformed_interpolated">
-<!--        <field field_ref="field_Domain_transformed_Interpolated" />-->
+        <field field_ref="field_Domain_transformed_Interpolated" />
      </file>
      <file id="output_Scalar" name="output_Scalar" type="one_file">
@@ -70 +70 @@
 <!--       <zoom_domain zoom_ibegin="0" zoom_ni="2" zoom_jbegin="0" zoom_nj="2"/>-->
      </domain>
-     <domain id="domain_A_transformed" domain_ref="domain_A">
-       <interpolate_from_file_domain file="" />
+     <domain id="domain_A_transformed" domain_src="domain_A">
+<!--       <interpolate_from_file_domain file="" />-->
+       <generate_rectilinear_domain />
      </domain>
    </domain_definition>

XIOS/trunk/src/config/domain_attribute.conf

@@ -56 +56 @@
 DECLARE_ENUM3(type,rectilinear,curvilinear,unstructured)
 DECLARE_ATTRIBUTE(StdString, domain_ref)
-
+DECLARE_ATTRIBUTE(StdString, domain_src)

XIOS/trunk/src/config/node_type.conf

@@ -51 +51 @@
 #endif //__XIOS_CInterpolateFromFileDomain__
 
+#ifdef __XIOS_CGenerateRectilinearDomain__
+   DECLARE_NODE(GenerateRectilinearDomain, generate_rectilinear_domain)
+#endif //__XIOS_CGenerateRectilinearDomain__
+
+
 #ifdef __XIOS_CContext__
    DECLARE_NODE_PAR(Context, context)

XIOS/trunk/src/group_factory_decl.cpp

@@ -30 +30 @@
   macro(CZoomDomainGroup)
   macro(CInterpolateFromFileDomainGroup)
+  macro(CGenerateRectilinearDomainGroup)
 }

XIOS/trunk/src/group_template_decl.cpp

@@ -19 +19 @@
   macro(ZoomDomain)
   macro(InterpolateFromFileDomain)
+  macro(GenerateRectilinearDomain)
 
 }

XIOS/trunk/src/node/domain.cpp

@@ -20 +20 @@
 #include "zoom_domain.hpp"
 #include "interpolate_from_file_domain.hpp"
+#include "generate_rectilinear_domain.hpp"
 
 #include <algorithm>
@@ -34 +35 @@
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
+      , srcObject_(0)
    { /* Ne rien faire de plus */ }
 
@@ -43 +45 @@
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
+      , srcObject_(0)
    { /* Ne rien faire de plus */ }
 
@@ -158 +161 @@
 
    //----------------------------------------------------------------
+
+   /*!
+     Redistribute RECTILINEAR domain with a number of local domains.
+   All attributes ni,nj,ibegin,jbegin (if defined) will be rewritten
+   The optional attributes lonvalue, latvalue will be added. Because this function only serves (for now)
+   for interpolation from unstructured domain to rectilinear one, range of latvalue is 0-360 and lonvalue is -90 - +90
+    \param [in] nbLocalDomain number of local domain on the domain destination
+   */
+   void CDomain::redistribute(int nbLocalDomain)
+   {
+     if (type_attr::rectilinear == type)
+     {
+        CContext* context = CContext::getCurrent();
+        CContextClient* client = context->client;
+        int rankClient = client->clientRank;
+        int rankOnDomain = rankClient%nbLocalDomain;
+
+        if (ni_glo.isEmpty() || ni_glo <= 0 )
+        {
+           ERROR("CDomain::redistribute(int nbLocalDomain)",
+              << "[ Id = " << this->getId() << " ] "
+              << "The global domain is badly defined,"
+              << " check the \'ni_glo\'  value !")
+        }
+
+        if (nj_glo.isEmpty() || nj_glo <= 0 )
+        {
+           ERROR("CDomain::redistribute(int nbLocalDomain)",
+              << "[ Id = " << this->getId() << " ] "
+              << "The global domain is badly defined,"
+              << " check the \'nj_glo\'  value !")
+        }
+
+        int globalDomainSize = ni_glo * nj_glo;
+        if (globalDomainSize <= nbLocalDomain)
+        {
+          for (int idx = 0; idx < nbLocalDomain; ++idx)
+          {
+            if (rankOnDomain < globalDomainSize)
+            {
+              int iIdx = rankOnDomain % ni_glo;
+              int jIdx = rankOnDomain / ni_glo;
+              ibegin.setValue(iIdx); jbegin.setValue(jIdx);
+              ni.setValue(1); nj.setValue(1);
+            }
+            else
+            {
+              ibegin.setValue(0); jbegin.setValue(0);
+              ni.setValue(0); nj.setValue(0);
+            }
+          }
+        }
+        else
+        {
+          // Compute (approximately) number of segment on x and y axis
+          float yOverXRatio = (nj_glo.getValue())/(ni_glo.getValue());
+          int nbProcOnX, nbProcOnY, range;
+          nbProcOnX = std::ceil(std::sqrt(nbLocalDomain/yOverXRatio));
+          nbProcOnY = std::ceil(((float)nbLocalDomain)/nbProcOnX);
+
+          // Simple distribution: Sweep from top to bottom, left to right
+          // Calculate local begin on x
+          std::vector<int> ibeginVec(nbProcOnX,0), jbeginVec(nbProcOnY,0);
+          std::vector<int> niVec(nbProcOnX), njVec(nbProcOnY);
+          for (int i = 1; i < nbProcOnX; ++i)
+          {
+            range = ni_glo / nbProcOnX;
+            if (i < (ni_glo%nbProcOnX)) ++range;
+            niVec[i-1] = range;
+            ibeginVec[i] = ibeginVec[i-1] + niVec[i-1];
+          }
+          niVec[nbProcOnX-1] = ni_glo - ibeginVec[nbProcOnX-1];
+
+          // Calculate local begin on y
+          for (int j = 1; j < nbProcOnY; ++j)
+          {
+            range = nj_glo / nbProcOnY;
+            if (j < (nj_glo%nbProcOnY)) ++range;
+            njVec[j-1] = range;
+            jbeginVec[j] = jbeginVec[j-1] + njVec[j-1];
+          }
+          njVec[nbProcOnY-1] = nj_glo - jbeginVec[nbProcOnY-1];
+
+          // Now assign value to ni, ibegin, nj, jbegin
+          int iIdx = rankOnDomain % nbProcOnX;
+          int jIdx = rankOnDomain / nbProcOnX;
+
+          if (rankOnDomain != (nbLocalDomain-1))
+          {
+            ibegin.setValue(ibeginVec[iIdx]);
+            jbegin.setValue(jbeginVec[jIdx]);
+            nj.setValue(njVec[jIdx]);
+            ni.setValue(niVec[iIdx]);
+          }
+          else // just merge all the remaining rectangle into the last one
+          {
+            ibegin.setValue(ibeginVec[iIdx]);
+            jbegin.setValue(jbeginVec[jIdx]);
+            nj.setValue(njVec[jIdx]);
+            ni.setValue(ni_glo - ibeginVec[iIdx]);
+          }
+        }
+
+        // Now fill other attributes
+        fillInRectilinearLonLat();
+     }
+   }
+
+   /*!
+     Fill in the values for lonvalue_1d and latvalue_1d of rectilinear domain
+     Range of longitude value from 0 - 360
+     Range of latitude value from -90 - +90
+   */
+   void CDomain::fillInRectilinearLonLat()
+   {
+     if (!lonvalue_2d.isEmpty()) lonvalue_2d.free();
+     if (!latvalue_2d.isEmpty()) latvalue_1d.free();
+     lonvalue_1d.resize(ni);
+     latvalue_1d.resize(nj);
+     double lonStep = double(360/ni_glo.getValue());
+     double latStep = double(180/nj_glo.getValue());
+
+     // Assign lon value
+     for (int i = 0; i < ni; ++i)
+     {
+       lonvalue_1d(i) = static_cast<double>(ibegin + i) * lonStep;
+     }
+
+     for (int j = 0; j < nj; ++j)
+     {
+       latvalue_1d(j) = static_cast<double>(jbegin + j) * latStep - 90;
+     }
+   }
 
    void CDomain::checkDomain(void)
@@ -702 +838 @@
        if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty())
        {
-         if (lonvalue_1d.numElements() != i_index.numElements())
+         if ((type_attr::rectilinear != type) && (lonvalue_1d.numElements() != i_index.numElements()))
            ERROR("CDomain::completeLonLatClient(void)",
                  << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
@@ -728 +864 @@
        if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty())
        {
-         if (latvalue_1d.numElements() != i_index.numElements())
+         if ((type_attr::rectilinear != type) && (latvalue_1d.numElements() != i_index.numElements()))
            ERROR("CDomain::completeLonLatClient(void)",
                  << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
@@ -1580 +1716 @@
   }
 
+  void CDomain::solveSrcInheritance()
+  {
+    if (!domain_src.isEmpty())
+    {
+       if (!CDomain::has(this->domain_src.getValue()))                                   \
+          ERROR("CDomain::solveSrcInheritance()",                                \
+             << "[ src_name = " << this->domain_src.getValue() << "]"                 \
+             << " invalid domain name !");
+
+       srcObject_ = CDomain::get(this->domain_src.getValue());
+    }
+  }
+
+  CDomain* CDomain::getDomainSrc()
+  {
+    return srcObject_;
+  }
+
   /*!
     Parse children nodes of a domain in xml file.
@@ -1595 +1749 @@
       StdString interpFromFileDomainDefRoot("interpolate_from_file_domain_definition");
       StdString interpFromFile("interpolate_from_file_domain");
+      StdString generateRectilinearDefRoot("generate_rectilinear_domain_definition");
+      StdString generateRectilinear("generate_rectilinear_domain");
       do
       {
@@ -1608 +1764 @@
           transformationMap_.push_back(std::make_pair(TRANS_INTERPOLATE_DOMAIN_FROM_FILE,tmp));
         }
+        else if (node.getElementName() == generateRectilinear)
+        {
+          CGenerateRectilinearDomain* tmp = (CGenerateRectilinearDomainGroup::get(generateRectilinearDefRoot))->createChild();
+          tmp->parse(node);
+          transformationMap_.push_back(std::make_pair(TRANS_GENERATE_RECTILINEAR_DOMAIN,tmp));
+        }
       } while (node.goToNextElement()) ;
       node.goToParentElement();

XIOS/trunk/src/node/domain.hpp

@@ -76 +76 @@
          bool hasTransformation();
          void solveInheritanceTransformation();
+         void solveSrcInheritance();
+         CDomain* getDomainSrc();
          TransMapTypes getAllTransformations();
+         void redistribute(int nbLocalDomain);
 
       public:
@@ -164 +167 @@
          void setTransformations(const TransMapTypes&);
          void computeNGlobDomain();
+         void fillInRectilinearLonLat();
 
          void sendIndex();
@@ -187 +191 @@
          std::vector<int> nGlobDomain_;
          bool isUnstructed_;
+         CDomain* srcObject_;
 
          DECLARE_REF_FUNC(Domain,domain)

XIOS/trunk/src/node/field.cpp

@@ -175 +175 @@
       client->sendEvent(event);
     }
-    
+
     CTimer::get("XIOS Send Data").suspend();
   }
@@ -498 +498 @@
         solveGridReference();
      }
+     if (context->hasClient)
+     {
+       solveGenerateGrid();
+     }
+
      solveGridDomainAxisRef(doSending2Sever);
+
      if (context->hasClient)
      {
        solveTransformedGrid();
      }
+
      solveCheckMaskIndex(doSending2Sever);
    }
@@ -775 +782 @@
    }
 
+   void CField::solveGenerateGrid()
+   {
+     if (!grid_ref.isEmpty() && hasDirectFieldReference() && !getDirectFieldReference()->grid_ref.isEmpty()
+         && grid_ref.getValue() != getDirectFieldReference()->grid_ref.getValue() && !grid->isTransformed())
+       grid->completeGrid(getDirectFieldReference()->grid);
+   }
+
    ///-------------------------------------------------------------------
 

XIOS/trunk/src/node/field.hpp

@@ -110 +110 @@
          void solveGridDomainAxisRef(bool checkAtt);
          void solveTransformedGrid();
+         void solveGenerateGrid();
 
          void buildFilterGraph(CGarbageCollector& gc, bool enableOutput);

XIOS/trunk/src/node/grid.cpp

@@ -17 +17 @@
 #include "distribution_client.hpp"
 #include "grid_transformation.hpp"
+#include "grid_generate.hpp"
 
 namespace xios {
@@ -1168 +1169 @@
         pDom->solveRefInheritance(apply);
         pDom->solveBaseReference();
+        pDom->solveSrcInheritance();
         pDom->solveInheritanceTransformation();
         if ((!pDom->domain_ref.isEmpty()) && (pDom->name.isEmpty()))
@@ -1203 +1205 @@
   {
     return transformations_;
+  }
+
+  /*!
+     Complete all the necessary (and lacking) attributes of a grid
+     This function is similar to gridTransformation but works only (till now) on generate_rectilinear_domain transformation
+  */
+  void CGrid::completeGrid(CGrid* transformGridSrc)
+  {
+    if (axis_domain_order.numElements() != transformGridSrc->axis_domain_order.numElements())
+    {
+      ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
+           << "Two grids have different dimension size"
+           << "Dimension of grid destination " << this->getId() << " is " << axis_domain_order.numElements() << std::endl
+           << "Dimension of grid source " << transformGridSrc->getId() << " is " << transformGridSrc->axis_domain_order.numElements());
+    }
+    else
+    {
+      int ssize = axis_domain_order.numElements();
+      for (int i = 0; i < ssize; ++i)
+        if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i))
+          ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
+                << "Grids " << this->getId() << " and " << transformGridSrc->getId()
+                << " don't have elements in the same order");
+    }
+
+    CGridGenerate gridGenerate(this, transformGridSrc);
+    gridGenerate.completeGrid();
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -180 +180 @@
 
          void transformGrid(CGrid* transformGridSrc);
+         void completeGrid(CGrid* transformGridSrc);
+         void doAutoDistribution(CGrid* transformGridSrc);
          bool isTransformed();
          void setTransformed();

XIOS/trunk/src/node/node_enum.hpp

@@ -24 +24 @@
          eInterpolateAxis,
          eZoomDomain,
-         eInterpolateFromFileDomain
+         eInterpolateFromFileDomain,
+         eGenerateRectilinearDomain
 
       } ENodeType;

XIOS/trunk/src/node/node_type.hpp

@@ -15 +15 @@
 #include "zoom_domain.hpp"
 #include "interpolate_from_file_domain.hpp"
+#include "generate_rectilinear_domain.hpp"
 
 #endif // __XIOS_NODE_TYPE__

XIOS/trunk/src/node/transformation_enum.hpp

@@ -11 +11 @@
         TRANS_INTERPOLATE_AXIS,
         TRANS_ZOOM_DOMAIN,
-        TRANS_INTERPOLATE_DOMAIN_FROM_FILE
+        TRANS_INTERPOLATE_DOMAIN_FROM_FILE,
+        TRANS_GENERATE_RECTILINEAR_DOMAIN
       } ETranformationType;
 

XIOS/trunk/src/object_factory_decl.cpp

@@ -29 +29 @@
   macro(CZoomDomain)
   macro(CInterpolateFromFileDomain)
+  macro(CGenerateRectilinearDomain)
 
   macro(CFieldGroup)
@@ -42 +43 @@
   macro(CZoomDomainGroup)
   macro(CInterpolateFromFileDomainGroup)
+  macro(CGenerateRectilinearDomainGroup)
 }

XIOS/trunk/src/object_template_decl.cpp

@@ -18 +18 @@
   template class CObjectTemplate<CZoomDomain>;
   template class CObjectTemplate<CInterpolateFromFileDomain>;
+  template class CObjectTemplate<CGenerateRectilinearDomain>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -31 +32 @@
   template class CObjectTemplate<CZoomDomainGroup>;
   template class CObjectTemplate<CInterpolateFromFileDomainGroup>;
+  template class CObjectTemplate<CGenerateRectilinearDomainGroup>;
 }

XIOS/trunk/src/test/test_new_features.f90

@@ -132 +132 @@
   CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj)
   CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
-  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat)
+  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat, type='curvilinear')
 
   CALL xios_set_domain_attr("domain_A_transformed", ni_glo=niDomGlo, nj_glo=njDomGlo, &
-                                                    ibegin=ibeginDomInterp, ni=niDomInterp, jbegin=jbeginDomInterp, nj=njDomInterp)
-  CALL xios_set_domain_attr("domain_A_transformed", lonvalue_2D=lontransformed, &
-                                                    latvalue_2D=lattransformed)
+                            type='rectilinear')
+!                                                    ibegin=ibeginDomInterp, ni=niDomInterp, jbegin=jbeginDomInterp, nj=njDomInterp)
+!  CALL xios_set_domain_attr("domain_A_transformed", lonvalue_2D=lontransformed, &
+!                                                    latvalue_2D=lattransformed)
 
   CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)
@@ -172 +173 @@
 
   ni=0 ; lonvalue(:)=0
-  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_1D=lonvalue)
+!  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_1D=lonvalue)
 
 !  print *,"ni",ni

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -58 +58 @@
 
   gridSource_ = CGrid::createGrid(domainSrc, axisSrc, gridDestination_->axis_domain_order);
-  gridSourceDimensionSize_ = gridSource_->getGlobalDimension();
-  gridDestinationDimensionSize_ = gridDestination_->getGlobalDimension();
 
   initializeMappingOfOriginalGridSource();
@@ -77 +75 @@
 
   CDistributionClient distribution(client->clientRank, originalGridSource_);
-  const std::vector<size_t>& globalIndexGridDestSendToServer = distribution.getGlobalDataIndexSendToServer();
-
-  weightOfGlobalIndexOfOriginalGridSource_.resize(globalIndexGridDestSendToServer.size());
-  globalIndexOfCurrentGridSource_  = globalIndexGridDestSendToServer;
-  globalIndexOfOriginalGridSource_ = globalIndexGridDestSendToServer;
+  const std::vector<size_t>& globalIndexGridSrcSendToServer = distribution.getGlobalDataIndexSendToServer();
+
+  weightOfGlobalIndexOfOriginalGridSource_.resize(globalIndexGridSrcSendToServer.size());
+  globalIndexOfCurrentGridSource_  = globalIndexGridSrcSendToServer;
+  globalIndexOfOriginalGridSource_ = globalIndexGridSrcSendToServer;
   weightOfGlobalIndexOfOriginalGridSource_ = 1.0;
 }
@@ -346 +344 @@
                                ite = listAlgos_.end(), it;
   CGenericAlgorithmTransformation* algo = 0;
-
+  int nbAgloTransformation = 0; // Only count for executed transformation. Generate domain is a special one, not executed in the list
   for (it = itb; it != ite; ++it)
   {
@@ -358 +356 @@
     algo = algoTransformation_.back();
 
-    // Recalculate the distribution of grid destination
-    CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
-    const std::vector<size_t>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
-
-    // ComputeTransformation of global index of each element
-    std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
-    std::vector<int> gridSrcDimensionSize = gridSource_->getGlobalDimension();
-    int elementPosition = it->first;
-    algo->computeGlobalSourceIndex(elementPosition,
-                                   gridDestinationDimensionSize,
-                                   gridSrcDimensionSize,
-                                   globalIndexGridDestSendToServer,
-                                   globaIndexWeightFromDestToSource);
-
-    // Compute transformation of global indexes among grids
-    computeTransformationFromOriginalGridSource(globaIndexWeightFromDestToSource);
-
-    // Now grid destination becomes grid source in a new transformation
-    setUpGrid(elementPositionInGrid, transType);
-  }
-
-  updateFinalGridDestination();
-  computeFinalTransformationMapping();
+    if (0 != algo) // Only registered transformation can be executed
+    {
+      // Recalculate the distribution of grid destination
+      CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
+      const std::vector<size_t>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
+
+      // ComputeTransformation of global index of each element
+      std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
+      std::vector<int> gridSrcDimensionSize = gridSource_->getGlobalDimension();
+      int elementPosition = it->first;
+      algo->computeGlobalSourceIndex(elementPosition,
+                                     gridDestinationDimensionSize,
+                                     gridSrcDimensionSize,
+                                     globalIndexGridDestSendToServer,
+                                     globaIndexWeightFromDestToSource);
+
+      // Compute transformation of global indexes among grids
+      computeTransformationFromOriginalGridSource(globaIndexWeightFromDestToSource);
+
+      // Now grid destination becomes grid source in a new transformation
+      setUpGrid(elementPositionInGrid, transType);
+      ++nbAgloTransformation;
+    }
+  }
+
+  if (0 != nbAgloTransformation)
+  {
+    updateFinalGridDestination();
+    computeFinalTransformationMapping();
+  }
 }
 

XIOS/trunk/src/transformation/grid_transformation.hpp

@@ -3 +3 @@
    \author Ha NGUYEN
    \since 14 May 2015
-   \date 18 June 2015
+   \date 26 Aug 2015
 
    \brief Interface for all transformations.
@@ -34 +34 @@
 {
 public:
+  typedef std::list<std::pair<int,std::pair<ETranformationType,int> > > ListAlgoType;
+
+public:
   /** Default constructor */
   CGridTransformation(CGrid* destination, CGrid* source);
@@ -44 +47 @@
   CGrid* getGridSource() {return gridSource_; }
   CGrid* getGridDestination() { return gridDestination_; }
+  ListAlgoType getAlgoList() const {return listAlgos_; }
 
-private:
+protected:
   void computeTransformation();
   void initializeAlgorithms();
@@ -60 +64 @@
   void updateFinalGridDestination();
 
-private:
+protected:
   //! Grid source on transformation
   CGrid* gridSource_;
@@ -70 +74 @@
   CGrid* originalGridSource_;
 
-  //! Grid source dimension size
-  std::vector<int> gridSourceDimensionSize_;
-
-  //! Grid destination dimension size
-  std::vector<int> gridDestinationDimensionSize_;
-
-private:
-  typedef std::list<std::pair<int,std::pair<ETranformationType,int> > > ListAlgoType;
+protected:
   //! List of algorithm types and their order
   ListAlgoType listAlgos_;

XIOS/trunk/src/type/type_util.hpp

@@ -30 +30 @@
     class CInterpolateFromFileDomain;
     class CInterpolateFromFileDomainGroup;
+    class CGenerateRectilinearDomain;
+    class CGenerateRectilinearDomainGroup;
 
   template <typename T> inline string getStrType(void);
@@ -76 +78 @@
   macro(CInterpolateFromFileDomain)
   macro(CInterpolateFromFileDomainGroup)
+  macro(CGenerateRectilinearDomain)
+  macro(CGenerateRectilinearDomainGroup)
 #undef macro
 }

XIOS/trunk/src/utils.hpp

@@ -171 +171 @@
       return hash;
     }
+
+    /*!
+      Adatped version of (stupid) boost hash (but working)
+    */
+    static inline size_t boost_hash(const std::vector<T>& vec)
+    {
+      size_t hash = 0;
+      int sizeVec = vec.size();
+      for(int i = 0; i < sizeVec; ++i)
+      {
+        hash ^= i + 0x9e3779b9 + (hash << 6) + (hash >> 2);
+      }
+      return hash;
+    }
   };
 
@@ -180 +194 @@
       Algo al;
       return hash_value(val, al);
+    }
+
+    std::size_t hashVec(const std::vector<T>& vec)
+    {
+      return HashAlgorithm<T>::boost_hash(vec);
     }
 

XIOS/trunk/src/xml_parser_decl.cpp

@@ -24 +24 @@
     macro( ZoomDomain )
     macro( InterpolateFromFileDomain )
+    macro( GenerateRectilinearDomain )
   }
 }