Changeset 1202 for XIOS/dev

Timestamp:

07/10/17 15:16:17 (7 years ago)

Author:

mhnguyen

Message:

Porting non-continuous axis zoom to dev branch

+) Port axis zoom
+) Resolve some merge conflicts
+) Revert some codes

Test
+) On Curie
+) Ok

Location:

XIOS/dev/dev_olga

Files:

• inputs/iodef.xml (modified) (2 diffs)
• src/config/axis_attribute_private.conf (modified) (1 diff)
• src/distribution_server.cpp (modified) (2 diffs)
• src/distribution_server.hpp (modified) (1 diff)
• src/node/axis.cpp (modified) (17 diffs)
• src/node/axis.hpp (modified) (3 diffs)
• src/node/domain.cpp (modified) (8 diffs)
• src/node/grid.cpp (modified) (10 diffs)
• src/node/grid.hpp (modified) (1 diff)
• src/test/test_client.f90 (modified) (3 diffs)
• src/transformation/axis_algorithm_zoom.cpp (modified) (4 diffs)

XIOS/dev/dev_olga/inputs/iodef.xml

@@ -11 +11 @@
      <field id="field_Domain"  operation="average" freq_op="3600s" domain_ref="domain_A"/>
      <field id="field_A_zoom"  operation="average" freq_op="3600s" field_ref="field_A" grid_ref="grid_A_zoom"/>
+     <field id="field_Scalar"  operation="average" freq_op="3600s" grid_ref="grid_Scalar"/>
    </field_definition>
 
 
-   <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" enabled=".TRUE.">
-     <file id="output" name="output">
+   <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" enabled=".FALSE.">
+      <file id="output" name="output" enabled=".TRUE.">
         <!-- <field field_ref="field_Domain" name="field_A" /> -->
         <field field_ref="field_A" name="field_A" /> 
-        <field field_ref="field_A" name="field_B" />
+        <field field_ref="field_A_zoom" name="field_B" />
      </file>
-     <file id="output1" name="output1">
+     <file id="output1" name="output1" enabled=".TRUE.">
         <!-- <field field_ref="field_Domain" name="field_A" /> -->
         <field field_ref="field_A" name="field_A" />        
+     </file> 
+     <file id="output2" name="output2" enabled=".TRUE.">
+        <!-- <field field_ref="field_Domain" name="field_A" /> -->
+        <field field_ref="field_Scalar" name="field_A" />        
      </file>
+ <!--     <file id="output_s" name="output_s" mode="read" >
+       <field id="field" name="field_A" grid_ref="grid_Scalar" operation="instant" />
+     </file> -->
    </file_definition>
 
+  <scalar_defintion>
+    <scalar id="scalar_A"/>
+  </scalar_defintion>
 
    <axis_definition>
      <axis id="axis_A"/>
      <axis id="axis_A_zoom" axis_ref="axis_A">
-       <zoom_axis begin="0" n="1" />
+       <zoom_axis index="(0,1)[0 2]" />
      </axis>
    </axis_definition>
@@ -47 +58 @@
        <domain domain_ref="domain_A" />
        <axis axis_ref="axis_A_zoom" />
+     </grid>
+     <grid id="grid_Scalar">
+      <scalar id="scalar_A"/>
      </grid>
    </grid_definition>

XIOS/dev/dev_olga/src/config/axis_attribute_private.conf

@@ -2 +2 @@
 DECLARE_ATTRIBUTE_PRIVATE(int, global_zoom_n)
 DECLARE_ARRAY_PRIVATE(int,  1, global_zoom_index)
-DECLARE_ATTRIBUTE_PRIVATE(int, zoom_begin)
-DECLARE_ATTRIBUTE_PRIVATE(int, zoom_n)
 
 /* LOCAL DATA*/
 DECLARE_ARRAY_PRIVATE(int    ,   1 , zoom_index)
+DECLARE_ATTRIBUTE_PRIVATE(int, zoom_begin)
+DECLARE_ATTRIBUTE_PRIVATE(int, zoom_n)

XIOS/dev/dev_olga/src/distribution_server.cpp

@@ -22 +22 @@
 }
 
