Changeset 619

Timestamp:

06/22/15 13:36:12 (10 years ago)

Author:

mhnguyen

Message:

Implementing the first prototype of filter

+) Create new class filter
+) Implement class for specific algorithm
+) Implement inversing algorithm

Test
+) On Curie
+) Grid with one axis: passed

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (4 diffs)
• src/config/node_type.conf (modified) (1 diff, 1 prop)
• src/config/transformation_attribute.conf (added)
• src/declare_virtual_node.hpp (added)
• src/filter (added)
• src/filter/axis_filter.cpp (added)
• src/filter/axis_filter.hpp (added)
• src/filter/axis_transformation.cpp (added)
• src/filter/axis_transformation.hpp (added)
• src/filter/generic_filter.cpp (added)
• src/filter/generic_filter.hpp (added)
• src/filter/invert_algorithm.cpp (added)
• src/filter/invert_algorithm.hpp (added)
• src/filter/zoom_algorithm.cpp (added)
• src/filter/zoom_algorithm.hpp (added)
• src/group_factory_decl.cpp (modified) (1 diff)
• src/group_template_decl.cpp (modified) (1 diff)
• src/node/axis.cpp (modified) (2 diffs)
• src/node/axis.hpp (modified) (6 diffs, 1 prop)
• src/node/context.cpp (modified) (1 diff)
• src/node/field.cpp (modified) (9 diffs)
• src/node/field.hpp (modified) (7 diffs, 1 prop)
• src/node/field_impl.hpp (modified) (7 diffs)
• src/node/grid.cpp (modified) (5 diffs)
• src/node/grid.hpp (modified) (7 diffs)
• src/node/node_enum.hpp (modified) (1 diff)
• src/node/node_type.hpp (modified) (1 diff)
• src/node/transformation.cpp (added)
• src/node/transformation.hpp (added)
• src/node/transformation_enum.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) (7 diffs)
• src/type/type_util.hpp (modified) (2 diffs)
• src/virtual_node.hpp (added)
• src/visitable.hpp (added)
• src/visitor.hpp (added)
• src/xml_parser_decl.cpp (modified) (2 diffs)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -10 +10 @@
      <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A" />
      <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_All_Axis" operation="average" freq_op="3600s" grid_ref="grid_All_Axis" />
      <field id="field_Scalar" operation="average" freq_op="3600s" grid_ref="ScalarGrid" />
@@ -17 +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">
-        <field field_ref="field_Axis" />
+<!--        <field field_ref="field_Axis" />-->
+     </file>
+     <file id="output_Axis_transformed" name="output_Axis_transformed" type="one_file">
+        <field field_ref="field_Axis_transformed" />
      </file>
      <file id="output_All_Axis" name="output_All_Axis" type="one_file">
@@ -35 +40 @@
      <axis id="axis_B" />
      <axis id="axis_C" zoom_size="2" zoom_end="2"/>
-     <axis id="axis_D" zoom_size="2" zoom_end="3"/>
+     <axis id="axis_D" />
+     <axis id="axis_E" axis_ref="axis_B">
+        <transformation type="inverse" />
+<!--        <transformation type="zoom" />-->
+     </axis>
    </axis_definition>
 
@@ -50 +59 @@
        <grid id="grid_Axis">
          <axis axis_ref="axis_D" />
+       </grid>
+       <grid id="grid_Two_Axis">
+         <axis axis_ref="axis_A" />
+         <axis axis_ref="axis_B" />
+       </grid>
+       <grid id="grid_Axis_tranformed">
+         <axis axis_ref="axis_A" />
+         <axis axis_ref="axis_E" />
        </grid>
        <grid id="grid_All_Axis">

XIOS/trunk/src/config/node_type.conf

@@ -31 +31 @@
 #endif //__XIOS_CCalendarWrapper__
 
