Changeset 621

Timestamp:

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

Author:

mhnguyen

Message:

Implementing generic transformation algorithm (local commit)

+) Change a little bit to make sure everything work in order

Test
+) test_new_features passe with inverse

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (3 diffs)
• src/config/inverse_axis_attribute.conf (added)
• src/config/node_type.conf (modified) (1 diff)
• src/distribution_client.cpp (moved) (moved from XIOS/trunk/src/node/distribution_client.cpp)
• src/distribution_client.hpp (moved) (moved from XIOS/trunk/src/node/distribution_client.hpp)
• src/distribution_server.cpp (moved) (moved from XIOS/trunk/src/node/distribution_server.cpp)
• src/distribution_server.hpp (moved) (moved from XIOS/trunk/src/node/distribution_server.hpp)
• src/filter/axis_algorithm_transformation.cpp (modified) (1 diff)
• src/filter/axis_algorithm_transformation.hpp (modified) (3 diffs)
• src/filter/axis_inverse.cpp (modified) (2 diffs)
• src/filter/axis_inverse.hpp (modified) (2 diffs)
• src/filter/axis_zoom.cpp (added)
• src/filter/axis_zoom.hpp (added)
• src/filter/concrete_algo.hpp (added)
• src/filter/grid_transformation.cpp (modified) (9 diffs)
• src/filter/transformation_mapping.cpp (modified) (1 diff)
• src/group_factory_decl.cpp (modified) (1 diff)
• src/group_template_decl.cpp (modified) (1 diff)
• src/node/axis.cpp (modified) (4 diffs)
• src/node/axis.hpp (modified) (6 diffs)
• src/node/field.cpp (modified) (5 diffs)
• src/node/field.hpp (modified) (1 diff)
• src/node/field_impl.hpp (modified) (2 diffs)
• src/node/grid.cpp (modified) (1 diff)
• src/node/inverse_axis.cpp (added)
• src/node/inverse_axis.hpp (added)
• src/node/node_enum.hpp (modified) (1 diff)
• src/node/node_type.hpp (modified) (1 diff)
• src/node/transformation.cpp (deleted)
• src/node/transformation.hpp (modified) (1 diff)
• src/node/transformation_enum.hpp (modified) (1 diff)
• src/node/zoom_axis.cpp (added)
• src/node/zoom_axis.hpp (added)
• src/object_factory_decl.cpp (modified) (2 diffs)
• src/object_template_decl.cpp (modified) (3 diffs)
• src/test/test_new_features.f90 (modified) (2 diffs)
• src/type/type_util.hpp (modified) (2 diffs)
• src/xios_spl.hpp (modified) (1 diff)
• src/xml_parser_decl.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_Axis" grid_ref="grid_Axis_tranformed" />
+     <field id="field_Axis_transformed"  operation="average" freq_op="3600s" field_ref="field_A" 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" />
@@ -39 +39 @@
      <axis id="axis_A" />
      <axis id="axis_B" />
-     <axis id="axis_C" zoom_size="2" zoom_end="2"/>
+     <axis id="axis_C" />
      <axis id="axis_D" />
-     <axis id="axis_E" axis_ref="axis_D">
-        <transformation type="inverse" />
+     <axis id="axis_E" axis_ref="axis_C">
 <!--        <transformation type="zoom" />-->
+        <inverse_axis />
+<!--        <zoom_axis zoom_begin=1 zoom_size=1 />-->
      </axis>
    </axis_definition>
@@ -65 +66 @@
        </grid>
        <grid id="grid_Axis_tranformed">
+         <domain domain_ref="domain_A" />
 <!--         <axis axis_ref="axis_A" />-->
+<!--         <axis axis_ref="axis_B" />-->
          <axis axis_ref="axis_E" />
        </grid>

XIOS/trunk/src/config/node_type.conf

@@ -31 +31 @@
 #endif //__XIOS_CCalendarWrapper__
 
-#ifdef __XIOS_CTransformation__
-   DECLARE_NODE(Transformation, transformation)
-#endif //__XIOS_CTransformation__
+#ifdef __XIOS_CInverseAxis__
+   DECLARE_NODE(InverseAxis, inverse_axis)
+#endif //__XIOS_CInverseAxis__
+
+#ifdef __XIOS_CZoomAxis__
+   DECLARE_NODE(ZoomAxis, zoom_axis)
+#endif //__XIOS_CZoomAxis__
 
 #ifdef __XIOS_CContext__