+CDistributionServer::CDistributionServer(int rank, 
+                                        const std::vector<CArray<int,1> >& globalIndexElements,
+                                        const CArray<int,1>& elementOrder,
+                                        const std::vector<int>& nZoomBegin,
+                                        const std::vector<int>& nZoomSize,
+                                        const std::vector<int>& nZoomBeginGlobal,
+                                        const std::vector<int>& nGlobal)
+  : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(nZoomBeginGlobal),
+    nZoomSize_(nZoomSize), nZoomBegin_(nZoomBegin), globalLocalIndexMap_()
+{
+  createGlobalIndex(globalIndexElements, elementOrder);
+}
+
 CDistributionServer::~CDistributionServer()
 {
@@ -70 +83 @@
       this->globalIndex_(idx) = globalIndex;
 
+      ++idx;
+    }
+    idxLoop[0] += innerLoopSize;
+  }
+}
+
+/*!
+  Create global index on server side
+  Like the similar function on client side, this function serves on creating global index
+for data written by the server. The global index is used to calculating local index of data
+written on each server
+  \param[in] globalIndexElement global index on server side of each element of grid (scalar, axis, domain)
+  \param[in] elementOrder the order of elements of grid (e.x: domain->axis or domain->scalar)
+*/
+void CDistributionServer::createGlobalIndex(const std::vector<CArray<int,1> >& globalIndexElements,
+                                            const CArray<int,1>& elementOrder)
+{
+  int numElement = elementOrder.numElements(), elementIdx = 0;  
+  std::vector<int> indexMap(numElement);
+  for (int i = 0; i < numElement; ++i)
+  {
+    indexMap[i] = elementIdx;
+    if (2 == elementOrder(i))
+    {      
+      elementIdx += 2;
+    }
+    else
+      ++elementIdx;
+  }
+
+  std::vector<size_t> elementGlobalSize(numElement);
+  size_t globalSize = 1;
+  for (int i = 0; i < numElement; ++i)
+  {
+    int elementType = elementOrder(i);
+    elementGlobalSize[i] = globalSize;
+    if (2 == elementType) // domain
+    {
+      globalSize *= nGlobal_[indexMap[i]+1] * nGlobal_[indexMap[i]];
+    }
+    else // axis or scalar
+    {
+      globalSize *= nGlobal_[indexMap[i]];
+    }
+  } 
+
+  size_t ssize = 1;
+  for (int i = 0; i < globalIndexElements.size(); ++i) ssize *= globalIndexElements[i].numElements();
+  this->globalIndex_.resize(ssize);
+  globalLocalIndexMap_.rehash(std::ceil(ssize/globalLocalIndexMap_.max_load_factor()));
+
+  std::vector<int> idxLoop(numElement,0);
+  std::vector<int> currentIndex(numElement);
+  int innerLoopSize = globalIndexElements[0].numElements();
+
+  size_t idx = 0;
+  while (idx<ssize)
+  {
+    for (int i = 0; i < numElement-1; ++i)
+    {
+      if (idxLoop[i] == globalIndexElements[i].numElements())
+      {
+        idxLoop[i] = 0;
+        ++idxLoop[i+1];
+      }
+    }
+
+    for (int i = 1; i < numElement; ++i)  currentIndex[i] = globalIndexElements[i](idxLoop[i]);
+
+    size_t mulDim, globalIndex;
+    for (int i = 0; i < innerLoopSize; ++i)
+    {      
+      globalIndex = 0;
+      currentIndex[0] = globalIndexElements[0](i);
+
+      for (int k = 0; k < numElement; ++k)
+      {     
+        globalIndex += (currentIndex[k])*elementGlobalSize[k];
+      }
+      globalLocalIndexMap_[globalIndex] = idx;
+      this->globalIndex_(idx) = globalIndex;
       ++idx;
     }

XIOS/dev/dev_olga/src/distribution_server.hpp

@@ -53 +53 @@
   protected:
     virtual void createGlobalIndex();
-
+    void createGlobalIndex(const std::vector<CArray<int,1> >& globalIndexElements,
+                           const CArray<int,1>& elementOrder);
+    
   protected:
     GlobalLocalMap globalLocalIndexMap_;

XIOS/dev/dev_olga/src/node/axis.cpp

@@ -27 +27 @@
       , hasBounds_(false), isCompressible_(false)
       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), doZoomByIndex_(false), hasLabel(false)
+      , transformationMap_(), hasValue(false), hasLabel(false)
       , computedWrittenIndex_(false)
    {
@@ -38 +38 @@
       , hasBounds_(false), isCompressible_(false)
       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), doZoomByIndex_(false), hasLabel(false)
+      , transformationMap_(), hasValue(false), hasLabel(false)
       , computedWrittenIndex_(false)
    {
@@ -365 +365 @@
     else hasLabel = false;
   }
+
   void CAxis::checkEligibilityForCompressedOutput()
   {
     // We don't check if the mask is valid here, just if a mask has been defined at this point.
     isCompressible_ = !mask.isEmpty();
+  }
+
+  bool CAxis::zoomByIndex()
+  {
+    return (!global_zoom_index.isEmpty() && (0 != global_zoom_index.numElements()));
   }
 
@@ -477 +483 @@
       size_t nbIndex = index.numElements();
 
-      if (doZoomByIndex_) 
-      {
-        nZoomCount = zoom_index.numElements();
-      }
-      else
-      {
-        for (size_t idx = 0; idx < nbIndex; ++idx)
-        {
-          globalLocalIndexMap_[index(idx)] = idx;
-          size_t globalIndex = index(idx);
-          if (globalIndex >= global_zoom_begin && globalIndex <= global_zoom_end) ++nZoomCount;
-        }
-      }
-
-
-      CArray<size_t,1> globalIndexAxis(nbIndex);
-      std::vector<size_t> globalAxisZoom(nZoomCount);
-      nZoomCount = 0;
-      if (doZoomByIndex_) 
-      {
-        int nbIndexZoom = zoom_index.numElements();        
-        for (int i = 0; i < nbIndexZoom; ++i)
-        {   
-          globalIndexAxis(i) = zoom_index(i);
-        }
-      }
-      else 
-      {
-        for (size_t idx = 0; idx < nbIndex; ++idx)
-        {
-          size_t globalIndex = index(idx);
-          globalIndexAxis(idx) = globalIndex;
-          if (globalIndex >= global_zoom_begin && globalIndex <= global_zoom_end)
-          {
-            globalAxisZoom[nZoomCount] = globalIndex;
-            ++nZoomCount;
-          }
-        }
-
-        int end       = begin + n -1;        
-        zoom_begin    = global_zoom_begin > begin ? global_zoom_begin : begin;
-        int zoom_end  = global_zoom_end < end ? zoom_end : end;
-        zoom_n        = zoom_end-zoom_begin+1;
-      }
-
+      for (size_t idx = 0; idx < nbIndex; ++idx)
+      {
+        globalLocalIndexMap_[index(idx)] = idx;
+      }
       std::set<int> writtenInd;
       if (isCompressible_)
@@ -593 +558 @@
       indSrv_.swap(globalIndexAxisOnServer);
 
-      CClientServerMapping::GlobalIndexMap::const_iterator it = indSrv_.begin(),
+      CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_.begin(),
                                                            ite = indSrv_.end();
 
@@ -625 +590 @@
                                                           ite = globalLocalIndexMap_.end(), it;          
       CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
-                                       itSrve = writtenGlobalIndex.end(), itSrv;      
-
-      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
-      {
-        indGlo = *itSrv;
-        if (ite != globalLocalIndexMap_.find(indGlo))
-        {          
-          ++nbWritten;
-        }                 
-      }
-
-      localIndexToWriteOnServer.resize(nbWritten);
-
-      nbWritten = 0;
-      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
-      {
-        indGlo = *itSrv;
-        if (ite != globalLocalIndexMap_.find(indGlo))
-        {
-          localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo];
-          ++nbWritten;
-        }                 
+                                       itSrve = writtenGlobalIndex.end(), itSrv;  
+      if (!zoomByIndex())
+      {   
+        for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+        {
+          indGlo = *itSrv;
+          if (ite != globalLocalIndexMap_.find(indGlo))
+          {          
+            ++nbWritten;
+          }                 
+        }
+
+        localIndexToWriteOnServer.resize(nbWritten);
+
+        nbWritten = 0;
+        for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+        {
+          indGlo = *itSrv;
+          if (ite != globalLocalIndexMap_.find(indGlo))
+          {
+            localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo];
+            ++nbWritten;
+          }                 
+        }
+      }
+      else
+      {
+        nbWritten = 0;
+        boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+                                                            ite = globalLocalIndexMap_.end(), it;
+        for (int i = 0; i < zoom_index.numElements(); ++i)
+        {
+           if (ite != globalLocalIndexMap_.find(zoom_index(i)))
+            ++nbWritten;
+        }
+
+        localIndexToWriteOnServer.resize(nbWritten);
+
+        nbWritten = 0;
+        for (int i = 0; i < zoom_index.numElements(); ++i)
+        {
+           if (ite != globalLocalIndexMap_.find(zoom_index(i)))
+           {
+             localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[zoom_index(i)];
+             ++nbWritten;
+           }
+        }
       }
 