+#ifdef __XIOS_CTransformation__
+   DECLARE_NODE(Transformation, transformation)
+#endif //__XIOS_CTransformation__
+
 #ifdef __XIOS_CContext__
    DECLARE_NODE_PAR(Context, context)

XIOS/trunk/src/group_factory_decl.cpp

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

XIOS/trunk/src/group_template_decl.cpp

@@ -6 +6 @@
 #  define macro(T) \
   template class CGroupTemplate<C##T, C##T##Group, C##T##Attributes> ;
-  
-  macro(Context) 
-  macro(Field) 
-  macro(File) 
-  macro(Domain) 
-  macro(Grid) 
-  macro(Axis) 
-  macro(Variable) 
-  
+
+  macro(Context)
+  macro(Field)
+  macro(File)
+  macro(Domain)
+  macro(Grid)
+  macro(Axis)
+  macro(Variable)
+  macro(Transformation)
+
 
 }

XIOS/trunk/src/node/axis.cpp

@@ -87 +87 @@
 
       StdSize true_size = value.numElements();
-      if (size != true_size)
+      if (this->ni.getValue() != true_size)
          ERROR("CAxis::checkAttributes(void)",
                << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute");
@@ -306 +306 @@
   }
 
+  bool CAxis::hasTransformation()
+  {
+    return (!transformations_.empty());
+  }
+
+  void CAxis::setTransformations(const std::vector<ETransformationType>& transformations)
+  {
+    transformations_ = transformations;
+  }
+
+  void CAxis::solveInheritanceTransformation()
+  {
+    if (this->hasTransformation()) return;
+
+    std::vector<CAxis*> refAxis;
+    CAxis* refer_sptr;
+    CAxis* refer_ptr = this;
+    while (refer_ptr->hasDirectAxisReference())
+    {
+      refAxis.push_back(refer_ptr);
+      refer_sptr = refer_ptr->getDirectAxisReference();
+      refer_ptr  = refer_sptr;
+      if (refer_ptr->hasTransformation()) break;
+    }
+
+    if (refer_ptr->hasTransformation())
+      for (int idx = 0; idx < refAxis.size(); ++idx)
+        refAxis[idx]->setTransformations(refer_ptr->getTransformations());
+  }
+
+  void CAxis::parse(xml::CXMLNode & node)
+  {
+    SuperClass::parse(node);
+
+    if (node.goToChildElement())
+    {
+      StdString tranformation("transformation");
+      do
+      {
+        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)
 

XIOS/trunk/src/node/axis.hpp

@@ -5 +5 @@
 #include "xios_spl.hpp"
 #include "group_factory.hpp"
+#include "virtual_node.hpp"
 
 #include "declare_group.hpp"
 #include "declare_ref_func.hpp"
+#include "declare_virtual_node.hpp"
 #include "attribute_array.hpp"
 #include "attribute_enum.hpp"
 #include "attribute_enum_impl.hpp"
 #include "server_distribution_description.hpp"
+#include "transformation.hpp"
+#include "transformation_enum.hpp"
 
 namespace xios {
@@ -19 +23 @@
    class CAxisAttributes;
    class CAxis;
+   class CTransformationGroup;
+   class CVirtualTransformationGroup;
 
+   DECLARE_VIRTUAL_NODE(TransformationGroup);
    ///--------------------------------------------------------------
 
@@ -32 +39 @@
       : public CObjectTemplate<CAxis>
       , public CAxisAttributes
+      , public CVirtualTransformationGroup
    {
          enum EEventId
@@ -69 +77 @@
          virtual ~CAxis(void);
 
+         virtual void parse(xml::CXMLNode & node);
+
          /// Accesseurs statiques ///
          static StdString GetName(void);
@@ -83 +93 @@
          void sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
                                     CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
+
+         bool hasTransformation();
+         void setTransformations(const std::vector<ETransformationType>&);
+         const std::vector<ETransformationType>& getTransformations();
+         void solveInheritanceTransformation();
+
       public:
         int zoom_begin_srv, zoom_end_srv, zoom_size_srv;
@@ -92 +108 @@
          void checkZoom();
 
+
+         void checkTransformation();
       private:
-
          bool isChecked;
          bool areClientAttributesChecked_;
          std::set<StdString> relFiles;
+         std::vector<ETransformationType> transformations_;
          bool isDistributed_;
 

XIOS/trunk/src/node/context.cpp

@@ -894 +894 @@
        {
          const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getRefDomainAxisIds();
-         domainIds.insert(prDomAxisId.first);
-         axisIds.insert(prDomAxisId.second);
+         if ("" != prDomAxisId.first) domainIds.insert(prDomAxisId.first);
+         if ("" != prDomAxisId.second) axisIds.insert(prDomAxisId.second);
        }
      }

XIOS/trunk/src/node/field.cpp

@@ -13 +13 @@
 #include "context_server.hpp"
 #include <set>
+#include "axis_filter.hpp"
+#include "invert_algorithm.hpp"
 
 namespace xios{
@@ -27 +29 @@
       , foperation(), hasInstantData(false), hasExpression(false)
       , active(false) , hasOutputFile(false),hasFieldOut(false), slotUpdateDate(NULL)
-      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false)
+      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0)
       , isReadDataRequestPending(false)
       { setVirtualVariableGroup(); }
@@ -40 +42 @@
       , foperation(), hasInstantData(false), hasExpression(false)
       , active(false), hasOutputFile(false), hasFieldOut(false), slotUpdateDate(NULL)
-      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false)
+      , processed(false), domAxisIds_("", ""), areAllReferenceSolved(false), areAllExpressionBuilt(false), filter(0)
       , isReadDataRequestPending(false)
    { setVirtualVariableGroup(); }
@@ -51 +53 @@
       if (hasExpression) delete expression;
       if (slotUpdateDate != NULL) delete slotUpdateDate;
+      if (0 != filter) delete filter;
 
    }
