Changeset 623

Timestamp:

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

Author:

mhnguyen

Message:

Implementing transformation algorithm: zoom axis (local commit)

+) Implement zoom axis: zoomed points are points not masked
+) Correct some minor bugs

Test
+) Ok with normal cases: zoom in the last of transformation list
+) There is still a bug in case of zoom then inverse

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (3 diffs)
• src/attribute_map.cpp (modified) (1 diff)
• src/attribute_map.hpp (modified) (1 diff)
• src/client_server_mapping_distributed.cpp (modified) (2 diffs)
• src/distribution_client.cpp (modified) (21 diffs)
• src/distribution_client.hpp (modified) (2 diffs)
• src/filter/axis_algorithm_inverse.cpp (moved) (moved from XIOS/trunk/src/filter/axis_inverse.cpp) (2 diffs)
• src/filter/axis_algorithm_inverse.hpp (moved) (moved from XIOS/trunk/src/filter/axis_inverse.hpp) (1 diff)
• src/filter/axis_algorithm_zoom.cpp (added)
• src/filter/axis_algorithm_zoom.hpp (moved) (moved from XIOS/trunk/src/filter/axis_zoom.hpp) (1 diff)
• src/filter/axis_zoom.cpp (deleted)
• src/filter/concrete_algo.hpp (deleted)
• src/filter/generic_algorithm_transformation.hpp (modified) (1 diff)
• src/filter/grid_transformation.cpp (modified) (16 diffs)
• src/filter/grid_transformation.hpp (modified) (3 diffs)
• src/filter/transformation_mapping.cpp (modified) (5 diffs)
• src/filter/transformation_mapping.hpp (modified) (1 diff)
• src/node/axis.cpp (modified) (7 diffs)
• src/node/axis.hpp (modified) (2 diffs)
• src/node/field.cpp (modified) (5 diffs)
• src/node/grid.cpp (modified) (3 diffs)
• src/node/grid.hpp (modified) (5 diffs)
• src/node/zoom_axis.cpp (modified) (2 diffs)
• src/output/nc4_data_output.cpp (modified) (2 diffs, 1 prop)
• src/test/test_new_features.f90 (modified) (3 diffs)
• src/utils.hpp (modified) (2 diffs)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -43 +43 @@
      <axis id="axis_E" axis_ref="axis_B">
         <inverse_axis />
-        <inverse_axis />
-<!--        <zoom_axis zoom_begin="1" zoom_size="3" />-->
+
+        <zoom_axis zoom_begin="0" zoom_size="4" />
+<!--        <inverse_axis />-->
      </axis>
      <axis id="axis_F" axis_ref="axis_A">
-       <inverse_axis />
+<!--       <inverse_axis />-->
      </axis>
    </axis_definition>
@@ -63 +64 @@
        <grid id="grid_Axis">
          <axis axis_ref="axis_D" />
+
        </grid>
        <grid id="grid_Two_Axis">
@@ -70 +72 @@
        <grid id="grid_Axis_tranformed">
 <!--         <domain domain_ref="domain_A" />-->
-<!--         <axis axis_ref="axis_E" />-->
          <axis axis_ref="axis_F" />
          <axis axis_ref="axis_E" />
-
        </grid>
        <grid id="grid_All_Axis">

XIOS/trunk/src/attribute_map.cpp

@@ -144 +144 @@
       }
 
+      void CAttributeMap::duplicateAttributes(const CAttributeMap* const srcAttr)
+      {
+         typedef std::pair<StdString, CAttribute*> StdStrAttPair;
+
+         SuperClassMap::const_iterator it = srcAttr->begin(), end = srcAttr->end();
+         for (; it != end; it++)
+         {
+            const StdStrAttPair& el = *it;
+            if (this->hasAttribute(el.first))
+            {
+               if (!el.second->isEmpty())
+               {
+                 this->setAttribute(el.first, el.second);
+               }
+            }
+         }
+      }
+
       //---------------------------------------------------------------
 /*

XIOS/trunk/src/attribute_map.hpp

@@ -30 +30 @@
             void setAttributes(const xml::THashAttributes & attributes);
             void setAttributes(const CAttributeMap * const _parent, bool apply=true);
-
+            void duplicateAttributes(const CAttributeMap* const _parent);
             void clearAllAttributes(void);
 

XIOS/trunk/src/client_server_mapping_distributed.cpp

@@ -37 +37 @@
    \param [in] localIndexOnClient local index on client
 */
-//void CClientServerMappingDistributed::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-//                                                                const CArray<int,1>& localIndexOnClient)
 void CClientServerMappingDistributed::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient)
 {
@@ -180 +178 @@
   }
 
-  if (0 != recvBuffIndexGlobal) delete recvBuffIndexGlobal;
-  if (0 != recvBuffIndexServer) delete recvBuffIndexServer;
+  if (0 != maxNbIndexDemandedFromOthers) delete [] recvBuffIndexGlobal;
+  if (0 != nbIndexReceivedFromOthers) delete [] recvBuffIndexServer;
   delete [] sendBuff;
   delete [] recvBuff;

XIOS/trunk/src/distribution_client.cpp

@@ -13 +13 @@
 CDistributionClient::CDistributionClient(int rank, int dims, CArray<size_t,1>* globalIndex)
    : CDistribution(rank, dims, globalIndex),
-   localDataIndex_(0), axisDomainOrder_(),
+   globalDataSendToServer_(0), localDataIndex_(0), localDataIndexSendToServer_(0), localMaskIndex_(0),
+   axisDomainOrder_(),
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
    gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_(),