@@ -731 +721 @@
           const int begin = serverIndexBegin[*itRank][orderPositionInGrid];
           const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid];
-          const int end   = begin + ni - 1;
+          const int end   = begin + ni - 1;          
 
           msgs.push_back(CMessage());
@@ -737 +727 @@
           msg << this->getId();
           msg << ni << begin << end;
-          msg << global_zoom_begin.getValue() << global_zoom_n.getValue();
+          // msg << global_zoom_begin.getValue() << global_zoom_n.getValue();
           msg << isCompressible_;
           msg << orderPositionInGrid;
@@ -792 +782 @@
           msg << this->getId();
           msg << index.getValue() << dataIndex << mask.getValue();
-
-          msg << doZoomByIndex_;
-          if (doZoomByIndex_) msg << zoom_index.getValue();
           msg << hasValue;
           if (hasValue) msg << value.getValue();
@@ -834 +821 @@
     mask.reference(tmp_mask);
 
-    buffer >> doZoomByIndex_;
-    if (doZoomByIndex_)
-    {
-      buffer >> tmp_zoom_index;
-      zoom_index.reference(tmp_zoom_index);
-    }
-
     buffer >> hasValue;
     if (hasValue)
@@ -864 +844 @@
     int ns, n, i, j, ind, nv, idx;
     CContext* context = CContext::getCurrent();
