Changeset 620

Timestamp:

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

Author:

mhnguyen

Message:

Implementing generic transformation algorithm (local commit)

+) Implement 3 important classes:

-gridTransformation to read transformation info from grid and interface with the rest of XIOS
-transformationMapping to be in charge of sending/receiving transformation info among clients
-transformationAlgorithm to represent various algorithms

+) Make some change on field to use the new classes

Test
+) Only test_new_features with inversed axis

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (4 diffs)
• src/client_server_mapping_distributed.hpp (modified) (2 diffs)
• src/filter/axis_algorithm_transformation.cpp (added)
• src/filter/axis_algorithm_transformation.hpp (added)
• src/filter/axis_filter.cpp (deleted)
• src/filter/axis_filter.hpp (deleted)
• src/filter/axis_inverse.cpp (added)
• src/filter/axis_inverse.hpp (added)
• src/filter/axis_transformation.cpp (deleted)
• src/filter/axis_transformation.hpp (deleted)
• src/filter/generic_algorithm_transformation.cpp (added)
• src/filter/generic_algorithm_transformation.hpp (added)
• src/filter/generic_filter.cpp (deleted)
• src/filter/generic_filter.hpp (deleted)
• src/filter/grid_transformation.cpp (added)
• src/filter/grid_transformation.hpp (added)
• src/filter/invert_algorithm.cpp (deleted)
• src/filter/invert_algorithm.hpp (deleted)
• src/filter/transformation_mapping.cpp (added)
• src/filter/transformation_mapping.hpp (added)
• src/filter/zoom_algorithm.cpp (deleted)
• src/filter/zoom_algorithm.hpp (deleted)
• src/node/axis.cpp (modified) (4 diffs)
• src/node/axis.hpp (modified) (2 diffs)
• src/node/field.cpp (modified) (3 diffs)
• src/node/field.hpp (modified) (2 diffs)
• src/node/field_impl.hpp (modified) (2 diffs)
• src/node/grid.cpp (modified) (10 diffs)
• src/node/grid.hpp (modified) (6 diffs, 1 prop)
• src/test/test_new_features.f90 (modified) (6 diffs)

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_Two_Axis" grid_ref="grid_Axis_tranformed" />
+     <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_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" />
@@ -19 +19 @@
    <file_definition type="multiple_file" par_access="collective" output_freq="6h" output_level="10" enabled=".TRUE.">
      <file id="output" name="output">
-        <field field_ref="field_A" />
+<!--        <field field_ref="field_A" />-->
      </file>
      <file id="output_Axis" name="output_Axis" type="one_file">
@@ -41 +41 @@
      <axis id="axis_C" zoom_size="2" zoom_end="2"/>
      <axis id="axis_D" />
-     <axis id="axis_E" axis_ref="axis_B">
+     <axis id="axis_E" axis_ref="axis_D">
         <transformation type="inverse" />
 <!--        <transformation type="zoom" />-->
@@ -65 +65 @@
        </grid>
        <grid id="grid_Axis_tranformed">
-         <axis axis_ref="axis_A" />
+<!--         <axis axis_ref="axis_A" />-->
          <axis axis_ref="axis_E" />
        </grid>

XIOS/trunk/src/client_server_mapping_distributed.hpp

@@ -37 +37 @@
 
     virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClientSendToServer);
-
-//    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClientSendToServer,
-//                                           const CArray<int,1>& localIndexOnClientSendToServer);
 
     std::vector<int> computeConnectedServerRank(const CArray<size_t,1> globalIndexClient);
@@ -85 +82 @@
     void resetReceivingRequestAndCount();
 
-  private:
+  protected:
     //! Mapping of global index to the corresponding server
     boost::unordered_map<size_t,int> globalIndexToServerMapping_;

XIOS/trunk/src/node/axis.cpp

@@ -85 +85 @@
       }
       else this->ni.setValue(size);
-
+      std::cout <<  "value " <<  value <<  std::endl;
       StdSize true_size = value.numElements();
       if (this->ni.getValue() != true_size)
@@ -311 +311 @@
   }
 
-  void CAxis::setTransformations(const std::vector<ETransformationType>& transformations)
+  void CAxis::setTransformations(const std::vector<CTransformation*>& transformations)
   {
     transformations_ = transformations;
+  }
+
+  std::vector<CTransformation*> CAxis::getAllTransformations(void)
+  {
+    if (!hasTransformation())
+      setTransformations(this->getVirtualTransformationGroup()->getAllChildren());
+
+    return transformations_;
   }
 