-   isDataDistributed_(true), axisNum_(0), domainNum_(0), localDataIndexSendToServer_(0), nIndexDomain_(), nIndexAxis_()
+   isDataDistributed_(true), axisNum_(0), domainNum_(0), nIndexDomain_(), nIndexAxis_()
 {
 }
@@ -23 +24 @@
 CDistributionClient::CDistributionClient(int rank, CGrid* grid)
    : CDistribution(rank, 0, 0),
-   localDataIndex_(0), axisDomainOrder_(),
+   globalDataSendToServer_(0), localDataIndex_(0), localDataIndexSendToServer_(0), localMaskIndex_(0),
+   axisDomainOrder_(),
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
    gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_(),
-   isDataDistributed_(true), axisNum_(0), domainNum_(0), localDataIndexSendToServer_(0), nIndexDomain_(), nIndexAxis_()
+   isDataDistributed_(true), axisNum_(0), domainNum_(0), nIndexDomain_(), nIndexAxis_()
 {
   readDistributionInfo(grid);
@@ -39 +41 @@
   if (0 != localDataIndex_) delete localDataIndex_;
   if (0 != localDataIndexSendToServer_) delete localDataIndexSendToServer_;
+  if (0 != localMaskIndex_) delete localMaskIndex_;
 }
 
@@ -145 +148 @@
     axisMasks_[i].resize(axisList[i]->mask.numElements());
     axisMasks_[i] = axisList[i]->mask;
+    std::cout << "axisMask " << axisMasks_[i] << std::endl;
   }
 
@@ -197 +201 @@
       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]->zoom_jbegin;
+//      nZoomEnd_.at((indexMap_[idx]+1))   = domList[domIndex]->zoom_jbegin + domList[domIndex]->zoom_nj-1;
 
       dataBegin_.at(indexMap_[idx]+1) = (2 == domList[domIndex]->data_dim) ? domList[domIndex]->data_jbegin.getValue() : -1;
@@ -209 +213 @@
       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]->zoom_ibegin;
+//      nZoomEnd_.at((indexMap_[idx]))   = domList[domIndex]->zoom_ibegin + domList[domIndex]->zoom_ni-1;
 
       dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue();
@@ -229 +233 @@
       nBeginLocal_.at(indexMap_[idx]) = 0;
       nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->ibegin.getValue();
-      nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->zoom_begin;
-      nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->zoom_begin + axisList[axisIndex]->zoom_size-1;
+      nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin;
+      nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin + axisList[axisIndex]->global_zoom_size-1;
 
       dataBegin_.at(indexMap_[idx]) = axisList[axisIndex]->data_begin.getValue();
@@ -393 +397 @@
 
   //   Compute size of the global index on client
-  std::vector<int> idxLoop(numElement_,0);
-  std::vector<int> currentIndex(this->dims_);
+  std::vector<StdSize> idxLoop(numElement_,0);
+  std::vector<StdSize> currentIndex(this->dims_,0);
   int innerLoopSize = eachElementSize[0];
   size_t idx = 0, indexLocalDataOnClientCount = 0, indexSend2ServerCount = 0;
@@ -445 +449 @@
       else currentIndex[0]   = localAxisIndex_[idxAxis][i];
 
-      int gridMaskIndex = currentIndex[0];
+      StdSize gridMaskIndex = currentIndex[0];
       int mulDimMask = 1;
       for (int k = 1; k < this->dims_; ++k)
@@ -473 +477 @@
   localDataIndex_ = new CArray<int,1>(indexLocalDataOnClientCount);
   localDataIndexSendToServer_ = new CArray<int,1>(indexSend2ServerCount);
+  localMaskIndex_ = new CArray<int,1>(indexSend2ServerCount);
 
   // We need to loop with data index
@@ -481 +486 @@
   int countLocalData = 0;
   std::vector<int> correctOuterIndex(numElement_,0);
+  bool isOuterIndexCorrect = true;
   while (idx < ssize)
   {
@@ -490 +496 @@
         correctOuterIndex[i] = 0;
         ++idxLoop[i+1];
-        ++correctOuterIndex[i+1];
+        if (isOuterIndexCorrect) ++correctOuterIndex[i+1];
       }
     }
@@ -510 +516 @@
           currentIndex[indexMap_[i]]   = localDomainIndex_[idxDomain][correctOuterIndex[i]];
           currentIndex[indexMap_[i]+1] = localDomainIndex_[idxDomain*2+1][correctOuterIndex[i]];
+          isIndexDomainDataCorrect &= true;
         }
         else isIndexDomainDataCorrect = false;
@@ -519 +526 @@
         {
           currentIndex[indexMap_[i]]   = localAxisIndex_[idxAxis][correctOuterIndex[i]];
+          isIndexAxisDataCorrect &= true;
         }
         else isIndexAxisDataCorrect = false;
@@ -524 +532 @@
       }
     }
+
+    isOuterIndexCorrect = (isIndexAxisDataCorrect) && (isIndexDomainDataCorrect);
 
     // Inner most index