-
-    //int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1;
+    
     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1;
     for (int p = 0; p < nbSrvPools; ++p)
@@ -903 +882 @@
         list_mask.push_back(CArray<bool,1>(nbData));
 
-        if (doZoomByIndex_)
-          list_zoomInd.push_back(CArray<int,1>(nbData));
-
         if (hasValue)
           list_val.push_back(CArray<double,1>(nbData));
@@ -926 +902 @@
           dataIndi(n) = dataIndex(ind);
           maskIndi(n) = mask(ind);
-
-          if (doZoomByIndex_)
-          {
-            CArray<int,1>& zoomIndi = list_zoomInd.back();
-            zoomIndi(n) = zoom_index(ind);
-          }
 
           if (hasValue)
@@ -950 +920 @@
         listData.back() << this->getId()
                         << list_indi.back() << list_dataInd.back() << list_mask.back();
-
-        listData.back() << doZoomByIndex_;           
-        if (doZoomByIndex_)
-          listData.back() << list_zoomInd.back();
 
         listData.back() << hasValue;
@@ -1003 +969 @@
       buffer >> vec_mask[idx];
 
-      buffer >> doZoomByIndex_;
-      if (doZoomByIndex_)
-        buffer >> vec_zoomInd[idx];
-
       buffer >> hasValue;
       if (hasValue)
@@ -1075 +1037 @@
     data_begin.setValue(0);
 