XIOS/trunk/src/filter/axis_algorithm_transformation.cpp

@@ -1 +1 @@
 #include "axis_algorithm_transformation.hpp"
+#include "axis_inverse.hpp"
+#include "axis_zoom.hpp"
 
 namespace xios {
 
-CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination)
+CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>& algos)
  : CGenericAlgorithmTransformation()
 {
-  int niDest = axisDestination->ni.getValue();
-  int ibeginDest = axisDestination->ibegin.getValue();
+  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();
+}
 
-  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];
+}
+
+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();
+  }
 }
 

XIOS/trunk/src/filter/axis_algorithm_transformation.hpp

@@ -4 +4 @@
 #include "generic_algorithm_transformation.hpp"
 #include "axis.hpp"
+#include "concrete_algo.hpp"
 
 namespace xios {
@@ -10 +11 @@
 {
 public:
-  CAxisAlgorithmTransformation(CAxis* axisDestination);
-  virtual ~CAxisAlgorithmTransformation() {}
+  CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource, std::vector<ETranformationType>&);
+
+  virtual ~CAxisAlgorithmTransformation();
 
 protected:
@@ -21 +23 @@
                                                         CArray<size_t,1>& globalIndexDestGrid,
                                                         std::vector<CArray<size_t,1> >& globalIndexSrcGrid);
-  virtual void computeIndexSourceMapping() = 0;
-
+  void computeIndexSourceMapping();
 protected:
-  std::vector<int> axisDestGlobalIndex_;
+  std::vector<CConcreteAlgo*> algosOfAnAxis_;
 
 };

XIOS/trunk/src/filter/axis_inverse.cpp

@@ -4 +4 @@
 
 CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)
- : CAxisAlgorithmTransformation(axisDestination)
+ : CConcreteAlgo()
 {
   if (axisDestination->size.getValue() != axisSource->size.getValue())
@@ -14 +14 @@
   }
 
+
   axisDestGlobalSize_ = axisDestination->size.getValue();
+  int niDest = axisDestination->ni.getValue();
+  int ibeginDest = axisDestination->ibegin.getValue();
 
-  this->computeIndexSourceMapping();
+  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
 }
 
-void CAxisInverse::computeIndexSourceMapping()
+void CAxisInverse::computeIndexSourceMapping(const std::map<int, std::vector<int> >& transformationMappingOfPreviousAlgo)
 {
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
-  if (!transMap.empty()) transMap.clear();
-
-  int globalIndexSize = axisDestGlobalIndex_.size();
-  for (int idx = 0; idx < globalIndexSize; ++idx)
-    transMap[axisDestGlobalIndex_[idx]].push_back(axisDestGlobalSize_-axisDestGlobalIndex_[idx]-1);
+  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);
+    }
+  }
 }
 
-
 }

XIOS/trunk/src/filter/axis_inverse.hpp

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

XIOS/trunk/src/filter/grid_transformation.cpp

@@ -2 +2 @@
 #include "axis_inverse.hpp"
 #include "transformation_mapping.hpp"
+#include "transformation_enum.hpp"
+#include "axis_algorithm_transformation.hpp"
 
 namespace xios {
@@ -86 +88 @@
       if (axisListDestP[i]->hasTransformation())
       {
-        CGenericAlgorithmTransformation* algo = new CAxisInverse(axisListDestP[i], axisListSrcP[i]);
+        CGenericAlgorithmTransformation* algo = 0;
+        CAxis::TransMapTypes trans = axisListDestP[i]->getAllTransformations();
+        CAxis::TransMapTypes::const_iterator itb = trans.begin(), it,
+                                             ite = trans.end();
+        std::vector<ETranformationType> algoAxis;
+        for (it = itb; it != ite; ++it)
+        {
+          algoAxis.push_back(it->first);
+        }
+        algo = new CAxisAlgorithmTransformation(axisListDestP[i], axisListSrcP[i], algoAxis);
         algoTransformation_[axisPositionInGrid[i]].push_back(algo);
       }
@@ -98 +109 @@
 }
 