@@ -530 +540 @@
     for (int i = 0; i < innerLoopSize; ++i)
     {
+      bool isCurrentIndexDomainDataCorrect = isIndexDomainDataCorrect;
+      bool isCurrentIndexAxisDataCorrect = isIndexAxisDataCorrect;
+
       if (axisDomainOrder_(0))
       {
@@ -536 +549 @@
           currentIndex[0] = localDomainIndex_[idxDomain][correctIndexDomain];
           currentIndex[1] = localDomainIndex_[idxDomain+1][correctIndexDomain];
-          isIndexDomainDataCorrect = true;
+          isCurrentIndexDomainDataCorrect &= true;
           ++correctIndexDomain;
         }
-        else isIndexDomainDataCorrect = false;
+        else isCurrentIndexDomainDataCorrect = false;
       }
       else
@@ -546 +559 @@
         {
           currentIndex[0] = localAxisIndex_[idxAxis][correctIndexAxis];
-          isIndexAxisDataCorrect = true;
+          isCurrentIndexAxisDataCorrect &= true;
           ++correctIndexAxis;
         }
-        else isIndexAxisDataCorrect = false;
+        else isCurrentIndexAxisDataCorrect = false;
       }
 
@@ -560 +573 @@
       }
 
-      if (isIndexDomainDataCorrect &&
-          isIndexAxisDataCorrect &&
+      if (isCurrentIndexDomainDataCorrect &&
+          isCurrentIndexAxisDataCorrect &&
           gridMask_(gridMaskIndex))
       {
@@ -582 +595 @@
           (*this->globalDataSendToServer_)(indexSend2ServerCount) = globalIndex;
           (*localDataIndexSendToServer_)(indexSend2ServerCount) = indexLocalDataOnClientCount;
+          (*localMaskIndex_)(indexSend2ServerCount) = gridMaskIndex;
           ++indexSend2ServerCount;
         }
@@ -649 +663 @@
 
 /*!
+  Return local mask index of client
+*/
+const CArray<int,1>& CDistributionClient::getLocalMaskIndexOnClient() const
+{
+  return (*localMaskIndex_);
+}
+
+/*!
   Return local data index on client which are sent to servers
 */

XIOS/trunk/src/distribution_client.hpp

@@ -39 +39 @@
     virtual const CArray<int,1>& getLocalDataIndexSendToServer() const;
     const CArray<size_t,1>& getGlobalDataIndexSendToServer() const;
+    const CArray<int,1>& getLocalMaskIndexOnClient() const;
 
     std::vector<int> getNGlob() { return nGlob_; }
     std::vector<int> getDataNIndex() { return dataNIndex_; }
+
     bool isDataDistributed() { return isDataDistributed_; }
 
@@ -73 +75 @@
     CArray<int,1>* localDataIndex_;
     CArray<int,1>* localDataIndexSendToServer_;
+    CArray<int,1>* localMaskIndex_;
 
   private:

XIOS/trunk/src/filter/axis_algorithm_inverse.cpp

@@ -1 @@
-#include "axis_inverse.hpp"
+#include "axis_algorithm_inverse.hpp"
 
 namespace xios {
 
-CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)
+CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)
  : CAxisAlgorithmTransformation(axisDestination, axisSource)
 {
   if (axisDestination->size.getValue() != axisSource->size.getValue())
   {
-    ERROR("CAxisInverse::CAxisInverse(CAxis* axisDestination, CAxis* axisSource)",
+    ERROR("CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)",
            << "Two axis have different size"
            << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
@@ -19 +19 @@
   int ibeginDest = axisDestination->ibegin.getValue();
 
-  for (int idx = 0; idx < niDest; ++idx) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+  for (int idx = 0; idx < niDest; ++idx)
+    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
   this->computeIndexSourceMapping();
 }
 
-void CAxisInverse::computeIndexSourceMapping()
+void CAxisAlgorithmInverse::computeIndexSourceMapping()
 {
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;

XIOS/trunk/src/filter/axis_algorithm_inverse.hpp

@@ -7 +7 @@
 namespace xios {
 
-class CAxisInverse : public CAxisAlgorithmTransformation //public CConcreteAlgo
+class CAxisAlgorithmInverse : public CAxisAlgorithmTransformation
 {
 public:
-  CAxisInverse(CAxis* axisDestination, CAxis* axisSource);
+  CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource);
 
-  virtual ~CAxisInverse() {}
+  virtual ~CAxisAlgorithmInverse() {}
 
   virtual void computeIndexSourceMapping();

XIOS/trunk/src/filter/axis_algorithm_zoom.hpp

@@ -8 +8 @@
 namespace xios {
 
-class CAxisZoom : public CAxisAlgorithmTransformation
+class CAxisAlgorithmZoom : public CAxisAlgorithmTransformation
 {
 public:
-  CAxisZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis);
+  CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis);
 
-  virtual ~CAxisZoom() {}
+  virtual ~CAxisAlgorithmZoom() {}
 
   virtual void computeIndexSourceMapping();
 
+private:
+  void updateAxisDestinationMask();
+  void updateZoom();
 private:
   StdSize zoomBegin_;

XIOS/trunk/src/filter/generic_algorithm_transformation.hpp

@@ -20 +20 @@
                                 std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
 
-                                  /*!
+  /*!
   Compute global index mapping from one element of destination grid to the corresponding element of source grid
   */

XIOS/trunk/src/filter/grid_transformation.cpp

@@ +1 @@
+/*!
+   \file grid_transformation.cpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Interface for all transformations.
+ */
 #include "grid_transformation.hpp"
-#include "axis_inverse.hpp"
-#include "axis_zoom.hpp"
+#include "axis_algorithm_inverse.hpp"
+#include "axis_algorithm_zoom.hpp"
 #include "context.hpp"
 #include "context_client.hpp"
@@ -35 +43 @@
   {
     CAxis* axis = CAxis::createAxis();
-    axisSrcTmp[idx]->duplicateAttributes(axis);
+    axis->setAttributes(axisSrcTmp[idx]);
     axisSrc.push_back(axis);
   }
@@ -42 +50 @@
   {
     CDomain* domain = CDomain::createDomain();
-    domainSrcTmp[idx]->duplicateAttributes(domain);
+    domain->setAttributes(domainSrcTmp[idx]);
     domainSrc.push_back(domain);
   }
@@ -168 +176 @@
     case TRANS_ZOOM_AXIS:
       zoomAxis = dynamic_cast<CZoomAxis*> (it->second);
-      algo = new CAxisZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
+      algo = new CAxisAlgorithmZoom(axisListDestP[axisIndex], axisListSrcP[axisIndex], zoomAxis);
       break;
     case TRANS_INVERSE_AXIS:
-      algo = new CAxisInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
+      algo = new CAxisAlgorithmInverse(axisListDestP[axisIndex], axisListSrcP[axisIndex]);
       break;
     default:
@@ -196 +204 @@
     case TRANS_INVERSE_AXIS:
       axisIndex =  elementPosition2AxisPositionInGrid_[elementPositionInGrid];
-      axisListDestP[axisIndex]->duplicateAttributes(axisListSrcP[axisIndex]);
+      axisListSrcP[axisIndex]->duplicateAttributes(axisListDestP[axisIndex]);
       break;
     default:
@@ -226 +234 @@
     const CArray<size_t,1>& globalIndexGridDestSendToServer = distributionClientDest.getGlobalDataIndexSendToServer();
 
+   std::cout << "global index grid  dest send to server " << globalIndexGridDestSendToServer << std::endl;
     // ComputeTransformation of global index of each element
     std::vector<int> gridDestinationDimensionSize = gridDestination_->getGlobalDimension();
@@ -241 +250 @@
   }
 
- std::cout << "global index destination 0 " << *globalIndexOfCurrentGridSource_ << std::endl;
- std::cout << "global index destination 1 " << *globalIndexOfOriginalGridSource_ << std::endl;
+ std::cout << "global index destination 0 final " << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 final " << *globalIndexOfOriginalGridSource_ << std::endl;
+  updateFinalGridDestination();
   computeFinalTransformationMapping();
 }
@@ -248 +258 @@
 
 /*!
-  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.
+  After applying the algorithms, there are some informations on grid destination needing change, for now, there are:
+   +) mask
 */
-void CGridTransformation::computeTransformation()
-{
-//  const CArray<size_t,1>& globalIndexGridDestSendToServer = gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
-//  std::list<std::pair<int,CGenericAlgorithmTransformation*> >::const_iterator itbMap, itMap, iteMap;
-//  itbMap = algoTransformation_.begin();
-//  iteMap = algoTransformation_.end();
-//
-//  std::vector<CGenericAlgorithmTransformation*>::const_iterator itbVec, itVec, iteVec;
-//
-//  for (itMap = itbMap; itMap != iteMap; ++itMap)
-//  {
-//    int elementPosition = itMap->first;
-//    itbVec = (itMap->second).begin();
-//    iteVec = (itMap->second).end();
-//    for (itVec = itbVec; itVec != iteVec; ++itVec)
-//    {
-//      (*itVec)->computeGlobalSourceIndex(elementPosition,
-//                                         gridDestinationDimensionSize_,
-//                                         globalIndexGridDestSendToServer,
-//                                         globaIndexMapFromDestToSource_);
-//    }
-//  }
+void CGridTransformation::updateFinalGridDestination()
+{
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  //First of all, retrieve info of local mask of grid destination
+  CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
+  const CArray<int, 1>& localMaskIndexOnClientDest = distributionClientDest.getLocalMaskIndexOnClient();
+  std::cout << "local mask " << localMaskIndexOnClientDest << std::endl;
+
+  const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer();
+  std::cout << "global index " << globalIndexOnClientDest <<  std::endl;
+  CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr;
+  itbArr = globalIndexOnClientDest.begin();
+  iteArr = globalIndexOnClientDest.end();
+
+  // Then find out which index became invalid (become masked after being applied the algorithms, or demande some masked points from grid source)
+  int num = globalIndexOfOriginalGridSource_->numElements();
+  const size_t sfmax = NumTraits<unsigned long>::sfmax();
+  int maskIndexNum = 0;
+  for (int idx = 0; idx < num; ++idx)
+  {
+    if (sfmax == (*globalIndexOfOriginalGridSource_)(idx))
+    {
+      size_t maskedGlobalIndex = (*globalIndexOfCurrentGridSource_)(idx);
+      itArr = std::find(itbArr, iteArr, maskedGlobalIndex);
+      if (iteArr != itArr) ++maskIndexNum;
+    }
+  }
+
+  CArray<int,1>* maskIndexToModify = new CArray<int,1>(maskIndexNum);
+  maskIndexNum = 0;
+  for (int idx = 0; idx < num; ++idx)
+  {
+    if (sfmax == (*globalIndexOfOriginalGridSource_)(idx))
+    {
+      size_t maskedGlobalIndex = (*globalIndexOfCurrentGridSource_)(idx);
+      itArr = std::find(itbArr, iteArr, maskedGlobalIndex);
+      if (iteArr != itArr)
+      {
+        int localIdx = std::distance(itbArr, itArr);
+        (*maskIndexToModify)(maskIndexNum) = (localMaskIndexOnClientDest)(localIdx);
+        ++maskIndexNum;
+      }
+    }
+  }
+
+  std::cout << "index to modify " << *maskIndexToModify << std::endl;
+  gridDestination_->modifyMask(*maskIndexToModify);
+
+  delete maskIndexToModify;
 }
 
@@ -302 +340 @@
  for (itSend = itbSend; itSend != iteSend; ++itSend) sendBuffSize += (itSend->second).size();
 
+ std::cout << "global index destination 0 before" << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 before" << *globalIndexOfOriginalGridSource_ << std::endl;
+
+ typedef unsigned long Scalar;
  unsigned long* sendBuff, *currentSendBuff;
  if (0 != sendBuffSize) sendBuff = new unsigned long [sendBuffSize];
+ for (StdSize idx = 0; idx < sendBuffSize; ++idx) sendBuff[idx] = NumTraits<Scalar>::sfmax();
+
  int currentBuffPosition = 0;
  for (itSend = itbSend; itSend != iteSend; ++itSend)
@@ -332 +376 @@
  unsigned long* recvBuff, *currentRecvBuff;
  if (0 != recvBuffSize) recvBuff = new unsigned long [recvBuffSize];
+ for (StdSize idx = 0; idx < recvBuffSize; ++idx) recvBuff[idx] = NumTraits<Scalar>::sfmax();
+
  int currentRecvBuffPosition = 0;
  for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
@@ -353 +399 @@
  }
 
- globalIndexOfCurrentGridSource_->resize(nbCurrentGridSource);
- globalIndexOfOriginalGridSource_->resize(nbCurrentGridSource);
+ if (globalIndexOfCurrentGridSource_->numElements()  != nbCurrentGridSource)
+ {
+   if ((0 != nbCurrentGridSource) && (0 != globalIndexOfCurrentGridSource_))
+   {
+     delete globalIndexOfCurrentGridSource_;
+     globalIndexOfCurrentGridSource_ = new CArray<size_t,1>(nbCurrentGridSource);
+   }
+ }
+
+ if (globalIndexOfOriginalGridSource_->numElements() != nbCurrentGridSource)
+ {
+   if ((0 != nbCurrentGridSource) && (0 != globalIndexOfOriginalGridSource_))
+   {
+     delete globalIndexOfOriginalGridSource_;
+     globalIndexOfOriginalGridSource_ = new CArray<size_t,1>(nbCurrentGridSource);
+   }
+ }
+
  int k = 0;
  currentRecvBuff = recvBuff;
@@ -372 +434 @@
  }
 
+ std::cout << "global index destination 0 after " << *globalIndexOfCurrentGridSource_ << std::endl;
+ std::cout << "global index destination 1 after " << *globalIndexOfOriginalGridSource_ << std::endl;
  if (0 != sendBuffSize) delete [] sendBuff;
  if (0 != recvBuffSize) delete [] recvBuff;
@@ -391 +455 @@
 
   int nb = globalIndexOfCurrentGridSource_->numElements();
+  const size_t sfmax = NumTraits<unsigned long>::sfmax();
   for (int idx = 0; idx < nb; ++idx)
   {
-    globaIndexMapFromDestToSource[(*globalIndexOfCurrentGridSource_)(idx)].insert((*globalIndexOfOriginalGridSource_)(idx));
+    if (sfmax != (*globalIndexOfOriginalGridSource_)(idx))
+      globaIndexMapFromDestToSource[(*globalIndexOfCurrentGridSource_)(idx)].insert((*globalIndexOfOriginalGridSource_)(idx));
   }
 
@@ -403 +469 @@
 
   CDistributionClient distributionClientDest(client->clientRank, gridDestination_);
-  CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
-
-  CArray<int, 1> localIndexOnClientDest = distributionClientDest.getLocalDataIndexOnClient(); //gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); //gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  CDistributionClient distributionClientSrc(client->clientRank, originalGridSource_);
+
+//  const CArray<int, 1>& localIndexOnClientDest = distributionClientDest.getLocalDataIndexOnClient(); //gridDestination_->getDistributionClient()->getLocalDataIndexOnClient();
+  const CArray<int, 1>& localIndexOnClientDest = distributionClientDest.getLocalDataIndexSendToServer();
+  const CArray<size_t,1>& globalIndexOnClientDest = distributionClientDest.getGlobalDataIndexSendToServer(); //gridDestination_->getDistributionClient()->getGlobalDataIndexSendToServer();
 
  std::cout << "dest: local index " << localIndexOnClientDest << std::endl;
  std::cout << "dest: global index " << globalIndexOnClientDest << std::endl;
-  CArray<int, 1> localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); //gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
-  CArray<size_t,1> globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  const CArray<int, 1>& localIndexOnClientSrc = distributionClientSrc.getLocalDataIndexOnClient(); //gridSource_->getDistributionClient()->getLocalDataIndexOnClient();
+  const CArray<size_t,1>& globalIndexOnClientSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
  std::cout << "src: local index " << localIndexOnClientSrc << std::endl;
  std::cout << "src: global index " << globalIndexOnClientSrc << std::endl;
   std::vector<size_t>::const_iterator itbVec, itVec, iteVec;
-  CArray<size_t, 1>::iterator itbArr, itArr, iteArr;
+  CArray<size_t, 1>::const_iterator itbArr, itArr, iteArr;
 
   std::map<int,std::vector<std::vector<size_t> > >::const_iterator itbMapRecv, itMapRecv, iteMapRecv;
@@ -439 +506 @@
         {
           int localIdx = std::distance(itbArr, itArr);
-//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
-          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
+          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = localIndexOnClientDest(localIdx); // Local index of un-extracted data (only domain)
+//          (*localIndexToReceiveOnGridDest_[sourceRank][i])(idx) = (localIdx); // Local index of extracted data
         }
       }
     }
