Changeset 631 for XIOS/trunk

Timestamp:

07/07/15 10:46:33 (9 years ago)

Author:

mhnguyen

Message:

Implementing zooming on a domain

+) Add algorithm to do zooming on a domain
+) Remove some redundant codes

Test
+) On Curie
+) test_complete and test_client are correct

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (3 diffs)
• src/config/node_type.conf (modified) (1 diff)
• src/config/zoom_domain_attribute.conf (added)
• src/distribution_client.cpp (modified) (2 diffs)
• 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) (1 diff)
• src/node/domain.cpp (modified) (11 diffs)
• src/node/domain.hpp (modified) (7 diffs)
• src/node/grid.cpp (modified) (2 diffs)
• src/node/node_enum.hpp (modified) (1 diff)
• src/node/node_type.hpp (modified) (1 diff)
• src/node/transformation_enum.hpp (modified) (1 diff)
• src/node/zoom_domain.cpp (added)
• src/node/zoom_domain.hpp (added)
• src/object_factory_decl.cpp (modified) (2 diffs)
• src/object_template_decl.cpp (modified) (3 diffs)
• src/output/nc4_data_output.cpp (modified) (6 diffs)
• src/test/test_new_features.f90 (modified) (1 diff)
• src/transformation/axis_algorithm_transformation.cpp (modified) (1 diff)
• src/transformation/axis_algorithm_transformation.hpp (modified) (1 diff)
• src/transformation/domain_algorithm_transformation.cpp (added)
• src/transformation/domain_algorithm_transformation.hpp (added)
• src/transformation/domain_algorithm_zoom.cpp (added)
• src/transformation/domain_algorithm_zoom.hpp (added)
• src/transformation/generic_algorithm_transformation.cpp (modified) (3 diffs)
• src/transformation/generic_algorithm_transformation.hpp (modified) (2 diffs)
• src/transformation/grid_transformation.cpp (modified) (9 diffs)
• src/transformation/grid_transformation.hpp (modified) (2 diffs)
• src/type/type_util.hpp (modified) (2 diffs)
• src/xml_parser_decl.cpp (modified) (2 diffs)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -54 +54 @@
      </axis>
      <axis id="axis_H" axis_ref="axis_C">
-<!--       <inverse_axis />-->
-       <zoom_axis zoom_begin="0" zoom_size="3" />
+       <inverse_axis />
+       <zoom_axis zoom_begin="0" zoom_size="1" />
      </axis>
    </axis_definition>
@@ -61 +61 @@
    <domain_definition>
      <domain id="domain_A" />
+     <domain id="domain_A_zoom" domain_ref="domain_A">
+       <zoom_domain zoom_ibegin="1" zoom_ni="3" zoom_jbegin="0" zoom_nj="4"/>
+       <zoom_domain zoom_ibegin="0" zoom_ni="2" zoom_jbegin="0" zoom_nj="2"/>
+     </domain>
    </domain_definition>
 
@@ -82 +86 @@
        </grid>
        <grid id="grid_Axis_tranformed">
-         <domain domain_ref="domain_A" />
-            <axis axis_ref="axis_H" />
+<!--         <domain domain_ref="domain_A" />-->
+         <domain domain_ref="domain_A_zoom" />
+         <axis axis_ref="axis_H" />
 <!--         <axis axis_ref="axis_E" />-->
 <!--         <axis axis_ref="axis_F" />-->

XIOS/trunk/src/config/node_type.conf

@@ -43 +43 @@
 #endif //__XIOS_CInterpolateAxis__
 
+#ifdef __XIOS_CZoomDomain__
+   DECLARE_NODE(ZoomDomain, zoom_domain)
+#endif //__XIOS_CZoomDomain__
+
 #ifdef __XIOS_CContext__
    DECLARE_NODE_PAR(Context, context)

XIOS/trunk/src/distribution_client.cpp

@@ -200 +200 @@
       nBeginLocal_.at(indexMap_[idx]+1) = 0;
       nBeginGlobal_.at(indexMap_[idx]+1) = domList[domIndex]->jbegin;
-      nZoomBegin_.at((indexMap_[idx]+1)) = domList[domIndex]->zoom_jbegin;
-      nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->zoom_jbegin + domList[domIndex]->zoom_nj-1;
+      nZoomBegin_.at((indexMap_[idx]+1)) = domList[domIndex]->global_zoom_jbegin;
+      nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->global_zoom_jbegin + domList[domIndex]->global_zoom_nj-1;
 
       dataBegin_.at(indexMap_[idx]+1) = (2 == domList[domIndex]->data_dim) ? domList[domIndex]->data_jbegin.getValue() : -1;