@@ -172 +175 @@
             int rank=(*it).first ;
             CArray<int,1>& index = *(it->second) ;
+                       std::cout << "rank " << index << std::endl;
+                       std::cout << "data " << data << std::endl;
             CArray<double,1> data_tmp(index.numElements()) ;
             for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ;
@@ -527 +532 @@
       return(this->last_operation);
    }
-
-   //----------------------------------------------------------------
-
-//   void CField::processEnabledField(void)
-//   {
-//      if (!processed)
-//      {
-//        processed = true;
-//        solveRefInheritance(true);
-//        solveBaseReference();
-//        solveOperation();
-//        solveGridReference();
-//
-//        if (hasDirectFieldReference()) baseRefObject->processEnabledField();
-//        buildExpression();
-//        active = true;
-//      }
-//    }
 
    void CField::solveAllReferenceEnabledField(bool doSending2Sever)
@@ -562 +549 @@
      }
      solveGridDomainAxisRef(doSending2Sever);
+     if (context->hasClient)
+     {
+       solveTransformedGrid();
+     }
      solveCheckMaskIndex(doSending2Sever);
    }
@@ -576 +567 @@
      {
        areAllExpressionBuilt = true;
-//       solveCheckMaskIndex(true);
-//       solveCheckMaskIndex();
-       if (hasDirectFieldReference()) baseRefObject->buildAllExpressionEnabledField();
+       if (hasDirectFieldReference() && (grid_ref.isEmpty())) baseRefObject->buildAllExpressionEnabledField();
        buildExpression();
        active = true;
@@ -770 +759 @@
    }
 