@@ -333 +341 @@
     if (refer_ptr->hasTransformation())
       for (int idx = 0; idx < refAxis.size(); ++idx)
-        refAxis[idx]->setTransformations(refer_ptr->getTransformations());
+        refAxis[idx]->setTransformations(refer_ptr->getAllTransformations());
   }
 
@@ -347 +355 @@
         if (node.getElementName() == tranformation) {
            this->getVirtualTransformationGroup()->parseChild(node);
-           transformations_.push_back(eInverse);
         }
       } while (node.goToNextElement()) ;
       node.goToParentElement();
     }
-  }
-
-  const std::vector<ETransformationType>& CAxis::getTransformations()
-  {
-    return transformations_;
-  }
-
-   DEFINE_REF_FUNC(Axis,axis)
+    setTransformations(this->getVirtualTransformationGroup()->getAllChildren());
+  }
+
+  DEFINE_REF_FUNC(Axis,axis)
 
    ///---------------------------------------------------------------

XIOS/trunk/src/node/axis.hpp

@@ -95 +95 @@
 
          bool hasTransformation();
-         void setTransformations(const std::vector<ETransformationType>&);
-         const std::vector<ETransformationType>& getTransformations();
          void solveInheritanceTransformation();
+         std::vector<CTransformation*> getAllTransformations();
 
       public:
@@ -109 +108 @@
 
 
-         void checkTransformation();
+
+         void setTransformations(const std::vector<CTransformation*>&);
       private:
          bool isChecked;
          bool areClientAttributesChecked_;
          std::set<StdString> relFiles;
-         std::vector<ETransformationType> transformations_;
+         std::vector<CTransformation*> transformations_;
          bool isDistributed_;
 

XIOS/trunk/src/node/field.cpp

@@ -549 +549 @@
      }
      solveGridDomainAxisRef(doSending2Sever);
+     solveCheckMaskIndex(doSending2Sever);
      if (context->hasClient)
      {
        solveTransformedGrid();
      }
-     solveCheckMaskIndex(doSending2Sever);
    }
 
@@ -804 +804 @@
          gridRefOfFieldRef->transformGrid(relGridRef);
          filterSources_.push_back(fieldRef);
-         transformations_ = relGridRef->getTransformations();
-         switch (gridRefOfFieldRef->getGridElementType()) {
-         case CGrid::GRID_ONLY_AXIS:
-           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef);
-           break;
-         default:
-           break;
-         }
-         setAlgorithms();
+//         transformations_ = relGridRef->getTransformations();
+//         switch (gridRefOfFieldRef->getGridElementType()) {
+//         case CGrid::GRID_ONLY_AXIS:
+////           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef);
+////           break;
+//         default:
+//           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef);
+//           break;
+//         }
+//         setAlgorithms();
        }
      }