+//    std::cout << "local index to receive from source Rank = " << sourceRank << (*localIndexToReceiveOnGridDest_[sourceRank][i]) << std::endl;
   }
 
@@ -468 +536 @@
       }
     }
+    std::cout << "local index to send to dest Rank = " << destRank << (*localIndexToSendFromGridSource_[destRank]) << std::endl;
   }
 }

XIOS/trunk/src/filter/grid_transformation.hpp

@@ +1 @@
+/*!
+   \file grid_transformation.hpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Interface for all transformations.
+ */
 #ifndef __XIOS_GRID_TRANSFORMATION_HPP__
 #define __XIOS_GRID_TRANSFORMATION_HPP__
@@ -12 +20 @@
 class CGrid;
 
+/*!
+  \class CGridTransformation
+  This class is an interface for all transformations to interact with the rest of XIOS.
+The class, firstly, tries to get all information relating to requested transformations by retrieving directly from grid.
+Then with all these information, all necessary transformations will be be created by generic class \class CGenericAlgorithmTransformation.
+Because there are information exchange among clients to accomplish the transformations (e.g: some index need retrieving from other clients),
+this class uses class \class CTransformationMapping to fulfill this demand.
+For each transformation, a new temporary grid source is created.
+For a consequential transformations (e.g: inversing -> zoom -> inversing -> ...),
+the grid destination of current transformation will be grid source of the next transformation
+*/
 class CGridTransformation
 {
@@ -38 +57 @@
   void computeFinalTransformationMapping();
   void computeTransformationFromOriginalGridSource(const std::map<size_t, std::set<size_t> >& globaIndexMapFromDestToSource);
+  void updateFinalGridDestination();
 
 private:
+  //! Grid source on transformation
   CGrid* gridSource_;
+
+  //! Grid destination on transformation
   CGrid* gridDestination_;
+
+  //! The grid source of the first transformation (original grid source)
   CGrid* originalGridSource_;
 
+  //! Grid source dimension size
   std::vector<int> gridSourceDimensionSize_;
+
+  //! Grid destination dimension size
   std::vector<int> gridDestinationDimensionSize_;
 
 private:
   typedef std::list<std::pair<int,std::pair<ETranformationType,int> > > ListAlgoType;
+  //! List of algorithm types and their order
+  ListAlgoType listAlgos_;
 
   // Mapping between position of an element in grid and its transformation (if any)
   std::list<CGenericAlgorithmTransformation*> algoTransformation_;
-  ListAlgoType listAlgos_;
+
+  //! Mapping of (grid) global index representing tranformation.
   std::map<size_t, std::set<size_t> > globaIndexMapFromDestToSource_;
 
+  //! Local index of data to send from grid source
   std::map<int, CArray<int,1>* > localIndexToSendFromGridSource_;
+
+  //! Local index of data to receive on grid destination
   std::map<int, std::vector<CArray<int,1>* > > localIndexToReceiveOnGridDest_;
 
+  //! Position of axis and domain in grid
   std::map<int, int> elementPosition2AxisPositionInGrid_, elementPosition2DomainPositionInGrid_;
 
+  //! (Grid) Global index of grid source
   CArray<size_t,1>* globalIndexOfCurrentGridSource_;
   CArray<size_t,1>* globalIndexOfOriginalGridSource_;

XIOS/trunk/src/filter/transformation_mapping.cpp

@@ +1 @@
+/*!
+   \file transformation_mapping.cpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Take charge of communication among clients to exchange transformed data.
+ */
+
 #include "transformation_mapping.hpp"
 #include <boost/unordered_map.hpp>
@@ -14 +23 @@
   int clientRank = client->clientRank;
 
-  CDistributionClient distributionClientDest(client->clientRank, gridSource_);
+  CDistributionClient distributionClientSrc(client->clientRank, gridSource_);
 
-  const CArray<size_t,1>& globalIndexGridSrc = distributionClientDest.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
+  const CArray<size_t,1>& globalIndexGridSrc = distributionClientSrc.getGlobalDataIndexSendToServer(); //gridSource_->getDistributionClient()->getGlobalDataIndexSendToServer();
   boost::unordered_map<size_t,int> globalIndexOfServer;
   int globalIndexSize = globalIndexGridSrc.numElements();
@@ -24 +33 @@
   }
 