+   CGrid* CField::getGridRefOfBaseReference()
+   {
+     solveRefInheritance(true);
+     solveBaseReference();
+     baseRefObject->solveGridReference();
+
+     return baseRefObject->grid;
+   }
+
+   void CField::solveTransformedGrid()
+   {
+     if (!grid_ref.isEmpty() && (!field_ref.isEmpty()))
+     {
+       CField* fieldRef  = this;
+       CGrid* gridRefOfFieldRef = 0;
+       while (fieldRef->hasDirectFieldReference())
+       {
+         if ((!(fieldRef->grid_ref.isEmpty())) &&
+             (fieldRef->grid_ref.getValue() != grid_ref.getValue()))
+         {
+           gridRefOfFieldRef = fieldRef->getGridRefOfBaseReference();
+           fieldRef->addReference(this);
+           fieldRef->solveGridDomainAxisRef(false);
+           fieldRef->solveCheckMaskIndex(false);
+           break;
+         }
+         CField* tmp = fieldRef->getDirectFieldReference();
+         fieldRef = tmp;
+       }
+
+       if ((0 == gridRefOfFieldRef) &&
+           (!(fieldRef->grid_ref.isEmpty())) &&
+           (fieldRef->grid_ref.getValue() != grid_ref.getValue()))
+       {
+         gridRefOfFieldRef = fieldRef->getGridRefOfBaseReference();
+         fieldRef->addReference(this);
+         fieldRef->solveGridDomainAxisRef(false);
+         fieldRef->solveCheckMaskIndex(false);
+       }
+
+       CGrid* relGridRef = CGrid::get(grid_ref.getValue());
+       if ((0 != gridRefOfFieldRef) && (relGridRef != gridRefOfFieldRef) && (!(relGridRef->isTransformed())))
+       {
+         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();
+       }
+     }
+   }
+
+
+  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()
+   {
+     filter->setInputs(filterSources_);
+     filter->setOutput(this);
+     filter->apply(algorithms_);
+
+   }
+
    ///-------------------------------------------------------------------
 

XIOS/trunk/src/node/field.hpp

@@ -15 +15 @@
 #include "expr_node.hpp"
 #include "declare_ref_func.hpp"
+#include "generic_filter.hpp"
+#include "transformation_enum.hpp"
 
 
@@ -28 +30 @@
    class CGrid;
    class CContext ;
+   class CGenericFilter;
+
    ///--------------------------------------------------------------
 
@@ -92 +96 @@
 
          template <int N> bool updateData(const CArray<double, N>&   data);
+         template <int N> bool updateFilteredData(CArray<double, N>&   data);
+         template<int N>
+         void updateDataWithoutOperation(const CArray<double, N>& data);
          bool updateDataFromExpression(const CArray<double, 1>&   data);
          void setDataFromExpression(const CArray<double, 1>& _data) ;
@@ -116 +123 @@
          void buildAllExpressionEnabledField();
          void solveGridDomainAxisRef(bool checkAtt);
-
+         void solveTransformedGrid();
+         CGrid* getGridRefOfBaseReference();
 
 //         virtual void fromBinary(StdIStream & is);
@@ -171 +179 @@
 
         const std::pair<StdString, StdString>& getRefDomainAxisIds();
+
+        const std::vector<CField*>& getFilterSources();
+        void applyFilter();
+        void setAlgorithms();
       public :
          /// Propriétés privées ///
@@ -193 +205 @@
          CArray<double, 1> data;
          CArray<double, 1> instantData;
+         CArray<double, 1> filteredData;
          bool hasInstantData ;
          map<int, CArray<double,1>* > data_srv ;
@@ -214 +227 @@
          std::pair<StdString,StdString> domAxisIds_;
          bool isReadDataRequestPending;
+         std::vector<CField*> filterSources_;
+         std::vector<CGenericAlgorithm*> algorithms_;
+         std::vector<ETransformationType> transformations_;
          DECLARE_REF_FUNC(Field,field)