-    if (doZoomByIndex_)
-    {
-      int nbZoomIndex = 0;
-      for (int idx = 0; idx < nbReceived; ++idx)
-      {
-        nbZoomIndex += vec_zoomInd[idx].numElements();
-      }
-
-      zoom_index.resize(nbZoomIndex);
-      nbZoomIndex = 0;      
-      for (int idx = 0; idx < nbReceived; ++idx)
-      {      
-        CArray<int,1>& tmp = vec_zoomInd[idx];
-        for (int i = 0; i < tmp.size(); ++i)
-        {
-          zoom_index(nbZoomIndex) = tmp(i);
-          ++nbZoomIndex;
-        }       
-      }
-    }
-
     if (hasLabel)
     {
@@ -1112 +1053 @@
   void CAxis::recvDistributionAttribute(CBufferIn& buffer)
   {
-    int ni_srv, begin_srv, end_srv, global_zoom_begin_tmp, global_zoom_n_tmp;
+    int ni_srv, begin_srv, end_srv;
+    int global_zoom_end, zoom_end;
+    bool zoomIndex = zoomByIndex();
+    
+    std::vector<int> zoom_index_tmp;
+    std::vector<int>::iterator itZoomBegin, itZoomEnd, itZoom;
 
     buffer >> ni_srv >> begin_srv >> end_srv;
-    buffer >> global_zoom_begin_tmp >> global_zoom_n_tmp;
+    // buffer >> global_zoom_begin_tmp >> global_zoom_n_tmp;   
     buffer >> isCompressible_;
     buffer >> orderPosInGrid;
-    buffer >> globalDimGrid;
-
+    buffer >> globalDimGrid;    
+
+    // Set up new local size of axis on the receiving clients
     n.setValue(ni_srv);
     begin.setValue(begin_srv);
-    global_zoom_begin = global_zoom_begin_tmp;
-    global_zoom_n  = global_zoom_n_tmp;
-    int global_zoom_end = global_zoom_begin + global_zoom_n - 1;
-
-    zoom_begin = global_zoom_begin > begin_srv ? global_zoom_begin : begin_srv ;
-    zoom_end_srv   = global_zoom_end < end_srv ? global_zoom_end : end_srv ;
-    zoom_n  = zoom_end_srv - zoom_begin_srv + 1;
+
+    // If we have zoom by index then process it
+    if (zoomIndex)
+    {
+      zoom_index_tmp.resize(global_zoom_index.numElements());
+      std::copy(global_zoom_index.begin(), global_zoom_index.end(), zoom_index_tmp.begin());
+      std::sort(zoom_index_tmp.begin(), zoom_index_tmp.end());
+      itZoomBegin = std::lower_bound(zoom_index_tmp.begin(), zoom_index_tmp.end(), begin_srv);
+      itZoomEnd   = std::upper_bound(zoom_index_tmp.begin(), zoom_index_tmp.end(), end_srv);      
+      int sz = std::distance(itZoomBegin, itZoomEnd);
+      zoom_index.resize(sz);
+      itZoom = itZoomBegin;
+      for (int i = 0; i < sz; ++i, ++itZoom)
+      {
+        zoom_index(i) = *(itZoom);
+      }
+    }
+
+    global_zoom_begin = zoomIndex ? 0 : global_zoom_begin ;
+    global_zoom_n     = zoomIndex ? zoom_index_tmp.size() : global_zoom_n;
+    global_zoom_end   = global_zoom_begin + global_zoom_n - 1;
+
+    zoom_begin = zoomIndex ? std::distance(itZoomBegin, zoom_index_tmp.begin())
+                           : global_zoom_begin > begin_srv ? global_zoom_begin : begin_srv ;
+    zoom_end   = zoomIndex ? std::distance(zoom_index_tmp.begin(), itZoomEnd) - 1 
+                           : global_zoom_end < end_srv ? global_zoom_end : end_srv ;
+    zoom_n     = zoom_end - zoom_begin + 1;
 
     if (zoom_n<=0)
     {
-      zoom_begin = 0; zoom_end_srv = 0; zoom_n = 0;
+      zoom_begin = 0; zoom_n = 0;
     }
 
     if (n_glo == n)
     {
-      zoom_begin = global_zoom_begin;
-      zoom_end_srv   = global_zoom_end; //zoom_end;
-      zoom_n     = zoom_end_srv - zoom_begin + 1;
+      zoom_begin = zoomIndex ? std::distance(itZoomBegin, zoom_index_tmp.begin())
+                             : global_zoom_begin;      
+      zoom_n     = zoomIndex ? zoom_index_tmp.size() : global_zoom_n;
     }
   }

XIOS/dev/dev_olga/src/node/axis.hpp

@@ -119 +119 @@
          CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
          bool isEqual(CAxis* axis);
+         bool zoomByIndex();
 
-      public:
-        int zoom_begin_srv, zoom_end_srv, zoom_size_srv;
-        int ni_srv, begin_srv, end_srv;
-        int global_zoom_begin_srv, global_zoom_end_srv, global_zoom_size_srv;
-        CArray<double,1> value_srv;
-        CArray<double,2> bound_srv;
+      public:                
         CArray<StdString,1> label_srv;
-        CArray<int,1> zoom_index_srv;
         bool hasValue;
         CArray<int,1> globalDimGrid;
@@ -146 +141 @@
          void computeConnectedServer(const std::vector<int>& globalDim, int orderPositionInGrid,
                                      CServerDistributionDescription::ServerDistributionType distType);
-         bool zoomByIndex();
 
          void sendNonDistributedAttributes(void);
@@ -175 +169 @@
          std::map<int, CArray<int,1> > indiSrv_;
          bool hasBounds_;
-         bool hasLabel;
-         bool doZoomByIndex_;
+         bool hasLabel;         
          bool computedWrittenIndex_;
 

XIOS/dev/dev_olga/src/node/domain.cpp

@@ -2463 +2463 @@
     }
     
+    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor()));
     i_index.resize(nbIndGlob);
-    j_index.resize(nbIndGlob);
-
-    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor()));
+    j_index.resize(nbIndGlob);    
     nbIndGlob = 0;
     for (i = 0; i < nbReceived; ++i)
@@ -2474 +2473 @@
       {
          index = tmp(ind);
-         i_index(nbIndGlob) = index % ni_glo;
-         j_index(nbIndGlob) = index / ni_glo;
-         globalLocalIndexMap_[index] = nbIndGlob;  
-         ++nbIndGlob;
+         if (0 == globalLocalIndexMap_.count(index))
+         {
+           i_index(nbIndGlob) = index % ni_glo;
+           j_index(nbIndGlob) = index / ni_glo;
+           globalLocalIndexMap_[index] = nbIndGlob;  
+           ++nbIndGlob;
+         } 
       } 
     } 
+
+    i_index.resizeAndPreserve(nbIndGlob);
+    j_index.resizeAndPreserve(nbIndGlob);
   }
 
@@ -2630 +2635 @@
   void CDomain::recvMask(std::map<int, CBufferIn*>& rankBuffers)
   {
-    int nbReceived = rankBuffers.size(), i, ind, index;
+    int nbReceived = rankBuffers.size(), i, ind, index, lInd;
     if (nbReceived != recvClientRanks_.size())
-      ERROR("void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)",
+      ERROR("void CDomain::recvMask(std::map<int, CBufferIn*>& rankBuffers)",
            << "The number of sending clients is not correct."
            << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived);
@@ -2650 +2655 @@
     }
   
+    if (nbMaskInd != globalLocalIndexMap_.size())
+      info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes."
+               << "Something must be wrong with mask index "<< std::endl;
+
+    nbMaskInd = globalLocalIndexMap_.size();
     mask_1d.resize(nbMaskInd);
-    nbMaskInd = 0;
+    
     for (i = 0; i < nbReceived; ++i)
     {
+      CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]];
       CArray<bool,1>& tmp = recvMaskValue[i];
       for (ind = 0; ind < tmp.numElements(); ++ind)
       {
-        mask_1d(nbMaskInd) = tmp(ind);      
-        ++nbMaskInd;
+        lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
+        mask_1d(lInd) = tmp(ind);
       }
     }    