@@ -212 +212 @@
       nBeginLocal_.at(indexMap_[idx]) = 0;
       nBeginGlobal_.at(indexMap_[idx]) = domList[domIndex]->ibegin;
-      nZoomBegin_.at((indexMap_[idx])) = domList[domIndex]->zoom_ibegin;
-      nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->zoom_ibegin + domList[domIndex]->zoom_ni-1;
+      nZoomBegin_.at((indexMap_[idx])) = domList[domIndex]->global_zoom_ibegin;
+      nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->global_zoom_ibegin + domList[domIndex]->global_zoom_ni-1;
 
       dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue();

XIOS/trunk/src/group_factory_decl.cpp

@@ -28 +28 @@
   macro(CZoomAxisGroup)
   macro(CInterpolateAxisGroup)
+  macro(CZoomDomainGroup)
 }

XIOS/trunk/src/group_template_decl.cpp

@@ -17 +17 @@
   macro(ZoomAxis)
   macro(InterpolateAxis)
+  macro(ZoomDomain)
 
 }

XIOS/trunk/src/node/axis.cpp

@@ -104 +104 @@
 //               << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute");
 
-      if (0 == global_zoom_size) global_zoom_size = size;
+
       this->checkData();
       this->checkMask();
-//      this->checkZoom();
+      this->checkZoom();
 
       if (!bounds.isEmpty())
@@ -138 +138 @@
    }
 
-//   void CAxis::checkZoom(void)
-//   {
-//      StdSize zoom_begin,zoom_end, zoom_size, axisSize;
-//
-//      zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ;
-//      zoom_size  = (this->zoom_size.isEmpty()) ?  size.getValue() : this->zoom_size.getValue() ;
-//      zoom_end   = (this->zoom_end.isEmpty()) ?  (size.getValue() - 1) : this->zoom_end.getValue() ;
-//
-//      if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1 ;
-//      if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1 ;
-//      if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1 ;
-//      axisSize = size.getValue();
-//
-//      if ( (zoom_begin < 0) || (zoom_begin > axisSize-1) || (zoom_end<0) || (zoom_end>axisSize-1) || (zoom_size<1) || (zoom_size>axisSize) || (zoom_begin>zoom_end))
-//        ERROR("CAxis::checkAttributes(void)",
-//              << "One or more attributes among <zoom_begin>, <zoom_end>, <zoom_size> of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
-//
-//      this->zoom_begin.setValue(zoom_begin) ;
-//      this->zoom_end.setValue(zoom_end) ;
-//      this->zoom_size.setValue(zoom_size) ;
-//   }
+   void CAxis::checkZoom(void)
+   {
+     if (0 == global_zoom_size) global_zoom_size = this->size.getValue();
+   }
 
    void CAxis::checkMask()

XIOS/trunk/src/node/axis.hpp

@@ -105 +105 @@
          void checkData();
          void checkMask();
-//         void checkZoom();
+         void checkZoom();
          void checkTransformations();
          void computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid,

XIOS/trunk/src/node/domain.cpp

@@ -16 +16 @@
 #include "server_distribution_description.hpp"
 #include "client_server_mapping_distributed.hpp"