-//       public:
-//         bool hasDirectFieldReference(void) const;
-//         CField* getDirectFieldReference(void) const;
-//         CField* getBaseFieldReference(void) const;
-//         void addReference(CField* field);
-//         const std::vector<CField*> & getAllReference(void) const;
-//void solveRefInheritance(bool apply);
-//void solveBaseReference(void);
-//         void removeRefInheritance();
-//         const StdString & getBaseFieldId(void) const;
-//
-//         std::vector<CField*> refObject;
-//         CField* baseRefObject;
-
 
    }; // class CField

XIOS/trunk/src/node/field_impl.hpp

@@ -25 +25 @@
     {
       const std::vector<CField*>& refField=getAllReference();
-      std::vector<CField*>::const_iterator  it = refField.begin(), end = refField.end();
-
-      for (; it != end; it++) (*it)->setData(_data);
-      if (hasOutputFile || hasFieldOut) updateData(_data);
+      std::vector<CField*>::const_iterator  it = refField.begin(), end = refField.end(),
+                                            itFilterSrc, iteFilterSrc;
+
+      for (; it != end; it++)
+      {
+        const std::vector<CField*>& fieldFilterSources = (*it)->getFilterSources();
+        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;
+          if ((*it)->hasOutputFile || (*it)->hasFieldOut) (*it)->updateFilteredData((*it)->filteredData);
+        }
+        else
+        {
+          (*it)->setData(_data);
+          if (hasOutputFile || hasFieldOut) updateData(_data);
+        }
+
+      }
+
     }
   }
@@ -50 +69 @@
   }
 
-   template <int N>
-   bool CField::updateData(const CArray<double, N>& _data)
+   template<int N>
+   void CField::updateDataWithoutOperation(const CArray<double, N>& _data)
+   {
+     if (this->data.numElements() != this->grid->storeIndex_client.numElements())
+     {
+        this->data.resize(this->grid->storeIndex_client.numElements());
+        this->grid->inputField(_data, this->data);
+     }
+   }
+
+   template<int N>
+   bool CField::updateFilteredData(CArray<double, N>& filteredData)
    {
       CContext* context=CContext::getCurrent();
@@ -70 +99 @@
       if (doOperation)
       {
-         if (this->data.numElements() != this->grid->storeIndex_client.numElements())
-         {
-            this->data.resize(this->grid->storeIndex_client.numElements());
-         }
-
-         CArray<double,1> input(data.numElements());
-         this->grid->inputField(_data, input);
-         (*this->foperation)(input);
+         if (this->data.numElements() != filteredData.numElements())
+         {
+            this->data.resize(filteredData.numElements());
+         }
+
+         (*this->foperation)(filteredData);
 
          *last_operation = currDate;
@@ -106 +133 @@
          }
 
-         if (hasFieldOut)
-         {
-           fieldOut->setDataFromExpression(data);
-         }
+//         if (hasFieldOut)
+//         {
+//           fieldOut->setDataFromExpression(data);
+//         }
          return (true);
       }
@@ -116 +143 @@
    }
 
-   bool CField::updateDataFromExpression(const CArray<double, 1>& _data)
+   template <int N>
+   bool CField::updateData(const CArray<double, N>& _data)
    {
       CContext* context=CContext::getCurrent();
@@ -140 +168 @@
          }
 
-        (*this->foperation)(_data);
+         CArray<double,1> input(data.numElements());
+         this->grid->inputField(_data, input);
+         (*this->foperation)(input);
 
          *last_operation = currDate;
@@ -179 +209 @@
    }
 