+/*!
+  Compute index mapping representing transformation between two grids
+  Each domain and each axis can contain some information of transformation, these information are then converted into
+form of global index mapping reprensenting transformation between two grids.
+*/
 void CGridTransformation::computeTransformation()
 {
@@ -122 +138 @@
 }
 
+/*!
+  Compute transformation mapping between grid source and grid destination
+  The transformation between grid source and grid destination is represented in form of mapping between global index
+of two grids. Then local index mapping between data on each grid will be found out thanks to these global indexes
+*/
 void CGridTransformation::computeTransformationMapping()
 {
@@ -141 +162 @@
   CArray<size_t,1> globalIndexOnClientSrc = gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
 
-
   std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
   CArray<size_t, 1>::iterator itbArr, itArr, iteArr;
 
   std::map<int,std::vector<std::vector<size_t> > >::const_iterator itbMapRecv, itMapRecv, iteMapRecv;
+
   // Find out local index on grid destination (received)
   itbMapRecv = globalIndexToReceive.begin();
@@ -166 +187 @@
         {
           int localIdx = std::distance(itbArr, itArr);
-          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx);
+//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
+          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
         }
       }
     }
-
   }
 
@@ -183 +204 @@
     CArray<int,1>* ptr = new CArray<int,1>((itMap->second).size());
     localIndexToSendFromGridSource_[itMap->first] = ptr;
+    int destRank = itMap->first;
     int vecSize = (itMap->second).size();
     for (int idx = 0; idx < vecSize; ++idx)
@@ -190 +212 @@
       {
         int localIdx = std::distance(itbArr, itArr);
-        (*localIndexToSendFromGridSource_[itMap->first])(idx) = localIndexOnClientSrc(localIdx);
-      }
-    }
-  }
-}
-
+//        (*localIndexToSendFromGridSource_[destRank])(idx) = localIndexOnClientSrc(localIdx);
+        (*localIndexToSendFromGridSource_[destRank])(idx) = (localIdx);
+      }
+    }
+  }
+}
+
+/*!
+  Local index of data which need sending from the grid source
+  \return local index of data
+*/
 std::map<int, CArray<int,1>* > CGridTransformation::getLocalIndexToSendFromGridSource()
 {
@@ -201 +228 @@
 }
 
+/*!
+  Local index of data which will be received on the grid destination
+  \return local index of data
+*/
 std::map<int, std::vector<CArray<int,1>* > > CGridTransformation::getLocalIndexToReceiveOnGridDest()
 {

XIOS/trunk/src/filter/transformation_mapping.cpp

@@ -33 +33 @@
 /*!
   Suppose that we have transformations between two grids, which are represented in form of mapping between global indexes of these two grids,
-this function tries to find out which clients a client need to send and receive these global indexes to accomplish the transformations.
+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.

XIOS/trunk/src/group_factory_decl.cpp

@@ -25 +25 @@
   macro(CContextGroup)
   macro(CVariableGroup)
-  macro(CTransformationGroup)
+  macro(CInverseAxisGroup)
+  macro(CZoomAxisGroup)
 }

XIOS/trunk/src/group_template_decl.cpp

@@ -14 +14 @@
   macro(Axis)
   macro(Variable)
-  macro(Transformation)
+  macro(InverseAxis)
+  macro(ZoomAxis)
 
 

XIOS/trunk/src/node/axis.cpp

@@ -18 +18 @@
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
       , isDistributed_(false)
-   { /* Ne rien faire de plus */ }
+      , transformationMap_()
+   {
+   }
 
    CAxis::CAxis(const StdString & id)
@@ -24 +26 @@
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
       , isDistributed_(false)
-   { /* Ne rien faire de plus */ }
+      , transformationMap_()
+   {
+   }
 
    CAxis::~CAxis(void)