@@ -818 +819 @@
 
 
-  void CField::setAlgorithms()
-  {
-    std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(),
-                                               iteTrans = transformations_.end();
-    std::set<ETransformationType> tmp;
-    for (; itTrans != iteTrans; ++itTrans)
-    {
-      if (tmp.end() == tmp.find(*itTrans))
-      {
-        switch (*itTrans) {
-        case eInverse:
-          algorithms_.push_back(new CInvertAlgorithm());
-          break;
-        default:
-          break;
+//  void CField::setAlgorithms()
+//  {
+//    std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(),
+//                                               iteTrans = transformations_.end();
+//    std::set<ETransformationType> tmp;
+//    for (; itTrans != iteTrans; ++itTrans)
+//    {
+//      if (tmp.end() == tmp.find(*itTrans))
+//      {
+//        switch (*itTrans) {
+//        case eInverse:
+//          algorithms_.push_back(new CInvertAlgorithm());
+//          break;
+//        default:
+//          break;
+//        }
+//      }
+//      tmp.insert(*itTrans);
+//    }
+//  }
+
+   const std::vector<CField*>& CField::getFilterSources()
+   {
+     return filterSources_;
+   }
+
+   void CField::applyFilter(const CArray<double, 1>& dataToSend, CArray<double,1>& dataToReceive)
+   {
+     std::vector<CField*>::iterator  itFilterSrc, iteFilterSrc;
+     if (!filterSources_.empty())
+     {
+        itFilterSrc = filterSources_.begin(); iteFilterSrc = filterSources_.end();
+        for (; itFilterSrc != iteFilterSrc; ++itFilterSrc)
+        {
+          if (0 != (*itFilterSrc)->grid->getTransformations())
+          {
+             const std::map<int, CArray<int,1>* >& localIndexToSend = (*itFilterSrc)->grid->getTransformations()->getLocalIndexToSendFromGridSource();
+             const std::map<int, std::vector<CArray<int,1>* > > localIndexToReceive = (*itFilterSrc)->grid->getTransformations()->getLocalIndexToReceiveOnGridDest();
+             sendAndReceiveTransformedData(localIndexToSend, dataToSend,
+                                           localIndexToReceive, dataToReceive);
+          }
+
         }
-      }
-      tmp.insert(*itTrans);
-    }
-  }
-
-   const std::vector<CField*>& CField::getFilterSources()
-   {
-     return filterSources_;
-   }
-
-   void CField::applyFilter()
-   {
-     filter->setInputs(filterSources_);
-     filter->setOutput(this);
-     filter->apply(algorithms_);
-
+
+//        std::cout << "it data " << (*it)->data << std::endl;
+//        std::cout << "it filtered data " << (*it)->filteredData << std::endl;
+     }
+   }
+
+   void CField::sendAndReceiveTransformedData(const std::map<int, CArray<int,1>* >& localIndexToSend,
+                                              const CArray<double, 1>& dataSrc,
+                                              const std::map<int, std::vector<CArray<int,1>* > >& localIndexToReceive,
+                                              CArray<double,1>& dataDest)
+   {
+     CContext* context = CContext::getCurrent();
+     CContextClient* client=context->client;
+
+     // Sending data from field sources to do transformations
+     std::map<int, CArray<int,1>* >::const_iterator itbSend = localIndexToSend.begin(), itSend,
+                                                    iteSend = localIndexToSend.end();
+     int sendBuffSize = 0;
+     for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize = (sendBuffSize < (itSend->second)->numElements())
+                                                                        ? (itSend->second)->numElements(): sendBuffSize;
+     double* sendBuff;
+     if (0 != sendBuffSize) sendBuff = new double [sendBuffSize];
+     for (itSend = itbSend; itSend != iteSend; ++itSend)
+     {
+       int destRank = itSend->first;
+       CArray<int,1>* localIndex_p = itSend->second;
+       int countSize = localIndex_p->numElements();
+       for (int idx = 0; idx < countSize; ++idx)
+       {
+         sendBuff[idx] = dataSrc((*localIndex_p)(idx));
+       }
+       MPI_Send(sendBuff, countSize, MPI_DOUBLE, destRank, 12, client->intraComm);
+     }
+
+     // Receiving data on destination fields
+     std::map<int, std::vector<CArray<int,1>* > >::const_iterator itbRecv = localIndexToReceive.begin(), itRecv,
+                                                                  iteRecv = localIndexToReceive.end();
+     int recvBuffSize = 0;
+     for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize = (recvBuffSize < (itRecv->second).size())
+                                                                        ? (itRecv->second).size() : recvBuffSize;
+     double* recvBuff;
+     if (0 != recvBuffSize) recvBuff = new double [recvBuffSize];
+     for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
+     {
+       MPI_Status status;
+       int srcRank = itRecv->first;
+       int countSize = (itRecv->second).size();
+       MPI_Recv(recvBuff, recvBuffSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &status);
+       for (int idx = 0; idx < countSize; ++idx)
+       {
+         CArray<int,1>* localIndex_p = (itRecv->second)[idx];
+         int numIndex = localIndex_p->numElements();
+         for (int i = 0; i < numIndex; ++i)
+         {
+           dataDest((*localIndex_p)(i)) = recvBuff[idx];
+         }
+       }
+     }
+
+     if (0 != sendBuffSize) delete [] sendBuff;
+     if (0 != recvBuffSize) delete [] recvBuff;
    }
 

XIOS/trunk/src/node/field.hpp

@@ -98 +98 @@
          template <int N> bool updateFilteredData(CArray<double, N>&   data);
          template<int N>
-         void updateDataWithoutOperation(const CArray<double, N>& data);
+         void updateDataWithoutOperation(const CArray<double, N>& _data, CArray<double,1>& updatedData);
          bool updateDataFromExpression(const CArray<double, 1>&   data);
          void setDataFromExpression(const CArray<double, 1>& _data) ;
@@ -181 +181 @@
 
         const std::vector<CField*>& getFilterSources();
-        void applyFilter();
-        void setAlgorithms();
+        void applyFilter(const CArray<double, 1>& dataToSend, CArray<double,1>& dataToReceive);
+        void sendAndReceiveTransformedData(const std::map<int, CArray<int,1>* >& localIndexToSend,
+                                           const CArray<double, 1>& dataSrc,
+                                           const std::map<int, std::vector<CArray<int,1>* > >& localIndexToReceive,
+                                           CArray<double,1>& dataDest);
       public :
          /// Propriétés privées ///

XIOS/trunk/src/node/field_impl.hpp

@@ -33 +33 @@
         if (!fieldFilterSources.empty())
         {
-          itFilterSrc = fieldFilterSources.begin(); iteFilterSrc = fieldFilterSources.end();
-          for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) (*itFilterSrc)->updateDataWithoutOperation(_data);
-          (*it)->applyFilter();
-          std::cout << "it data " << (*it)->data << std::endl;
-          std::cout << "it filtered data " << (*it)->filteredData << std::endl;
+          itFilterSrc  = fieldFilterSources.begin();
+          iteFilterSrc = fieldFilterSources.end();
+          for (; itFilterSrc != iteFilterSrc; ++itFilterSrc)
+          {
+            (*itFilterSrc)->updateDataWithoutOperation(_data, (*itFilterSrc)->data);
+            (*it)->updateDataWithoutOperation(_data, (*it)->filteredData);
+            (*it)->applyFilter((*itFilterSrc)->data, (*it)->filteredData);
+          }
           if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData);
+//          itFilterSrc = fieldFilterSources.begin(); iteFilterSrc = fieldFilterSources.end();
+//          for (; itFilterSrc != iteFilterSrc; ++itFilterSrc) (*itFilterSrc)->updateDataWithoutOperation(_data);
+//          (*it)->applyFilter();
+//          std::cout << "it data " << (*it)->data << std::endl;
+//          std::cout << "it filtered data " << (*it)->filteredData << std::endl;
+//          if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData);
         }
         else