+   bool CField::updateDataFromExpression(const CArray<double, 1>& _data)
+   {
+      CContext* context=CContext::getCurrent();
+      const CDate & currDate = context->getCalendar()->getCurrentDate();
+      const CDate opeDate      = *last_operation + freq_operation;
+      const CDate writeDate    = *last_Write     + freq_write;
+      bool doOperation, doWrite;
+
+
+      info(50) << "CField::updateData " << currDate <<  " : send data to " << this->getBaseFieldId() << std::endl;
+      info(50) << "Next operation "  << opeDate<<std::endl;
+
+      doOperation = (opeDate <= currDate);
+      if (isOnceOperation)
+        if (isFirstOperation) doOperation=true;
+        else doOperation=false;
+
+      if (doOperation)
+      {
+         if (this->data.numElements() != this->grid->storeIndex_client.numElements())
+         {
+            this->data.resize(this->grid->storeIndex_client.numElements());
+         }
+
+        (*this->foperation)(_data);
+
+         *last_operation = currDate;
+         info(50) << "(*last_operation = currDate) : " << *last_operation << " = " << currDate << std::endl;
+      }
+
+      doWrite = (writeDate < (currDate + freq_operation));
+      if (isOnceOperation)
+      {
+        if(isFirstOperation)
+        {
+          doWrite=true;
+          isFirstOperation=false;
+        }
+        else doWrite=false;
+      }
+
+      if (doWrite)
+      {
+         this->foperation->final();
+         *last_Write = writeDate;
+         if (hasOutputFile)
+         {
+           info(50) << "(*last_Write = currDate) : " << *last_Write << " = " << currDate << std::endl;
+           CTimer::get("XIOS Send Data").resume();
+           sendUpdateData();
+           CTimer::get("XIOS Send Data").suspend();
+         }
+
+         if (hasFieldOut)
+         {
+           fieldOut->setDataFromExpression(data);
+         }
+         return (true);
+      }
+
+      return (false);
+   }
+
   template <int N>
   void CField::getData(CArray<double, N>& _data) const

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 {
@@ -24 +26 @@
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false)
    {
      setVirtualDomainGroup();
@@ -35 +37 @@
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
       , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), algorithms_(), transformations_(), isTransformed_(false)
    {
      setVirtualDomainGroup();
@@ -51 +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;
    }
 
@@ -1093 +1096 @@
         pAxis->solveRefInheritance(apply);
         pAxis->solveBaseReference();
+        pAxis->solveInheritanceTransformation();
         if ((!pAxis->axis_ref.isEmpty()) && (pAxis->name.isEmpty()))
           pAxis->name.setValue(pAxis->getBaseAxisReference()->getId());
       }
     }
+  }
+
+  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()
+  {
+    return transformations_;
+  }
+
+  bool CGrid::isTransformed()
+  {
+    return isTransformed_;
+  }
+
+  void CGrid::setTransformed()
+  {
+    isTransformed_ = true;
+  }
+
+  const std::vector<CGenericAlgorithm*>& CGrid::getTransformationAlgo()
+  {
+    return algorithms_;
+  }
+
+  void CGrid::transformGrid(CGrid* transformedGrid)
+  {
+    if (transformedGrid->isTransformed()) return;
+    transformedGrid->setTransformed();
+    if (axis_domain_order.numElements() != transformedGrid->axis_domain_order.numElements())
+    {
+      ERROR("CGrid::transformGrid(CGrid* transformedGrid)",
+           << "Two grids have different dimension size"
+           << "Dimension of grid source " <<this->getId() << " is " << axis_domain_order.numElements() << std::endl
+           << "Dimension of grid destination " <<transformedGrid->getId() << " is " << transformedGrid->axis_domain_order.numElements());
+    }
+    else
+    {
+      int ssize = axis_domain_order.numElements();
+      for (int i = 0; i < ssize; ++i)
+        if (axis_domain_order(i) != (transformedGrid->axis_domain_order)(i))
+          ERROR("CGrid::transformGrid(CGrid* transformedGrid)",
+                << "Grids " <<this->getId() <<" and " << transformedGrid->getId()
+                << " don't have elements in the same order");
+    }
+
+    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;
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -16 +16 @@
 #include "client_server_mapping.hpp"
 #include "utils.hpp"
+#include "transformation_enum.hpp"
+#include "visitor.hpp"
 
 namespace xios {
@@ -58 +60 @@
          } ;
 
+         enum EElementType
+         {
+           GRID_ONLY_AXIS, GRID_ONLY_DOMAIN, GRID_AXIS_DOMAIN
+         };
+
          /// Constructeurs ///
          CGrid(void);
@@ -140 +147 @@
          void solveAxisRef(bool checkAtt);
          void solveDomainAxisRefInheritance(bool apply = true);
+         void solveTransformations();
 
          void sendAddDomain(const std::string& id="");
@@ -175 +183 @@
          const CDistributionServer* getDistributionServer() const;
 
+         void transformGrid(CGrid* transformedGrid);
+         bool isTransformed();
+         void setTransformed();
+         EElementType getGridElementType();
+
+         std::vector<ETransformationType> getTransformations();
+         const std::vector<CGenericAlgorithm*>& getTransformationAlgo();
+
       public:
 
@@ -191 +207 @@
          void checkMask(void) ;
 
+         std::vector<CGenericAlgorithm*> algorithms_;
       private:
        template<int N>
@@ -214 +231 @@
         CAxisGroup* getVirtualAxisGroup() const;
         CDomainGroup* getVirtualDomainGroup() const;
+
+
+        void setTransformationAlgorithms();
+
         std::vector<int> globalDim_;
       private:
@@ -229 +250 @@
         std::vector<int> connectedServerRank_;
         bool isDataDistributed_;
+
+
+        std::vector<ETransformationType> transformations_;
+        bool isTransformed_;
    }; // class CGrid
 