@@ -308 +312 @@
   bool CAxis::hasTransformation()
   {
-    return (!transformations_.empty());
-  }
-
-  void CAxis::setTransformations(const std::vector<CTransformation*>& transformations)
-  {
-    transformations_ = transformations;
-  }
-
-  std::vector<CTransformation*> CAxis::getAllTransformations(void)
-  {
-    if (!hasTransformation())
-      setTransformations(this->getVirtualTransformationGroup()->getAllChildren());
-
-    return transformations_;
+    return (!transformationMap_.empty());
+  }
+
+  void CAxis::setTransformations(const TransMapTypes& axisTrans)
+  {
+    transformationMap_ = axisTrans;
+  }
+
+  CAxis::TransMapTypes CAxis::getAllTransformations(void)
+  {
+    return transformationMap_;
+  }
+
+  /*!
+    Check the validity of all transformations applied on axis
+  This functions is called AFTER all inherited attributes are solved
+  */
+  void CAxis::checkTransformations()
+  {
+    TransMapTypes::const_iterator itb = transformationMap_.begin(), it,
+                                  ite = transformationMap_.end();
+    for (it = itb; it != ite; ++it)
+    {
+      (it->second)->checkValid(this);
+    }
   }
 
@@ -350 +365 @@
     if (node.goToChildElement())
     {
-      StdString tranformation("transformation");
+      StdString inverseAxisDefRoot("inverse_axis_definition");
+      StdString inverse("inverse_axis");
+      StdString zoomAxisDefRoot("zoom_axis_definition");
+      StdString zoom("zoom_axis");
       do
       {
-        if (node.getElementName() == tranformation) {
-           this->getVirtualTransformationGroup()->parseChild(node);
+        if (node.getElementName() == inverse) {
+          CInverseAxis* tmp = (CInverseAxisGroup::get(inverseAxisDefRoot))->createChild();
+          tmp->parse(node);
+          transformationMap_[TRANS_INVERSE_AXIS] = tmp;
+        } else if (node.getElementName() == zoom) {
+          CZoomAxis* tmp = (CZoomAxisGroup::get(zoomAxisDefRoot))->createChild();
+          tmp->parse(node);
+          transformationMap_[TRANS_ZOOM_AXIS] = tmp;
         }
       } while (node.goToNextElement()) ;
       node.goToParentElement();
     }
-    setTransformations(this->getVirtualTransformationGroup()->getAllChildren());
   }
 

XIOS/trunk/src/node/axis.hpp

@@ -16 +16 @@
 #include "transformation.hpp"
 #include "transformation_enum.hpp"
+#include "inverse_axis.hpp"
+#include "zoom_axis.hpp"
 
 namespace xios {
@@ -23 +25 @@
    class CAxisAttributes;
    class CAxis;
-   class CTransformationGroup;
-   class CVirtualTransformationGroup;
 
-   DECLARE_VIRTUAL_NODE(TransformationGroup);
    ///--------------------------------------------------------------
 
@@ -39 +38 @@
       : public CObjectTemplate<CAxis>
       , public CAxisAttributes
-      , public CVirtualTransformationGroup
    {
          enum EEventId
@@ -54 +52 @@
          typedef CAxisAttributes RelAttributes;
          typedef CAxisGroup      RelGroup;
+         typedef CTransformation<CAxis>::TransformationMapTypes TransMapTypes;
 
+      public:
          /// Constructeurs ///
          CAxis(void);
@@ -96 +96 @@
          bool hasTransformation();
          void solveInheritanceTransformation();
-         std::vector<CTransformation*> getAllTransformations();
+         TransMapTypes getAllTransformations();
 
       public:
@@ -106 +106 @@
          void checkMask();
          void checkZoom();
+         void checkTransformations();
+         void computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                 CServerDistributionDescription::ServerDistributionType disType);
 
 
-
-         void setTransformations(const std::vector<CTransformation*>&);
+         void setTransformations(const TransMapTypes&);
       private:
          bool isChecked;
          bool areClientAttributesChecked_;
          std::set<StdString> relFiles;
-         std::vector<CTransformation*> transformations_;
+         TransMapTypes transformationMap_;
          bool isDistributed_;
 

XIOS/trunk/src/node/field.cpp

@@ -31 +31 @@
       , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0)
       , isReadDataRequestPending(false)
+      , filterSources_(), algorithms_()
       { setVirtualVariableGroup(); }
 
@@ -44 +45 @@
       , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0)
       , isReadDataRequestPending(false)
+      , filterSources_(), algorithms_()
    { setVirtualVariableGroup(); }
 
@@ -804 +806 @@
          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:
-//           filter = new CAxisFilter(gridRefOfFieldRef, relGridRef);
-//           break;
-//         }
-//         setAlgorithms();
        }
      }
    }
-
-
-//  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()
@@ -857 +827 @@
              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);