@@ -70 +79 @@
 
    template<int N>
-   void CField::updateDataWithoutOperation(const CArray<double, N>& _data)
+   void CField::updateDataWithoutOperation(const CArray<double, N>& _data, CArray<double,1>& updatedData)
    {
-     if (this->data.numElements() != this->grid->storeIndex_client.numElements())
+     if (updatedData.numElements() != this->grid->storeIndex_client.numElements())
      {
-        this->data.resize(this->grid->storeIndex_client.numElements());
-        this->grid->inputField(_data, this->data);
+        updatedData.resize(this->grid->storeIndex_client.numElements());
+        this->grid->inputField(_data, updatedData);
      }
    }

XIOS/trunk/src/node/grid.cpp

@@ -14 +14 @@
 #include "array_new.hpp"
 #include "client_server_mapping_distributed.hpp"
-#include "invert_algorithm.hpp"
-#include "visitable.hpp"
 
 namespace xios {
@@ -26 +24 @@
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false)
+      , axisPositionInGrid_()
    {
      setVirtualDomainGroup();
@@ -37 +36 @@
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false)
+      , axisPositionInGrid_()
    {
      setVirtualDomainGroup();
@@ -53 +53 @@
     if (0 != serverDistribution_) delete serverDistribution_;
     if (0 != serverDistributionDescription_) delete serverDistributionDescription_;
-    for (std::vector<CGenericAlgorithm*>::iterator it = algorithms_.begin(); it != algorithms_.end(); ++it) delete *it;
+    if (0 != transformations_) delete transformations_;
    }
 
@@ -324 +324 @@
       {
         int idx = 0;
-        std::vector<int> axisPositionMap;
+        axisPositionInGrid_.resize(0);
         for (int i = 0; i < axis_domain_order.numElements(); ++i)
         {
           if (false == axis_domain_order(i))
           {
-            axisPositionMap.push_back(idx);
+            axisPositionInGrid_.push_back(idx);
             ++idx;
           }
@@ -339 +339 @@
         {
           if (sendAtt)
-            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionMap[i]);
+            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionInGrid_[i]);
           else
-            axisListP[i]->checkAttributesOnClient(globalDim_,axisPositionMap[i]);
+            axisListP[i]->checkAttributesOnClient(globalDim_,axisPositionInGrid_[i]);
           ++idx;
         }