+  std::cout << "global index grid src " << globalIndexGridSrc << std::endl;
   gridIndexClientClientMapping_ = new CClientServerMappingDistributed(globalIndexOfServer,
                                                                       client->intraComm,
@@ -151 +161 @@
 }
 
+/*!
+  Return (grid) global index on grid destination. This mapping contains the rank of client source (that sends info to grid destination)
+and the corresponding global index to write on grid destination.
+  \return global index mapping to receive on grid destination
+*/
 const std::map<int,std::vector<std::vector<size_t> > >& CTransformationMapping::getGlobalIndexReceivedOnGridDestMapping() const
 {
@@ -156 +171 @@
 }
 
+/*!
+  Return (grid) global index on grid source. This mapping contains the rank of client destination (which receives transformation info) and
+the corresponding global index to send
+  \return global index mapping to send on grid source
+*/
 const std::map<int,std::vector<size_t> >& CTransformationMapping::getGlobalIndexSendToGridDestMapping() const
 {

XIOS/trunk/src/filter/transformation_mapping.hpp

@@ +1 @@
+/*!
+   \file transformation_mapping.hpp
+   \author Ha NGUYEN
+   \since 14 May 2015
+   \date 09 June 2015
+
+   \brief Take charge of communication among clients to exchange transformed data.
+ */
 #ifndef __XIOS_TRANSFORMATION_MAPPING_HPP__
 #define __XIOS_TRANSFORMATION_MAPPING_HPP__

XIOS/trunk/src/node/axis.cpp

@@ -18 +18 @@
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
       , isDistributed_(false)
-      , transformationMap_()
+      , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
    {
    }
@@ -26 +26 @@
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
       , isDistributed_(false)
-      , transformationMap_()
+      , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
    {
    }
@@ -67 +67 @@
      CAxis* axis = CAxisGroup::get("axis_definition")->createChild();
      return axis;
-   }
-
-   void CAxis::duplicateAttributes(CAxis* axis)
-   {
-     axis->setAttributes(this);
    }
 