@@ -862 +833 @@
 
         }
-
-//        std::cout << "it data " << (*it)->data << std::endl;
-//        std::cout << "it filtered data " << (*it)->filteredData << std::endl;
      }
    }

XIOS/trunk/src/node/field.hpp

@@ -232 +232 @@
          std::vector<CField*> filterSources_;
          std::vector<CGenericAlgorithm*> algorithms_;
-         std::vector<ETransformationType> transformations_;
          DECLARE_REF_FUNC(Field,field)
 

XIOS/trunk/src/node/field_impl.hpp

@@ -38 +38 @@
           {
             (*itFilterSrc)->updateDataWithoutOperation(_data, (*itFilterSrc)->data);
-            (*it)->updateDataWithoutOperation(_data, (*it)->filteredData);
+            if ((*it)->filteredData.numElements() != (*it)->grid->storeIndex_client.numElements())
+            {
+               (*it)->filteredData.resize((*it)->grid->storeIndex_client.numElements());
+            }
             (*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
@@ -54 +51 @@
           if (hasOutputFile || hasFieldOut) updateData(_data);
         }
-
       }
 

XIOS/trunk/src/node/grid.cpp

@@ -1152 +1152 @@
     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/node_enum.hpp

@@ -19 +19 @@
          eContext,gContext,
          eCalendarWrapper,
-         eTransformation
-
+         eTransformation,
+         eInverseAxis,
+         eZoomAxis
 //#include "node_type.conf"
 

XIOS/trunk/src/node/node_type.hpp

@@ -10 +10 @@
 #include "context.hpp"
 #include "transformation.hpp"
+#include "inverse_axis.hpp"
+#include "zoom_axis.hpp"
 
 #endif // __XIOS_NODE_TYPE__

XIOS/trunk/src/node/transformation.hpp

@@ -2 +2 @@
 #define __XMLIO_CTransformation__
 
-/// xios headers ///
 #include "xmlioserver_spl.hpp"
-#include "attribute_enum.hpp"
-#include "attribute_enum_impl.hpp"
-#include "attribute_array.hpp"
-#include "declare_attribute.hpp"
-#include "object_template.hpp"
-#include "group_factory.hpp"
-#include "declare_group.hpp"
+#include "transformation_enum.hpp"
 
 namespace xios {
-
-  /// ////////////////////// Déclarations ////////////////////// ///
-  class CTransformationGroup;
-  class CTransformationAttributes;
-  class CTransformation;
-  ///--------------------------------------------------------------
-
-  // Declare/Define CFileAttribute
-  BEGIN_DECLARE_ATTRIBUTE_MAP(CTransformation)
-#include "transformation_attribute.conf"
-  END_DECLARE_ATTRIBUTE_MAP(CTransformation)
 
   ///--------------------------------------------------------------
   /*!
     \class CTransformation
-    This class describes transformation in xml file.
+    This class describes inverse_axis in xml file.
   */
+  template<typename T>
   class CTransformation
-    : public CObjectTemplate<CTransformation>
-    , public CTransformationAttributes
   {
-    public :
-      enum TransformationId
-      {
-        TRANS_ID_ZOOM, TRANS_ID_INVERSE
-      };
-      typedef CObjectTemplate<CTransformation> SuperClass;
-      typedef CTransformationAttributes SuperClassAttribute;
+  public:
+    typedef typename boost::unordered_map<ETranformationType, CTransformation<T>*, boost::hash<int> > TransformationMapTypes;
+    typedef TransformationMapTypes TransMapTypes;
 
     public :
       /// Constructeurs ///
-      CTransformation(void);
-      explicit CTransformation(const StdString& id);
+      CTransformation(void) {}
+      virtual void checkValid(T* dest) = 0;
 
       /// Destructeur ///
-      virtual ~CTransformation(void);
-
-      /// Accesseurs statiques ///
-      static StdString GetName(void);
-      static StdString GetDefName(void);
-      static ENodeType GetType(void);
-    private:
-      static std::vector<StdString> TransformationTypes;
-      static std::vector<TransformationId> TransformationTypeIds;
-
-    public :
-      void checkAttributes();
-
-    private:
-      void checkAttributesType(TransformationId& transType);
-      void checkAttributesZoomType();
-      void checkAttributesInverseType();
-
-    private:
+      virtual ~CTransformation(void) {}
   }; // class CTransformation
 
-  DECLARE_GROUP(CTransformation);
 } // namespace xios
 