@@ -2717 +2728 @@
     
       if (nbLonInd != globalLocalIndexMap_.size())
-        info (0) << "Something wrong with longitude index "<< std::endl;
-
+        info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes."
+                 << "Something must be wrong with longitude index "<< std::endl;
+
+      nbLonInd = globalLocalIndexMap_.size();
       lonvalue.resize(nbLonInd);
       if (hasBounds)
@@ -2799 +2812 @@
     
       if (nbLatInd != globalLocalIndexMap_.size())
-        info (0) << "Something wrong with latitude index "<< std::endl;
-
+        info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes."
+                << "Something must be wrong with latitude index "<< std::endl;
+
+      nbLatInd = globalLocalIndexMap_.size();
       latvalue.resize(nbLatInd);
       if (hasBounds)
@@ -2870 +2885 @@
     }
 
-    int nbAreaInd = 0;
-    for (i = 0; i < nbReceived; ++i)
-    {      
-      nbAreaInd += recvAreaValue[i].numElements();
-    }
-  
-    if (nbAreaInd != globalLocalIndexMap_.size())
-      info (0) << "Something wrong with latitude index "<< std::endl;
-
     if (hasArea)
     {
+      int nbAreaInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {      
+        nbAreaInd += recvAreaValue[i].numElements();
+      }
+
+      if (nbAreaInd != globalLocalIndexMap_.size())
+        info (0) << "If the domain " << this->getDomainOutputName() <<" does not have overlapped region between processes."
+                 << "Something must be wrong with area index "<< std::endl;
+
+      nbAreaInd = globalLocalIndexMap_.size();
       areavalue.resize(nbAreaInd);
       nbAreaInd = 0;      
@@ -2988 +3005 @@
       {
          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
-         dataIIndex(lInd) = tmpI(ind);
-         dataJIndex(lInd) = tmpJ(ind);         
+         dataIIndex(lInd) = (-1 == dataIIndex(lInd)) ? tmpI(ind) : dataIIndex(lInd); // Only fill in dataIndex if there is no data
+         dataJIndex(lInd) = (-1 == dataJIndex(lInd)) ? tmpJ(ind) : dataJIndex(lInd);         
       } 
     }

XIOS/dev/dev_olga/src/node/grid.cpp

@@ -287 +287 @@
      nbSrvPools = 1;  
      for (int p = 0; p < nbSrvPools; ++p)