@@ -101 +96 @@
       else this->ni.setValue(size);
       std::cout <<  "value " <<  value <<  std::endl;
-      StdSize true_size = value.numElements();
-      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");
-
+//      StdSize true_size = value.numElements();
+//      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");
+
+      if (0 == global_zoom_size) global_zoom_size = size;
       this->checkData();
       this->checkMask();
-      this->checkZoom();
+//      this->checkZoom();
 
       if (!bounds.isEmpty())
@@ -281 +277 @@
         msg << this->getId();
         msg << ni << begin << end;
+        msg<<global_zoom_begin<<global_zoom_size;
 
         event.push(*itRank,1,msg);
@@ -299 +296 @@
   void CAxis::recvServerAttribut(CBufferIn& buffer)
   {
-    int zoom_end = zoom_begin.getValue()+zoom_size.getValue()-1;
-    int ni_srv, begin_srv, end_srv;
-
-    buffer>>ni_srv>>begin_srv>>end_srv;
-
-    zoom_begin_srv = zoom_begin.getValue() > begin_srv ? zoom_begin.getValue() : begin_srv;
-    zoom_end_srv   = zoom_end < end_srv ? zoom_end : end_srv;
+    int ni_srv, begin_srv, end_srv, global_zoom_begin_tmp, global_zoom_size_tmp;
+
+    buffer>>ni_srv>>begin_srv>>end_srv>>global_zoom_begin_tmp>>global_zoom_size_tmp;
+    global_zoom_begin = global_zoom_begin_tmp;
+    global_zoom_size  = global_zoom_size_tmp;
+    int global_zoom_end = global_zoom_begin + global_zoom_size - 1;
+
+    zoom_begin_srv = global_zoom_begin > begin_srv ? global_zoom_begin : begin_srv ;
+    zoom_end_srv   = global_zoom_end < end_srv ? global_zoom_end : end_srv ;
     zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
 
@@ -315 +314 @@
     if (size == ni)
     {
-      zoom_begin_srv = zoom_begin.getValue();
-      zoom_end_srv   = zoom_end;
+      zoom_begin_srv = global_zoom_begin;
+      zoom_end_srv   = global_zoom_end; //zoom_end;
       zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
     }

XIOS/trunk/src/node/axis.hpp

@@ -65 +65 @@
          /// Accesseurs ///
          const std::set<StdString> & getRelFiles(void) const;
-         void duplicateAttributes(CAxis* axis);
 
          /// Test ///
@@ -104 +103 @@
         int zoom_begin_srv, zoom_end_srv, zoom_size_srv;
         int ni_srv, begin_srv, end_srv;
-
+        int global_zoom_begin, global_zoom_size;  // The real global zoom begin and zoom size after axis is transformed (zoomed)
       private :
          void checkData();

XIOS/trunk/src/node/field.cpp

@@ -551 +551 @@
      }
      solveGridDomainAxisRef(doSending2Sever);