+#include "zoom_domain.hpp"
 
 namespace xios {
@@ -547 +548 @@
 
       // compute client zoom indices
-
-      int zoom_iend=zoom_ibegin+zoom_ni-1 ;
-      zoom_ibegin_client = ibegin_client > zoom_ibegin ? ibegin_client : zoom_ibegin ;
-      zoom_iend_client = iend_client < zoom_iend ? iend_client : zoom_iend ;
+      // compute client zoom indices
+      if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
+      if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
+
+      int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
+      zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ;
+      zoom_iend_client = iend_client < global_zoom_iend ? iend_client : global_zoom_iend ;
       zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ;
       if (zoom_ni_client<0) zoom_ni_client=0 ;
 
 
-      int zoom_jend=zoom_jbegin+zoom_nj-1 ;
-      zoom_jbegin_client = jbegin_client > zoom_jbegin ? jbegin_client : zoom_jbegin ;
-      zoom_jend_client = jend_client < zoom_jend ? jend_client : zoom_jend ;
+      int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
+      zoom_jbegin_client = jbegin_client > global_zoom_jbegin ? jbegin_client : global_zoom_jbegin ;
+      zoom_jend_client = jend_client < global_zoom_jend ? jend_client : global_zoom_jend ;
       zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ;
       if (zoom_nj_client<0) zoom_nj_client=0 ;
+
+//      int zoom_iend=zoom_ibegin+zoom_ni-1 ;
+//      zoom_ibegin_client = ibegin_client > zoom_ibegin ? ibegin_client : zoom_ibegin ;
+//      zoom_iend_client = iend_client < zoom_iend ? iend_client : zoom_iend ;
+//      zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ;
+//      if (zoom_ni_client<0) zoom_ni_client=0 ;
+//
+//
+//      int zoom_jend=zoom_jbegin+zoom_nj-1 ;
+//      zoom_jbegin_client = jbegin_client > zoom_jbegin ? jbegin_client : zoom_jbegin ;
+//      zoom_jend_client = jend_client < zoom_jend ? jend_client : zoom_jend ;
+//      zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ;
+//      if (zoom_nj_client<0) zoom_nj_client=0 ;
 
    }
@@ -598 +615 @@
 
       this->checkDomain();
-      this->checkZoom();
+//      this->checkZoom();
       this->checkBounds();
       this->checkArea();
@@ -607 +624 @@
          this->checkDomainData();
          this->checkCompression();
-         this->completeLonLatClient();
-         this->computeConnectedServer() ;
+//         this->completeLonLatClient();
+//         this->computeConnectedServer() ;
       }
       else
@@ -625 +642 @@
      CContext* context=CContext::getCurrent() ;
 