XIOS/trunk/src/node/node_enum.hpp

@@ -18 +18 @@
          eVariable,gVariable,
          eContext,gContext,
-         eCalendarWrapper
+         eCalendarWrapper,
+         eTransformation
 
 //#include "node_type.conf"

XIOS/trunk/src/node/node_type.hpp

@@ -9 +9 @@
 #include "variable.hpp"
 #include "context.hpp"
+#include "transformation.hpp"
 
 #endif // __XIOS_NODE_TYPE__

XIOS/trunk/src/object_factory_decl.cpp

@@ -24 +24 @@
   macro(CCalendarWrapper)
   macro(CVariable)
+  macro(CTransformation)
 
   macro(CFieldGroup)
@@ -32 +33 @@
   macro(CContextGroup)
   macro(CVariableGroup)
+  macro(CTransformationGroup)
 }

XIOS/trunk/src/object_template_decl.cpp

@@ -8 +8 @@
 #include "axis.hpp"
 #include "variable.hpp"
+#include "transformation.hpp"
 
 
@@ -20 +21 @@
   template class CObjectTemplate<CAxis>;
   template class CObjectTemplate<CVariable>;
+  template class CObjectTemplate<CTransformation>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -28 +30 @@
   template class CObjectTemplate<CAxisGroup>;
   template class CObjectTemplate<CVariableGroup>;
+  template class CObjectTemplate<CTransformationGroup>;
 }

XIOS/trunk/src/test/test_new_features.f90

@@ -17 +17 @@
   INTEGER,PARAMETER :: ni_glo=100
   INTEGER,PARAMETER :: nj_glo=100
-  INTEGER,PARAMETER :: llm=5
+  INTEGER,PARAMETER :: llm=10
   DOUBLE PRECISION  :: lval(llm)=1, tsTemp
   TYPE(xios_field) :: field_hdl
@@ -26 +26 @@
   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(:)
+  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:), lvaln(:), field_Two_Axis(:,:)
   INTEGER :: ni,ibegin,iend,nj,jbegin,jend, nAxis, axisBegin, axisEnd
   INTEGER :: i,j,l,ts,n
@@ -67 +67 @@
   axisBegin = 0
   nAxis = llm