-     {       
-       if (isScalarGrid())
-       {  
-          if (context->hasClient)
-            if (this->isChecked && doSendingIndex && !isIndexSent) { sendIndexScalarGrid(); this->isIndexSent = true; }
-
-          if (this->isChecked) continue;
-  
-          if (context->hasClient)
-          {
-            this->computeIndexScalarGrid();
-          }
-  
-         if (!(this->hasTransform() && !this->isTransformed()))
-          this->isChecked = true;
-         continue;
+     {    
+       if (context->hasClient && this->isChecked && doSendingIndex && !isIndexSent) 
+       { 
+         if (isScalarGrid())
+           sendIndexScalarGrid();
+         else
+           sendIndex();
+         this->isIndexSent = true; 
        }
 
-       if (context->hasClient)
-       {
-         if (this->isChecked && doSendingIndex && !isIndexSent)
-            {sendIndex(); this->isIndexSent = true;}
-       }
+       // Not sure about this
+       //if (!(this->hasTransform() && !this->isTransformed()))
+       // this->isChecked = true;
+       //return;
      }
     
@@ -546 +537 @@
       if (computedWrittenIndex_) return;
       computedWrittenIndex_ = true;
+
+      if (isScalarGrid())
+      {
+        size_t nbWritten = 1;
+        int writtenIndex = 0;
+
+        localIndexToWriteOnClient.resize(nbWritten);  
+        localIndexToWriteOnServer.resize(nbWritten);
+        localIndexToWriteOnServer(0) = writtenIndex;
+        localIndexToWriteOnClient(0) = writtenIndex;
+        
+        return;
+      }
 
       size_t nbWritten = 0, indGlo;
@@ -746 +750 @@
    {
      CContext* context = CContext::getCurrent();
-     computeClientIndex();
-     if (context->hasClient)
+     if (isScalarGrid())
      {
-       computeConnectedClients();
+       computeClientIndexScalarGrid();
+       if (context->hasClient)
+       {
+         computeConnectedClientsScalarGrid();
+       }
+     }
+     else
+     {
+       computeClientIndex();
+       if (context->hasClient)
+       {
+         computeConnectedClients();
+       }
      }
    }
@@ -1171 +1186 @@
    }
 
-  void CGrid::computeIndexScalarGrid()
+  void CGrid::computeClientIndexScalarGrid()
+  {
+    CContext* context = CContext::getCurrent();    
+    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1; // This should be changed soon
+    for (int p = 0; p < nbSrvPools; ++p)
+    {
+      CContextClient* client = (context->hasServer) ? (context->hasClient ? context->clientPrimServer[p] : context->client) 
+                                                    : context->client;
+
+      storeIndex_client.resize(1);
+      storeIndex_client(0) = 0;      
+
+      if (0 != serverDistribution_)
+      {
+        map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(),
+                                               ite = outGlobalIndexFromClient.end(), it;
+        for (it = itb; it != ite; ++it)
+        {
+          int rank = it->first;
+          CArray<size_t,1>& globalIndex = outGlobalIndexFromClient[rank];
+          outLocalIndexStoreOnClient.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements())));
+          CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank];
+          if (1 != globalIndex.numElements())
+            ERROR("void CGrid::computeClientIndexScalarGrid()",
+              << "Something wrong happened. "
+              << "Number of received global index on scalar grid should equal to 1" 
+              << "Number of received global index " << globalIndex.numElements() << ".");
+
+          localIndex(0) = globalIndex(0);
+        }
+      }
+    }
+  }
+
+  void CGrid::computeConnectedClientsScalarGrid()
   {
     CContext* context = CContext::getCurrent();    
@@ -1181 +1230 @@
     for (int p = 0; p < nbSrvPools; ++p)
     {
-      CContextClient* client = context->hasServer ? context->clientPrimServer[p] : context->client;
-
-      storeIndex_client.resize(1);
-      storeIndex_client(0) = 0;
+      CContextClient* client = (context->hasServer) ? (context->hasClient ? context->clientPrimServer[p] : context->client) 
+                                                    : context->client;
 
       connectedServerRank_[p].clear();
 
-      if (0 == client->clientRank)
-      {
-        for (int rank = 0; rank < client->serverSize; ++rank)
-        {
+      if (client->isServerLeader())
+      {
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          int rank = *itRank;
+          int nb = 1;
           connectedServerRank_[p].push_back(rank);
-          connectedDataSize_[p][rank] = 1;
-          nbSenders[p][rank] = 1;
-        }
-      }
+          connectedDataSize_[p][rank] = nb;
+          nbSenders[p][rank] = nb;
+        }
+      }
+      else
+      {
+        const std::list<int>& ranks = client->getRanksServerNotLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          int rank = *itRank;
+          int nb = 1;
+          connectedServerRank_[p].push_back(rank);
+          connectedDataSize_[p][rank] = nb;
+          nbSenders[p][rank] = nb;
+        }        
+      }
+
       isDataDistributed_ = false;
     }
@@ -1433 +1496 @@
           std::vector<CAxis*> axisList = getAxis();
           std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize), nGlobElement(numElement);
-          std::vector<CArray<int,1> > zoomIndex;
+          std::vector<CArray<int,1> > globalZoomIndex(numElement);
           for (int i = 0; i < numElement; ++i)
           {
@@ -1449 +1512 @@
               nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo;
 
+              {
+                int count = 0;
+                globalZoomIndex[i].resize(nZoomSize[indexMap[i]]*nZoomSize[indexMap[i]+1]);
+                for (int jdx = 0; jdx < nZoomSize[indexMap[i]+1]; ++jdx)
+                  for (int idx = 0; idx < nZoomSize[indexMap[i]]; ++idx)                
+                  {
+                    globalZoomIndex[i](count) = (nZoomBegin[indexMap[i]] + idx) + (nZoomBegin[indexMap[i]+1] + jdx) * nGlob[indexMap[i]];
+                    ++count;
+                  }
+              }
+
               ++domainId;
             }
@@ -1456 +1530 @@
               nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_n;
               nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;              
-              nGlob[indexMap[i]] = axisList[axisId]->n_glo;              
+              nGlob[indexMap[i]] = axisList[axisId]->n_glo;     
+              if (axisList[axisId]->zoomByIndex())
+              {
+                globalZoomIndex[i].reference(axisList[axisId]->zoom_index);                
+              }
+              else
+              {
+                globalZoomIndex[i].resize(nZoomSize[indexMap[i]]);
+                for (int idx = 0; idx < nZoomSize[indexMap[i]]; ++idx)
+                  globalZoomIndex[i](idx) = nZoomBegin[indexMap[i]] + idx;
+              }
+
               ++axisId;
             }