+     this->checkZoom();
      if (this->isChecked) return;
      if (context->hasClient)
      {
+       this->computeConnectedServer();
+       this->completeLonLatClient();
+
        sendServerAttribut() ;
        sendLonLatArea() ;
@@ -703 +724 @@
         msg << this->getId() ;
         msg << ni_srv << ibegin_srv << iend_srv << nj_srv << jbegin_srv << jend_srv;
+        msg << global_zoom_ni << global_zoom_ibegin << global_zoom_nj << global_zoom_jbegin;
 
         event.push(*itRank,1,msg);
@@ -722 +744 @@
 
     int i,j,i_ind,j_ind ;
-    int zoom_iend=zoom_ibegin+zoom_ni-1 ;
-    int zoom_jend=zoom_jbegin+zoom_nj-1 ;
+    int zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
+    int zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
 
     // Precompute number of index
@@ -733 +755 @@
         j_ind=jbegin+j_index(i,j) ;
 
-        if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend)
+        if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend)
         {
           ++globalIndexCountZoom;
@@ -755 +777 @@
         globalIndexDomain(globalIndexCount) = globalIndex;
         ++globalIndexCount;
-        if (i_ind >= zoom_ibegin && i_ind <= zoom_iend && j_ind >= zoom_jbegin && j_ind <= zoom_jend)
+        if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend)
         {
           globalIndexDomainZoom(globalIndexCountZoom) = globalIndex;
@@ -976 +998 @@
   void CDomain::recvServerAttribut(CBufferIn& buffer)
   {
-    int zoom_iend = zoom_ibegin.getValue() + zoom_ni.getValue() - 1;
-    int zoom_jend = zoom_jbegin.getValue() + zoom_nj.getValue() - 1;
-
-    buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv;
-
-    zoom_ibegin_srv = zoom_ibegin.getValue() > ibegin_srv ? zoom_ibegin.getValue() : ibegin_srv ;
+    buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv
+           >> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin;
+
+    int zoom_iend = global_zoom_ibegin + global_zoom_ni - 1;
+    int zoom_jend = global_zoom_jbegin + global_zoom_nj - 1;
+
+    zoom_ibegin_srv = global_zoom_ibegin > ibegin_srv ? global_zoom_ibegin : ibegin_srv ;
     zoom_iend_srv = zoom_iend < iend_srv ? zoom_iend : iend_srv ;
     zoom_ni_srv=zoom_iend_srv-zoom_ibegin_srv+1 ;
 
-    zoom_jbegin_srv = zoom_jbegin.getValue() > jbegin_srv ? zoom_jbegin.getValue() : jbegin_srv ;
+    zoom_jbegin_srv = global_zoom_jbegin > jbegin_srv ? global_zoom_jbegin : jbegin_srv ;
     zoom_jend_srv = zoom_jend < jend_srv ? zoom_jend : jend_srv ;
     zoom_nj_srv=zoom_jend_srv-zoom_jbegin_srv+1 ;
@@ -1127 +1150 @@
   }
 
+  bool CDomain::hasTransformation()
+  {
+    return (!transformationMap_.empty());
+  }
+
+  void CDomain::setTransformations(const TransMapTypes& domTrans)
+  {
+    transformationMap_ = domTrans;
+  }
+
+  CDomain::TransMapTypes CDomain::getAllTransformations(void)
+  {
+    return transformationMap_;
+  }
+
+  /*!
+    Check the validity of all transformations applied on domain
+  This functions is called AFTER all inherited attributes are solved
+  */
+  void CDomain::checkTransformations()
+  {
+    TransMapTypes::const_iterator itb = transformationMap_.begin(), it,
+                                  ite = transformationMap_.end();
+    for (it = itb; it != ite; ++it)
+    {
+      (it->second)->checkValid(this);
+    }
+  }
+
+  void CDomain::solveInheritanceTransformation()
+  {
+    if (this->hasTransformation()) return;
+
+    std::vector<CDomain*> refDomain;
+    CDomain* refer_sptr;
+    CDomain* refer_ptr = this;
+    while (refer_ptr->hasDirectDomainReference())
+    {
+      refDomain.push_back(refer_ptr);
+      refer_sptr = refer_ptr->getDirectDomainReference();
+      refer_ptr  = refer_sptr;
+      if (refer_ptr->hasTransformation()) break;
+    }
+
+    if (refer_ptr->hasTransformation())
+      for (int idx = 0; idx < refDomain.size(); ++idx)
+        refDomain[idx]->setTransformations(refer_ptr->getAllTransformations());
+  }
+
+  void CDomain::parse(xml::CXMLNode & node)
+  {
+    SuperClass::parse(node);
+
+    if (node.goToChildElement())
+    {
+      StdString zoomDomainDefRoot("zoom_domain_definition");
+      StdString zoom("zoom_domain");
+      do
+      {
+        if (node.getElementName() == zoom) {
+          CZoomDomain* tmp = (CZoomDomainGroup::get(zoomDomainDefRoot))->createChild();
+          tmp->parse(node);
+          transformationMap_.push_back(std::make_pair(TRANS_ZOOM_DOMAIN,tmp));
+        }
+      } while (node.goToNextElement()) ;
+      node.goToParentElement();
+    }
+  }
    //----------------------------------------------------------------
 

XIOS/trunk/src/node/domain.hpp

@@ -14 +14 @@
 #include "attribute_array.hpp"
 #include "attribute_enum.hpp"
+#include "transformation.hpp"
+#include "transformation_enum.hpp"
 
 namespace xios {
@@ -49 +51 @@
          typedef CDomainAttributes RelAttributes;
          typedef CDomainGroup      RelGroup;
+         typedef CTransformation<CDomain>::TransformationMapTypes TransMapTypes;
 
          /// Constructeurs ///
@@ -59 +62 @@
          void duplicateAttributes(CDomain* domain);
 
+         virtual void parse(xml::CXMLNode & node);
+
          /// Vérifications ///
          void checkAttributes(void);
@@ -65 +70 @@
 
          void sendCheckedAttributes();
+
+         bool hasTransformation();
+         void solveInheritanceTransformation();
+         TransMapTypes getAllTransformations();
 
       private :
@@ -122 +131 @@
         CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target
 
-
+        int global_zoom_ibegin, global_zoom_ni;
+        int global_zoom_jbegin, global_zoom_nj;
 //        vector<int> ib_srv, ie_srv, in_srv ;
 //        vector<int> jb_srv, je_srv, jn_srv ;
@@ -160 +170 @@
          bool hasBounds ;
          bool hasArea;
+      private:
+         void checkTransformations();
+         void setTransformations(const TransMapTypes&);
+
        private :
-
-         /// Proriétés protégées ///
          bool isChecked;
          std::set<StdString> relFiles;
@@ -171 +183 @@
          std::vector<int> connectedServerRank_;
          bool isDistributed_;
+         TransMapTypes transformationMap_;
 
          DECLARE_REF_FUNC(Domain,domain)

XIOS/trunk/src/node/grid.cpp

@@ -862 +862 @@
             nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin_srv;
             nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni_srv;
-            nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->zoom_ibegin;
+            nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin;
             nGlob[indexMap[i]] = domainList[domainId]->ni_glo;
 
             nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin_srv;
             nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj_srv;
-            nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin;
+            nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin;
             nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo;
             ++domainId;
@@ -1124 +1124 @@
         pDom->solveRefInheritance(apply);
         pDom->solveBaseReference();
+        pDom->solveInheritanceTransformation();
         if ((!pDom->domain_ref.isEmpty()) && (pDom->name.isEmpty()))
           pDom->name.setValue(pDom->getBaseDomainReference()->getId());

XIOS/trunk/src/node/node_enum.hpp

@@ -22 +22 @@
          eInverseAxis,
          eZoomAxis,
-         eInterpolateAxis
+         eInterpolateAxis,
+         eZoomDomain
 
       } ENodeType;

XIOS/trunk/src/node/node_type.hpp

@@ -13 +13 @@
 #include "zoom_axis.hpp"
 #include "interpolate_axis.hpp"
+#include "zoom_domain.hpp"
 
 #endif // __XIOS_NODE_TYPE__

XIOS/trunk/src/node/transformation_enum.hpp

@@ -9 +9 @@
         TRANS_ZOOM_AXIS,
         TRANS_INVERSE_AXIS,
-        TRANS_INTERPOLATE_AXIS
+        TRANS_INTERPOLATE_AXIS,
+        TRANS_ZOOM_DOMAIN
       } ETranformationType;
 