-     solveCheckMaskIndex(doSending2Sever);
      if (context->hasClient)
      {
        solveTransformedGrid();
      }
+     solveCheckMaskIndex(doSending2Sever);
    }
 
@@ -784 +784 @@
            fieldRef->addReference(this);
            fieldRef->solveGridDomainAxisRef(false);
-           fieldRef->solveCheckMaskIndex(false);
+//           fieldRef->solveCheckMaskIndex(false);
            break;
          }
@@ -798 +798 @@
          fieldRef->addReference(this);
          fieldRef->solveGridDomainAxisRef(false);
-         fieldRef->solveCheckMaskIndex(false);
+//         fieldRef->solveCheckMaskIndex(false);
        }
 
@@ -857 +857 @@
        CArray<int,1>* localIndex_p = itSend->second;
        int countSize = localIndex_p->numElements();
+       std::cout << "Data Source " <<  dataSrc <<  std::endl;
        for (int idx = 0; idx < countSize; ++idx)
        {
@@ -887 +888 @@
          }
        }
+       std::cout << "Data Destination " <<  dataDest <<  std::endl;
      }
 

XIOS/trunk/src/node/grid.cpp

@@ -298 +298 @@
       }
    }
+
+   void CGrid::modifyMask(const CArray<int,1>& indexToModify)
+   {
+      using namespace std;
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+
+      switch (dim) {
+        case 1:
+          modifyGridMask(mask1, indexToModify);
+          break;
+        case 2:
+          modifyGridMask(mask2, indexToModify);
+          break;
+        case 3:
+          modifyGridMask(mask3, indexToModify);
+          break;
+
+        default:
+          break;
+      }
+   }
+
    //---------------------------------------------------------------
 