@@ -1465 +1550 @@
               nZoomBeginGlobal[indexMap[i]] = 0;              
               nGlob[indexMap[i]] = 1;
-
+              globalZoomIndex[i].resize(1);
+              globalZoomIndex[i](0) = 0;
               ++scalarId;
             }
@@ -1473 +1559 @@
           for (int i = 0; i < nZoomSize.size(); ++i)
             dataSize *= nZoomSize[i];
-          serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize,
-                                                        nZoomBeginGlobal, nGlob);
+          // serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize,
+          //                                               nZoomBeginGlobal, nGlob);
+          serverDistribution_ = new CDistributionServer(server->intraCommRank, 
+                                                        globalZoomIndex, axis_domain_order,
+                                                        nZoomBegin, nZoomSize, nZoomBeginGlobal, nGlob);
         }
 

XIOS/dev/dev_olga/src/node/grid.hpp

@@ -278 +278 @@
         void computeClientIndex();
         void computeConnectedClients();
+        void computeClientIndexScalarGrid(); 
+        void computeConnectedClientsScalarGrid(); 
 
       private:

XIOS/dev/dev_olga/src/test/test_client.f90

@@ -19 +19 @@
   INTEGER,PARAMETER :: ni_glo=100
   INTEGER,PARAMETER :: nj_glo=100
-  INTEGER,PARAMETER :: llm=2
-  DOUBLE PRECISION  :: lval(llm)=1
+  INTEGER,PARAMETER :: llm=5
+  DOUBLE PRECISION  :: lval(llm)=1, scalar = 5
   TYPE(xios_field) :: field_hdl
   TYPE(xios_fieldgroup) :: fieldgroup_hdl
@@ -131 +131 @@
 
   PRINT*,"field field_A is active ? ",xios_field_is_active("field_A")
+  ! CALL xios_recv_field("field", scalar)
   DO ts=1,4
     CALL xios_update_calendar(ts)
@@ -137 +138 @@
     ! CALL xios_send_field("field_Axis",lval)
     CALL xios_send_field("field_Domain",field_domain)
+    CALL xios_send_field("field_Scalar",scalar)
     CALL wait_us(5000) ;
   ENDDO

XIOS/dev/dev_olga/src/transformation/axis_algorithm_zoom.cpp

@@ -53 +53 @@
            << "Zoom size is " << zoomSize_ );
   }
+
+  if (!zoomAxis->index.isEmpty())
+  {
+    int sz = zoomAxis->index.numElements();
+    zoomIndex_.resize(sz);
+    for (int i = 0; i < sz; ++i)
+      zoomIndex_[i] = zoomAxis->index(i);
+
+    std::sort(zoomIndex_.begin(), zoomIndex_.end());
+  }
+
 }
 
@@ -69 +80 @@
   StdSize ibegin = std::max(ibeginSource, zoomBegin_);
   StdSize iend = std::min(iendSource, zoomEnd_);
-  // StdSize ibegin = ibeginSource;
-  // StdSize iend = iendSource;
   StdSize ni = iend + 1 - ibegin;
   if (iend < ibegin) ni = 0;
@@ -80 +89 @@
   TransformationWeightMap& transWeight = this->transformationWeight_[0];
 
-  for (StdSize idx = 0; idx < ni; ++idx)
+  if (!zoomIndex_.empty())
   {
-    transMap[ibegin+idx].push_back(ibegin+idx);
-    transWeight[ibegin+idx].push_back(1.0);
+    std::vector<int>::iterator itZoomBegin, itZoomEnd;
+    itZoomBegin = std::lower_bound(zoomIndex_.begin(), zoomIndex_.end(), ibeginSource);
+    itZoomEnd   = std::upper_bound(zoomIndex_.begin(), zoomIndex_.end(), iendSource);            
+    for (; itZoomBegin != itZoomEnd; ++itZoomBegin)
+    {
+      transMap[*itZoomBegin].push_back(*itZoomBegin);
+      transWeight[*itZoomBegin].push_back(1.0);
+    }
+  }
+  else
+  {
+    for (StdSize idx = 0; idx < ni; ++idx)
+    {
+      transMap[ibegin+idx].push_back(ibegin+idx);
+      transWeight[ibegin+idx].push_back(1.0);
+    }
   }
 
@@ -97 +120 @@
   axisDest_->global_zoom_begin = zoomBegin_;
   axisDest_->global_zoom_n  = zoomSize_;
+  if (!zoomIndex_.empty())
+  {
+    axisDest_->global_zoom_index.resize(zoomIndex_.size());
+    std::copy(zoomIndex_.begin(), zoomIndex_.end(), axisDest_->global_zoom_index.begin());
+  }
 }