-!  DO n=0, size -1
-!    nAxis = llm/size
-!    IF (n<MOD(llm,size)) nAxis=nAxis+1
-!    IF (n==rank) exit
-!    axisBegin=axisBegin+nAxis
-!  ENDDO
+  DO n=0, size -1
+    nAxis = llm/size
+    IF (n<MOD(llm,size)) nAxis=nAxis+1
+    IF (n==rank) exit
+    axisBegin=axisBegin+nAxis
+  ENDDO
   axisEnd=axisBegin+nAxis-1
 
-  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))
+  DO i=1,llm
+    lval(i) = i
+  ENDDO
+
+
+  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))
   lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
@@ -81 +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)
+  lvaln(1:nAxis) = lval(axisBegin+1:axisEnd+1)
 
   CALL xios_context_initialize("test",comm)
@@ -92 +99 @@
   CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj)
   CALL xios_set_axis_attr("axis_C", size=llm, value=lval)
-  CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lval)
+  CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lvaln)
   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)
@@ -99 +106 @@
   CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)
 
-  CALL xios_get_handle("field_definition",fieldgroup_hdl)
-  CALL xios_add_child(fieldgroup_hdl,field_hdl,"field_B")
-  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_B")
-
-  CALL xios_get_handle("output",file_hdl)
-  CALL xios_add_child(file_hdl,field_hdl)
-  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C")
-
-  CALL xios_get_handle("output_All_Axis",file_hdl)
-  CALL xios_add_child(file_hdl,field_hdl)
-  CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C")
+!  CALL xios_get_handle("field_definition",fieldgroup_hdl)
+!  CALL xios_add_child(fieldgroup_hdl,field_hdl,"field_B")
+!  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_B")
+!
+!  CALL xios_get_handle("output",file_hdl)
+!  CALL xios_add_child(file_hdl,field_hdl)
+!  CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C")
+!
+!  CALL xios_get_handle("output_All_Axis",file_hdl)
+!  CALL xios_add_child(file_hdl,field_hdl)
+!  CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C")
 
   dtime%second = 3600
@@ -146 +153 @@
   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_All_Axis",field_All_Axis)
-    tsTemp = ts
-    CALL xios_send_scalar("field_Scalar", tsTemp)
+
+    CALL xios_send_field("field_Two_Axis",field_Two_Axis)
+!    CALL xios_send_field("field_All_Axis",field_All_Axis)
+!    tsTemp = ts
+!    CALL xios_send_scalar("field_Scalar", tsTemp)
     CALL wait_us(5000) ;
   ENDDO

XIOS/trunk/src/type/type_util.hpp

@@ -20 +20 @@
     class CVariable;
     class CVariableGroup;
+    class CTransformation;
+    class CTransformationGroup;
 
   template <typename T> inline string getStrType(void);
@@ -56 +58 @@
   macro(CVariable)
   macro(CVariableGroup)
+  macro(CTransformation)
+  macro(CTransformationGroup)
 
 #undef macro

XIOS/trunk/src/xml_parser_decl.cpp

@@ -7 +7 @@
 #include "file.hpp"
 #include "variable.hpp"
-
+#include "transformation.hpp"
 
 namespace xios
@@ -14 +14 @@
   {
     template void CXMLParser::ParseInclude<CContext>(StdIStream & stream, const string& fluxId, CContext& object) ;
- 
+
  #   define macro(T) \
     template void CXMLParser::ParseInclude< CGroupTemplate<C##T, C##T##Group, C##T##Attributes> >(StdIStream & stream, const string& fluxId, CGroupTemplate<C##T, C##T##Group, C##T##Attributes>& object) ;
-    
-    macro( Context ) 
-    macro( Axis ) 
-    macro( Domain ) 
-    macro( Grid ) 
-    macro( Field ) 
-    macro( File ) 
-    macro( Variable ) 
+
+    macro( Context )
+    macro( Axis )
+    macro( Domain )
+    macro( Grid )
+    macro( Field )
+    macro( File )
+    macro( Variable )
+    macro( Transformation )
   }
 }