@@ -850 +874 @@
             nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv;
             nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv;
-            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->zoom_begin;
+            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;
             nGlob[indexMap[i]] = axisList[axisId]->size;
             ++axisId;
@@ -1158 +1182 @@
     transformations_ = new CGridTransformation(transformedGrid, this);
     transformations_->computeAll();
+
+    // Ok, now need to compute index of grid source
+    checkMaskIndex(false);
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -190 +190 @@
          bool isTransformed();
          void setTransformed();
-//         EElementType getGridElementType();
-//
-//         std::vector<ETransformationType> getTransformations();
-//         const std::vector<CGenericAlgorithm*>& getTransformationAlgo();
 
       public:
@@ -210 +206 @@
          map<int, CArray<size_t, 1>* > outIndexFromClient;
          void checkMask(void) ;
+         void modifyMask(const CArray<int,1>& indexToModify);
 
       private:
@@ -217 +214 @@
                           const std::vector<CArray<bool,1>* >& axisMasks,
                           const CArray<bool,1>& axisDomainOrder);
+        template<int N>
+        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify);
+
         void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
         void setVirtualDomainGroup();
@@ -366 +366 @@
         maskIndex += idxLoop[k]*mulDim;
       }
-      *(gridMask.dataFirst()+maskIndex) = maskValue;
+      *(gridMask.dataFirst()+maskIndex) &= maskValue;
 
       ++idxLoop[0];
@@ -374 +374 @@
    }
 
+   /*!
+     Modify the current mask of grid, the local index to be modified will take value false
+     \param [in/out] gridMask current mask of grid
+     \param [in] indexToModify local index to modify
+   */
+   template<int N>
+   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify)
+   {
+     bool valueToModify = false;
+     int num = indexToModify.numElements();
+     for (int idx = 0; idx < num; ++idx)
+     {
+       *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
+     }
+   }
    ///--------------------------------------------------------------
 

XIOS/trunk/src/node/zoom_axis.cpp

@@ -25 +25 @@
   void CZoomAxis::checkValid(CAxis* axisDest)
   {
-    StdSize axisIBegin, axisNi, axisSize;
-    StdSize zoom_begin, zoom_end, zoom_size;
+    int axisIBegin, axisNi, axisSize;
+    int zoom_begin, zoom_end, zoom_size;
 
     axisIBegin = axisDest->ibegin.getValue();
@@ -36 +36 @@
     zoom_end   = (this->zoom_end.isEmpty()) ?  (axisSize - 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 ;
+    if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1;
+    if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1;
+    if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1;
 
     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))

XIOS/trunk/src/output/nc4_data_output.cpp

@@ -600 +600 @@
         int zoom_begin_srv = axis->zoom_begin_srv;
         int zoom_size  = (MULTI_FILE == SuperClass::type) ? zoom_size_srv : axis->zoom_size;
-        int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv : axis->zoom_begin;
+                                                              : axis->global_zoom_size;
+                                                              : axis->global_zoom_begin;
 
 
@@ -1361 +1362 @@
            if (!field->prec.isEmpty() && field->prec==2) fieldData=round(fieldData) ;
 
+           std::cout << "fieldData "<< fieldData << std::endl;
            switch (SuperClass::type)
            {

XIOS/trunk/src/test/test_new_features.f90

@@ -23 +23 @@
   TYPE(xios_file) :: file_hdl
   LOGICAL :: ok
+  LOGICAL,ALLOCATABLE :: mask_glo(:),mask(:)
 
   DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
@@ -81 +82 @@
 
   ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm), lvaln(nAxis), lval_ni(ni), lval_nj(nj), field_Two_Axis(ni_glo,1:nj))
+  ALLOCATE(mask(nj))
+  DO i = 1, nj
+!    IF (MOD(i,2)>=0) THEN
+!      mask(i)=.FALSE.
+!    ELSE
+      mask(i)=.TRUE.
+!    ENDIF
+  ENDDO
   lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
@@ -99 +108 @@
 
   CALL xios_set_axis_attr("axis_A", size=ni_glo, ibegin=ibegin, ni=ni, value=lval_ni)
-  CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj)
+  CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj, mask=mask)
   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=lvaln)

XIOS/trunk/src/utils.hpp

@@ -13 +13 @@
 
 #include <vector>
+#include <limits>
 #include "array_new.hpp"
 #include "exception.hpp"
@@ -187 +188 @@
     }
   };
+
+template<typename K>
+struct NumTraits {
+    typedef K Type;
+};
+
+template<>
+struct NumTraits<unsigned long>
+{
+  typedef unsigned long Scalar;
+  typedef Scalar magnitudeType;
+
+  static inline Scalar sfmin() {
+    return std::numeric_limits<Scalar>::min();
+  }
+  static inline Scalar sfmax() {
+    return std::numeric_limits<Scalar>::max();
+  }
+};
 }