XIOS/trunk/src/object_factory_decl.cpp

@@ -27 +27 @@
   macro(CZoomAxis)
   macro(CInterpolateAxis)
+  macro(CZoomDomain)
 
   macro(CFieldGroup)
@@ -38 +39 @@
   macro(CZoomAxisGroup)
   macro(CInterpolateAxisGroup)
+  macro(CZoomDomainGroup)
 }

XIOS/trunk/src/object_template_decl.cpp

@@ -12 +12 @@
 #include "zoom_axis.hpp"
 #include "interpolate_axis.hpp"
+#include "zoom_domain.hpp"
 
 namespace xios
@@ -26 +27 @@
   template class CObjectTemplate<CZoomAxis>;
   template class CObjectTemplate<CInterpolateAxis>;
+  template class CObjectTemplate<CZoomDomain>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -37 +39 @@
   template class CObjectTemplate<CZoomAxisGroup>;
   template class CObjectTemplate<CInterpolateAxisGroup>;
+  template class CObjectTemplate<CZoomDomainGroup>;
 }

XIOS/trunk/src/output/nc4_data_output.cpp

@@ -250 +250 @@
               case (ONE_FILE) :
               {
-                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni.getValue());
-                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue());
+                 SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni);
+                 SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj);
 
                  if (domain->hasBounds)
@@ -322 +322 @@
                      else
                      {
-                       start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
+                       start[1]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
+                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
                        count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
                      }
@@ -339 +340 @@
                        count[0]=0 ;
                        SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