XIOS/trunk/src/node/transformation_enum.hpp

@@ -8 +8 @@
 {
       /// ////////////////////// Définitions ////////////////////// ///
-      typedef enum transformationType
+      typedef enum transformation_type
       {
-         UnknownTransformation = 0,
-         eInverse,
-         eZoom
-
-//#include "node_type.conf"
-
-      } ETransformationType;
+        TRANS_ZOOM_AXIS,
+        TRANS_INVERSE_AXIS
+      } ETranformationType;
 
 } // namespace xios

XIOS/trunk/src/object_factory_decl.cpp

@@ -24 +24 @@
   macro(CCalendarWrapper)
   macro(CVariable)
-  macro(CTransformation)
+  macro(CInverseAxis)
+  macro(CZoomAxis)
 
   macro(CFieldGroup)
@@ -33 +34 @@
   macro(CContextGroup)
   macro(CVariableGroup)
-  macro(CTransformationGroup)
+  macro(CInverseAxisGroup)
+  macro(CZoomAxisGroup)
 }

XIOS/trunk/src/object_template_decl.cpp

@@ -9 +9 @@
 #include "variable.hpp"
 #include "transformation.hpp"
-
+#include "inverse_axis.hpp"
+#include "zoom_axis.hpp"
 
 namespace xios
@@ -21 +22 @@
   template class CObjectTemplate<CAxis>;
   template class CObjectTemplate<CVariable>;
-  template class CObjectTemplate<CTransformation>;
+  template class CObjectTemplate<CInverseAxis>;
+  template class CObjectTemplate<CZoomAxis>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -30 +32 @@
   template class CObjectTemplate<CAxisGroup>;
   template class CObjectTemplate<CVariableGroup>;
-  template class CObjectTemplate<CTransformationGroup>;
+  template class CObjectTemplate<CInverseAxisGroup>;
+  template class CObjectTemplate<CZoomAxisGroup>;
 }

XIOS/trunk/src/test/test_new_features.f90

@@ -17 +17 @@
   INTEGER,PARAMETER :: ni_glo=5
   INTEGER,PARAMETER :: nj_glo=5
-  INTEGER,PARAMETER :: llm=5
+  INTEGER,PARAMETER :: llm=2
   DOUBLE PRECISION  :: lval(llm)=1, tsTemp
   TYPE(xios_field) :: field_hdl
@@ -155 +155 @@
   DO ts=1,24*10
     CALL xios_update_calendar(ts)
-!    CALL xios_send_field("field_A",field_A)
+    CALL xios_send_field("field_A",field_A)
     CALL xios_send_field("field_Axis",field_Axis)
 
     CALL xios_send_field("field_Two_Axis",field_Two_Axis)
-!    CALL xios_send_field("field_All_Axis",field_All_Axis)
+    CALL xios_send_field("field_All_Axis",field_All_Axis)
 !    tsTemp = ts
 !    CALL xios_send_scalar("field_Scalar", tsTemp)

XIOS/trunk/src/type/type_util.hpp

@@ -20 +20 @@
     class CVariable;
     class CVariableGroup;
-    class CTransformation;
-    class CTransformationGroup;
+    class CInverseAxis;
+    class CInverseAxisGroup;
+    class CZoomAxis;
+    class CZoomAxisGroup;
 
   template <typename T> inline string getStrType(void);
@@ -58 +60 @@
   macro(CVariable)
   macro(CVariableGroup)
-  macro(CTransformation)
-  macro(CTransformationGroup)
-
+  macro(CInverseAxis)
+  macro(CInverseAxisGroup)
+  macro(CZoomAxis)
+  macro(CZoomAxisGroup)
 #undef macro
 }

XIOS/trunk/src/xios_spl.hpp

@@ -28 +28 @@
 
 /// boost headers ///
-//#include <boost/unordered_map.hpp>
+#include <boost/unordered_map.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/cast.hpp>

XIOS/trunk/src/xml_parser_decl.cpp

@@ -25 +25 @@
     macro( File )
     macro( Variable )
-    macro( Transformation )
+    macro( InverseAxis )
+    macro( ZoomAxis )
   }
 }