@@ -347 +347 @@
       }
    }
+
+   std::vector<int> CGrid::getAxisPositionInGrid() const
+   {
+     return axisPositionInGrid_;
+   }
+
 
    //---------------------------------------------------------------
@@ -759 +765 @@
   {
     return serverDistribution_;
+  }
+
+  const CDistributionClient* CGrid::getDistributionClient() const
+  {
+    return clientDistribution_;
   }
 
@@ -1103 +1114 @@
   }
 
-  CGrid::EElementType CGrid::getGridElementType()
-  {
-    EElementType gridType = GRID_ONLY_AXIS;
-    int numElements = axis_domain_order.numElements();
-    if (1 == numElements)
-    {
-      if (true == axis_domain_order(0)) gridType = GRID_ONLY_DOMAIN;
-    }
-    else gridType = GRID_AXIS_DOMAIN;
-  }
-
-  void CGrid::solveTransformations()
-  {
-    std::vector<CAxis*> axisPtr = getAxis();
-    for (std::vector<CAxis*>::iterator it = axisPtr.begin(); it != axisPtr.end(); ++it)
-    {
-      std::vector<ETransformationType> axisTransformation = (*it)->getTransformations();
-      std::vector<ETransformationType>::iterator itTrans  = axisTransformation.begin(),
-                                                 iteTrans = axisTransformation.end();
-      for (;itTrans != iteTrans; ++ itTrans)
-        transformations_.push_back(*itTrans);
-    }
-  }
-
-  void CGrid::setTransformationAlgorithms()
-  {
-    std::vector<ETransformationType>::iterator itTrans  = transformations_.begin(),
-                                               iteTrans = transformations_.end();
-    std::set<ETransformationType> tmp;
-    for (; itTrans != iteTrans; ++itTrans)
-    {
-      if (tmp.end() == tmp.find(*itTrans))
-      {
-        switch (*itTrans) {
-        case eInverse:
-          algorithms_.push_back(new CInvertAlgorithm());
-          break;
-        default:
-          break;
-        }
-      }
-      tmp.insert(*itTrans);
-    }
-  }
-
-  std::vector<ETransformationType> CGrid::getTransformations()
+  bool CGrid::isTransformed()
+  {
+    return isTransformed_;
+  }
+
+  void CGrid::setTransformed()
+  {
+    isTransformed_ = true;
+  }
+
+  CGridTransformation* CGrid::getTransformations()
   {
     return transformations_;
-  }
-
-  bool CGrid::isTransformed()
-  {
-    return isTransformed_;
-  }
-
-  void CGrid::setTransformed()
-  {
-    isTransformed_ = true;
-  }
-
-  const std::vector<CGenericAlgorithm*>& CGrid::getTransformationAlgo()
-  {
-    return algorithms_;
   }
 
@@ -1189 +1150 @@
     }
 
-    EElementType gridType = getGridElementType();
-    CGenericTransformation* gTransform = 0;
-    switch (gridType) {
-    case GRID_ONLY_AXIS:
-      gTransform = new CAxisTransformation(this->getAxis(), transformedGrid->getAxis());
-      break;
-    case GRID_ONLY_DOMAIN:
-      break;
-    case GRID_AXIS_DOMAIN:
-      break;
-    default:
-      break;
-    }
-
-    transformedGrid->solveTransformations();
-    transformedGrid->setTransformationAlgorithms();
-    gTransform->apply(transformedGrid->algorithms_);
-    if (0 != gTransform) delete gTransform;
+    transformations_ = new CGridTransformation(transformedGrid, this);
+    transformations_->computeTransformationMapping();
+    std::cout << "send index " << *(transformations_->getLocalIndexToSendFromGridSource()[0]) << std::endl;
+    std::cout << "receive index " << *(transformations_->getLocalIndexToReceiveOnGridDest()[0][0]) << std::endl;
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -17 +17 @@
 #include "utils.hpp"
 #include "transformation_enum.hpp"