-                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 }
+                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
+                     }
                      else
                      {
-                       start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
+                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
                        count[0]=domain->zoom_nj_srv ;
                        CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
                        SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
 
-                       start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ;
+                       start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
                        count[0]=domain->zoom_ni_srv ;
                        CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
@@ -368 +370 @@
                    {
                      start[2] = 0;
-                     start[1] = domain->zoom_ibegin_srv - domain->zoom_ibegin.getValue();
-                     start[0] = domain->zoom_jbegin_srv - domain->zoom_jbegin.getValue();
+                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
+                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
                      count[2] = domain->nvertex;
                      count[1] = domain->zoom_ni_srv;
@@ -391 +393 @@
                    else
                    {
-                     start[1] = domain->zoom_ibegin_srv - domain->zoom_ibegin.getValue();
-                     start[0] = domain->zoom_jbegin_srv - domain->zoom_jbegin.getValue();
+                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
+                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
                      count[1] = domain->zoom_ni_srv;
                      count[0] = domain->zoom_nj_srv;
@@ -554 +556 @@
                  else
                  {
-                   start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;
+                   start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
                    count[0]=domain->zoom_nj_srv ;
-                   startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;
+                   startBounds[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
                    startBounds[1]=0 ;
                    countBounds[0]=domain->zoom_nj_srv ;

XIOS/trunk/src/test/test_new_features.f90

@@ -124 +124 @@
 !  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

XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp

@@ -47 +47 @@
                                                                           int axisPositionInGrid,
                                                                           const std::vector<int>& gridDestGlobalDim,
+                                                                          const std::vector<int>& gridSrcGlobalDim,
                                                                           const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                                                           CArray<size_t,1>& globalIndexDestGrid,

XIOS/trunk/src/transformation/axis_algorithm_transformation.hpp

@@ -31 +31 @@
                                                         int axisPositionInGrid,
                                                         const std::vector<int>& gridDestGlobalDim,
+                                                        const std::vector<int>& gridSrcGlobalDim,
                                                         const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                                         CArray<size_t,1>& globalIndexDestGrid,

XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

@@ -21 +21 @@
                 then position of axis in grid is 2 (since a domain is considered to contain 2 elements (axis)
   \param[in] gridDestGlobalDim global size of each dimension of grid source (all dimension must have the same size except of the one on which transformation is performed)
+  \param[in] gridSrcGlobalDim dimension size of source grid (it should share the same size for all dimension, maybe except the domain on which transformation is performed)
   \param[in] globalIndexGridDestSendToServer global index of grid destination on the current client to send to server
   \param[in/out] globaIndexWeightFromDestToSource mapping between transformed global index of grid destination
@@ -27 +28 @@
 void CGenericAlgorithmTransformation::computeGlobalSourceIndex(int elementPositionInGrid,
                                                              const std::vector<int>& gridDestGlobalDim,
+                                                             const std::vector<int>& gridSrcGlobalDim,
                                                              const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                                              std::map<size_t, std::vector<std::pair<size_t,double> > >& globaIndexWeightFromDestToSource)
@@ -45 +47 @@
                                                    elementPositionInGrid,
                                                    gridDestGlobalDim,
+                                                   gridSrcGlobalDim,
                                                    globalIndexGridDestSendToServer,
                                                    globalIndexDestGrid,

XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

@@ -28 +28 @@
   void computeGlobalSourceIndex(int elementPositionInGrid,
                                 const std::vector<int>& gridDestGlobalDim,
+                                const std::vector<int>& gridSrcGlobalDim,
                                 const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                 std::map<size_t, std::vector<std::pair<size_t,double> > >& globaIndexWeightFromDestToSource);
@@ -51 +52 @@
                                                         int elementPositionInGrid,
                                                         const std::vector<int>& gridDestGlobalDim,
+                                                        const std::vector<int>& gridSrcGlobalDim,
                                                         const CArray<size_t,1>& globalIndexGridDestSendToServer,
                                                         CArray<size_t,1>& globalIndexDestGrid,

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -11 +11 @@
 #include "axis_algorithm_zoom.hpp"
 #include "axis_algorithm_interpolate.hpp"
+#include "domain_algorithm_zoom.hpp"
 #include "context.hpp"
 #include "context_client.hpp"
@@ -19 +20 @@
 CGridTransformation::CGridTransformation(CGrid* destination, CGrid* source)
 : gridSource_(source), gridDestination_(destination), originalGridSource_(source),
-  globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0), weightOfGlobalIndexOfOriginalGridSource_(0)
+  globalIndexOfCurrentGridSource_(0), globalIndexOfOriginalGridSource_(0), weightOfGlobalIndexOfOriginalGridSource_(0), algoTypes_()
 {
   //Verify the compatibity between two grids
@@ -105 +106 @@
 void CGridTransformation::initializeAlgorithms()
 {
-  initializeAxisAlgorithms();
-  initializeDomainAlgorithms();
-}
+  std::vector<int> axisPositionInGrid;
+  std::vector<int> domPositionInGrid;
+  std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
+  std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
+
+  int idx = 0;
+  for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i)
+  {
+    if (false == (gridDestination_->axis_domain_order)(i))
+    {
+      axisPositionInGrid.push_back(idx);
+      ++idx;
+    }
+    else
+    {
+      ++idx;
+      domPositionInGrid.push_back(idx);
+      ++idx;
+    }
+  }
+
+  for (int i = 0; i < axisListDestP.size(); ++i)
+  {
+    elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i;
+  }
+
+  for (int i = 0; i < domListDestP.size(); ++i)
+  {
+    elementPosition2DomainPositionInGrid_[domPositionInGrid[i]] = i;
+  }
+
+  idx = 0;
+  for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i)
+  {
+    if (false == (gridDestination_->axis_domain_order)(i))
+    {
+      initializeAxisAlgorithms(idx);
+      ++idx;
+    }
+    else
+    {
+      ++idx;
+      initializeDomainAlgorithms(idx);
+      ++idx;
+    }
+  }
+}
+
+
 
 /*!
@@ -114 +161 @@
 In general, each axis can have several transformations performed on itself. However, should they be done seperately or combinely (of course in order)?
 For now, one approach is to do these combinely but maybe this needs changing.
-*/
-void CGridTransformation::initializeAxisAlgorithms()
-{
-  std::vector<int> axisPositionInGrid;
+\param [in] axisPositionInGrid position of an axis in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2)
+*/
+void CGridTransformation::initializeAxisAlgorithms(int axisPositionInGrid)
+{
   std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
-  std::vector<CAxis*> axisListSrcP = gridSource_->getAxis();
   if (!axisListDestP.empty())
   {
-    int idx = 0;
-    for (int i = 0; i < gridDestination_->axis_domain_order.numElements(); ++i)
-    {
-      if (false == (gridDestination_->axis_domain_order)(i))
+    if (axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->hasTransformation())
+    {
+      CAxis::TransMapTypes trans = axisListDestP[elementPosition2AxisPositionInGrid_[axisPositionInGrid]]->getAllTransformations();
+      CAxis::TransMapTypes::const_iterator itb = trans.begin(), it,
+                                           ite = trans.end();
+      int transformationOrder = 0;
+      for (it = itb; it != ite; ++it)
       {
-        axisPositionInGrid.push_back(idx);
-        ++idx;
+        listAlgos_.push_back(std::make_pair(axisPositionInGrid, std::make_pair(it->first, transformationOrder)));
+        algoTypes_.push_back(false);
+        ++transformationOrder;
       }
-      else idx += 2;
-    }
-
-    for (int i = 0; i < axisListDestP.size(); ++i)
-    {
-      elementPosition2AxisPositionInGrid_[axisPositionInGrid[i]] = i;
-      if (axisListDestP[i]->hasTransformation())
+    }
+  }
+}
+
+/*!
+  Initialize the algorithms corresponding to transformation info contained in each domain.
+If a domain has transformations, they will be represented in form of vector of CTransformation pointers
+In general, each domain can have several transformations performed on itself.
+\param [in] domPositionInGrid position of a domain in grid. (for example: a grid with one domain and one axis, position of domain is 1, position of axis is 2)
+*/
+void CGridTransformation::initializeDomainAlgorithms(int domPositionInGrid)
+{
+  std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
+  if (!domListDestP.empty())
+  {
+    if (domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->hasTransformation())
+    {
+      CDomain::TransMapTypes trans = domListDestP[elementPosition2DomainPositionInGrid_[domPositionInGrid]]->getAllTransformations();
+      CDomain::TransMapTypes::const_iterator itb = trans.begin(), it,
+                                             ite = trans.end();
+      int transformationOrder = 0;
+      for (it = itb; it != ite; ++it)
       {
-        CAxis::TransMapTypes trans = axisListDestP[i]->getAllTransformations();
-        CAxis::TransMapTypes::const_iterator itb = trans.begin(), it,
-                                             ite = trans.end();
-        int transformationOrder = 0;
-        for (it = itb; it != ite; ++it)
-        {
-          listAlgos_.push_back(std::make_pair(axisPositionInGrid[i], std::make_pair(it->first, transformationOrder)));
-          ++transformationOrder;
-        }
+        listAlgos_.push_back(std::make_pair(domPositionInGrid, std::make_pair(it->first, transformationOrder)));
+        algoTypes_.push_back(true);
+        ++transformationOrder;
       }
     }
   }
-}
-
-void CGridTransformation::initializeDomainAlgorithms()
-{
 
 }
@@ -163 +218 @@
   \param [in] transType transformation type, for now we have Zoom_axis, inverse_axis
   \param [in] transformationOrder position of the transformation in an element (an element can have several transformation)
-*/
-void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
-{
-   selectAxisAlgo(elementPositionInGrid, transType, transformationOrder);
+  \param [in] isDomainAlgo flag to specify type of algorithm (for domain or axis)
+*/
+void CGridTransformation::selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, bool isDomainAlgo)
+{
+   if (isDomainAlgo) selectDomainAlgo(elementPositionInGrid, transType, transformationOrder);
+   else selectAxisAlgo(elementPositionInGrid, transType, transformationOrder);
 }
 
@@ -219 +276 @@
 void CGridTransformation::selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder)
 {
+  std::vector<CDomain*> domainListDestP = gridDestination_->getDomains();
+  std::vector<CDomain*> domainListSrcP = gridSource_->getDomains();
+
+  int domainIndex =  elementPosition2DomainPositionInGrid_[elementPositionInGrid];
+  CDomain::TransMapTypes trans = domainListDestP[domainIndex]->getAllTransformations();
+  CDomain::TransMapTypes::const_iterator it = trans.begin();
+
+  for (int i = 0; i < transformationOrder; ++i, ++it) {}  // Find the correct transformation
+
+  CZoomDomain* zoomDomain = 0;
+  CGenericAlgorithmTransformation* algo = 0;
+  switch (transType)
+  {
+    case TRANS_ZOOM_DOMAIN:
+      zoomDomain = dynamic_cast<CZoomDomain*> (it->second);
+      algo = new CDomainAlgorithmZoom(domainListDestP[domainIndex], domainListSrcP[domainIndex], zoomDomain);
+      break;
+    default:
+      break;
+  }
+  algoTransformation_.push_back(algo);
 }
 
@@ -233 +311 @@
   std::vector<CAxis*> axisListSrcP = gridSource_->getAxis();
 
-  int axisIndex;
+  std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
+  std::vector<CDomain*> domListSrcP = gridSource_->getDomains();
+
+  int axisIndex, domainIndex;
   switch (transType)
   {
+    case TRANS_ZOOM_DOMAIN:
+      domainIndex = elementPosition2DomainPositionInGrid_[elementPositionInGrid];
+      domListSrcP[domainIndex]->duplicateAttributes(domListDestP[domainIndex]);
+      break;
+
     case TRANS_INTERPOLATE_AXIS:
     case TRANS_ZOOM_AXIS:
@@ -272 +358 @@
 
     // First of all, select an algorithm
-    selectAlgo(elementPositionInGrid, transType, transformationOrder);
+    selectAlgo(elementPositionInGrid, transType, transformationOrder, algoTypes_[std::distance(itb, it)]);
     algo = algoTransformation_.back();
 
@@ -281 +367 @@
     // ComputeTransformation of global index of each element
     std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
+    std::vector<int> gridSrcDimensionSize = gridSource_->getGlobalDimension();
     int elementPosition = it->first;
     algo->computeGlobalSourceIndex(elementPosition,
                                    gridDestinationDimensionSize,
+                                   gridSrcDimensionSize,
                                    globalIndexGridDestSendToServer,
                                    globaIndexWeightFromDestToSource);

XIOS/trunk/src/transformation/grid_transformation.hpp

@@ -46 +46 @@
   void computeTransformation();
   void initializeAlgorithms();
-  void initializeAxisAlgorithms();
-  void initializeDomainAlgorithms();
+  void initializeAxisAlgorithms(int axisPositionInGrid);
+  void initializeDomainAlgorithms(int domPositionInGrid);
   void initializeMappingOfOriginalGridSource();
 
   void selectAxisAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
   void selectDomainAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
-  void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder);
+  void selectAlgo(int elementPositionInGrid, ETranformationType transType, int transformationOrder, bool isDomainAlgo);
   void setUpGrid(int elementPositionInGrid, ETranformationType transType);
   void computeFinalTransformationMapping();
@@ -78 +78 @@
   //! List of algorithm types and their order
   ListAlgoType listAlgos_;
+  // true if domain algorithm and false if axis algorithm (can be replaced by tuple with listAlgos_
+  std::vector<bool> algoTypes_;
 
   // Mapping between position of an element in grid and its transformation (if any)

XIOS/trunk/src/type/type_util.hpp

@@ -26 +26 @@
     class CInterpolateAxis;
     class CInterpolateAxisGroup;
+    class CZoomDomain;
+    class CZoomDomainGroup;
 
   template <typename T> inline string getStrType(void);
@@ -68 +70 @@
   macro(CInterpolateAxis)
   macro(CInterpolateAxisGroup)
+  macro(CZoomDomain)
+  macro(CZoomDomainGroup)
 #undef macro
 }

XIOS/trunk/src/xml_parser_decl.cpp

@@ -7 +7 @@
 #include "file.hpp"
 #include "variable.hpp"
-//#include "transformation.hpp"
 #include "inverse_axis.hpp"
 #include "zoom_axis.hpp"
 #include "interpolate_axis.hpp"
+#include "zoom_domain.hpp"
 
 namespace xios
@@ -31 +31 @@
     macro( ZoomAxis )
     macro( InterpolateAxis )
+    macro( ZoomDomain )
   }
 }