-#include "visitor.hpp"
+#include "grid_transformation.hpp"
 
 namespace xios {
@@ -32 +32 @@
    class CServerDistributionDescription;
    class CClientServerMapping;
+   class CGridTransformation;
 
    ///--------------------------------------------------------------
@@ -176 +177 @@
          std::vector<int> getGlobalDimension();
          bool isScalarGrid() const;
+         std::vector<int> getAxisPositionInGrid() const;
 
          bool doGridHaveDataToWrite();
@@ -182 +184 @@
 
          const CDistributionServer* getDistributionServer() const;
+         const CDistributionClient* getDistributionClient() const;
+         CGridTransformation* getTransformations();
 
          void transformGrid(CGrid* transformedGrid);
          bool isTransformed();
          void setTransformed();
-         EElementType getGridElementType();
-
-         std::vector<ETransformationType> getTransformations();
-         const std::vector<CGenericAlgorithm*>& getTransformationAlgo();
+//         EElementType getGridElementType();
+//
+//         std::vector<ETransformationType> getTransformations();
+//         const std::vector<CGenericAlgorithm*>& getTransformationAlgo();
 
       public:
@@ -207 +211 @@
          void checkMask(void) ;
 
-         std::vector<CGenericAlgorithm*> algorithms_;
       private:
        template<int N>
@@ -252 +255 @@
 
 
-        std::vector<ETransformationType> transformations_;
+//        std::vector<ETransformationType> transformations_;
         bool isTransformed_;
+        std::vector<int> axisPositionInGrid_;
+        CGridTransformation* transformations_;
    }; // class CGrid
 

XIOS/trunk/src/test/test_new_features.f90

@@ -15 +15 @@
   CHARACTER(len=15) :: calendar_type
   TYPE(xios_context) :: ctx_hdl
-  INTEGER,PARAMETER :: ni_glo=100
-  INTEGER,PARAMETER :: nj_glo=100
-  INTEGER,PARAMETER :: llm=10
+  INTEGER,PARAMETER :: ni_glo=5
+  INTEGER,PARAMETER :: nj_glo=5
+  INTEGER,PARAMETER :: llm=5
   DOUBLE PRECISION  :: lval(llm)=1, tsTemp
   TYPE(xios_field) :: field_hdl
@@ -25 +25 @@
 
   DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
-  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm), lval_ni(ni_glo), lval_nj(nj_glo)
-  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), field_Two_Axis(:,:)
+  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm), lval_ni_glo(ni_glo), lval_nj_glo(nj_glo)
+  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), lval_ni(:), lval_nj(:), field_Two_Axis(:,:)
   INTEGER :: ni,ibegin,iend,nj,jbegin,jend, nAxis, axisBegin, axisEnd
   INTEGER :: i,j,l,ts,n
@@ -47 +47 @@
       lon_glo(i,j)=(i-1)+(j-1)*ni_glo
       lat_glo(i,j)=1000+(i-1)+(j-1)*ni_glo
-      lval_ni(i) = i-1
+      lval_ni_glo(i) = i-1
       DO l=1,llm
         field_A_glo(i,j,l)=(i-1)+(j-1)*ni_glo+10000*l
       ENDDO
     ENDDO
-    lval_nj(j) = j-1
+    lval_nj_glo(j) = j-1
   ENDDO
   ni=ni_glo ; ibegin=0
@@ -80 +80 @@
 
 
-  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm), lvaln(nAxis), field_Two_Axis(ni_glo,1:nj))
+  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm), lvaln(nAxis), lval_ni(ni), lval_nj(nj), field_Two_Axis(ni_glo,1:nj))
   lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
@@ -86 +86 @@
   field_Axis(1:nAxis)  = field_A_glo(1,1,axisBegin+1:axisEnd+1)
   field_All_Axis(1:ni,1:nj,:) = field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
-  field_Two_Axis(:,1:nAxis)  = field_A_glo(:,jbegin+1:jend+1,1)
+  field_Two_Axis(:,1:nj)  = field_A_glo(:,jbegin+1:jend+1,1)
   lvaln(1:nAxis) = lval(axisBegin+1:axisEnd+1)
+  lval_nj(1:nj) = lval_nj_glo(jbegin+1:jend+1);
+  lval_ni(1:ni) = lval_ni_glo(ibegin+1:iend+1);
 
   CALL xios_context_initialize("test",comm)
@@ -103 +105 @@
   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=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
-  CALL xios_set_domain_attr("domain_A",zoom_ibegin=40, zoom_ni=20, zoom_jbegin=40, zoom_nj=10)
+!  CALL xios_set_domain_attr("domain_A",zoom_ibegin=40, zoom_ni=20, zoom_jbegin=40, zoom_nj=10)
   CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)