Changeset 1169 for XIOS/trunk

Timestamp:

06/15/17 16:17:01 (7 years ago)

Author:

mhnguyen

Message:

Non-continuous zoom on axis
Zoomed points are defined by array index of zoom_axis

+) Update axis with new type of zoom

Test
+) On Curie
+) Work
+) Update test_complete with this new zoom.

Location:

XIOS/trunk

Files:

• bld.cfg (modified) (1 diff)
• inputs/COMPLETE/context_atmosphere.xml (modified) (1 diff)
• src/config/axis_attribute_private.conf (modified) (1 diff)
• src/config/zoom_axis_attribute.conf (modified) (1 diff)
• src/distribution_server.cpp (modified) (2 diffs)
• src/distribution_server.hpp (modified) (2 diffs)
• src/io/nc4_data_output.cpp (modified) (2 diffs)
• src/node/axis.cpp (modified) (9 diffs)
• src/node/axis.hpp (modified) (2 diffs)
• src/node/grid.cpp (modified) (5 diffs)
• src/node/zoom_axis.cpp (modified) (2 diffs)
• src/transformation/axis_algorithm_zoom.cpp (modified) (5 diffs)
• src/transformation/axis_algorithm_zoom.hpp (modified) (1 diff)

XIOS/trunk/bld.cfg

@@ -37 +37 @@
 #bld::target test_expand_domain.exe
 #bld::target test_new_features.exe test_unstruct_complete.exe 
-bld::target test_client.exe #test_complete.exe test_xios2_cmip6.exe
+bld::target test_client.exe 
+bld::target test_complete.exe test_xios2_cmip6.exe
 #bld::target test_connectivity_expand.exe
 #bld::target toy_cmip6.exe

XIOS/trunk/inputs/COMPLETE/context_atmosphere.xml

@@ -19 +19 @@
   <axis_definition>
     <axis id="axis_atm"/>
-    <axis id="axis_atm_zoom" axis_ref="axis_atm">
-      <zoom_axis id="axis_atm_zoom" n="4"/>
+    <axis id="axis_atm_zoom" axis_ref="axis_atm">      
+      <zoom_axis id="axis_atm_zoom" index="(0,2)[3 0 1]"/>
     </axis>
   </axis_definition>

XIOS/trunk/src/config/axis_attribute_private.conf

@@ -1 +1 @@
 DECLARE_ATTRIBUTE_PRIVATE(int, global_zoom_begin)
 DECLARE_ATTRIBUTE_PRIVATE(int, global_zoom_n)
+DECLARE_ARRAY_PRIVATE(int,  1, global_zoom_index)

XIOS/trunk/src/config/zoom_axis_attribute.conf

@@ -2 +2 @@
 DECLARE_ATTRIBUTE(int,       begin)
 DECLARE_ATTRIBUTE(int,       n)
+DECLARE_ARRAY(int    ,1    , index)

XIOS/trunk/src/distribution_server.cpp

@@ -34 +34 @@
 }
 
+CDistributionServer::CDistributionServer(int rank, 
+                                        const std::vector<CArray<int,1> >& globalIndexElements,
+                                        const CArray<int,1>& elementOrder,
+                                        const std::vector<int>& nZoomBeginServer,
+                                        const std::vector<int>& nZoomSizeServer,
+                                        const std::vector<int>& nZoomBeginGlobal,
+                                        const std::vector<int>& nGlobal)
+  : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(nZoomBeginGlobal),
+    nZoomSize_(nZoomSizeServer), nZoomBegin_(nZoomBeginServer), globalLocalIndexMap_()
+{
+  createGlobalIndex(globalIndexElements, elementOrder);
+}
+
 CDistributionServer::~CDistributionServer()
 {
@@ -89 +102 @@
 
 /*!
+  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;
+    }
+    idxLoop[0] += innerLoopSize;
+  }
+}
+
+/*!
   Compute local index for writing data on server
   \param [in] globalIndex global index received from client

XIOS/trunk/src/distribution_server.hpp

@@ -31 +31 @@
                         const std::vector<int>& nGlobal);
 
+    CDistributionServer(int rank, 
+                        const std::vector<CArray<int,1> >& globalIndexElements,
+                        const CArray<int,1>& elementOrder,
+                        const std::vector<int>& nZoomBeginServer,
+                        const std::vector<int>& nZoomSizeServer,
+                        const std::vector<int>& nZoomBeginGlobal,
+                        const std::vector<int>& nGlobal);
+
     /** Default destructor */
     virtual ~CDistributionServer();
@@ -44 +52 @@
   protected:
     virtual void createGlobalIndex();
+    void createGlobalIndex(const std::vector<CArray<int,1> >& globalIndexElements,
+                           const CArray<int,1>& elementOrder);
 
   protected:

XIOS/trunk/src/io/nc4_data_output.cpp

@@ -1044 +1044 @@
         int zoom_begin_srv = axis->zoom_begin_srv;
         int zoom_size  = (MULTI_FILE == SuperClass::type) ? zoom_size_srv
-                                                              : axis->global_zoom_n;
-        int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv
-                                                              : axis->global_zoom_begin;
+                                                          : axis->global_zoom_size_srv;
 
         if ((0 == zoom_size_srv) && (MULTI_FILE == SuperClass::type)) return;
@@ -1125 +1123 @@
                 std::vector<StdSize> start(1), startBounds(2) ;
                 std::vector<StdSize> count(1), countBounds(2) ;
-                start[0] = startBounds[0] = zoom_begin_srv-axis->global_zoom_begin;
+                start[0] = startBounds[0] = zoom_begin_srv-axis->global_zoom_begin_srv;
                 count[0] = countBounds[0] = zoom_size_srv;
                 startBounds[1] = 0;

XIOS/trunk/src/node/axis.cpp

@@ -354 +354 @@
     // 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()));
   }
 
@@ -450 +455 @@
     size_t nZoomCount = 0;
     size_t nbIndex = index.numElements();
-    for (size_t idx = 0; idx < nbIndex; ++idx)
+
+    int end = (0 == n) ? begin : begin + n - 1;
+    int zoom_size = zoomByIndex() ? global_zoom_index.numElements() : global_zoom_n;
+    int minInd = min(index);
+    int maxInd = max(index);
+    for (size_t idx = 0; idx < zoom_size; ++idx)
+    {
+      size_t globalZoomIndex = zoomByIndex() ? global_zoom_index(idx) : global_zoom_begin + idx;
+      if (globalZoomIndex >= minInd && globalZoomIndex <= maxInd) ++nZoomCount;
+    }
+
+/*    for (size_t idx = 0; idx < nbIndex; ++idx)
     {
       size_t globalIndex = index(idx);
       if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nZoomCount;
-    }
-
+    }*/
+    
     CArray<size_t,1> globalIndexAxis(nbIndex);
+    for (size_t idx = 0; idx < nbIndex; ++idx)
+    {      
+      globalIndexAxis(idx) = (size_t)index(idx);
+    }
+
     std::vector<size_t> globalAxisZoom(nZoomCount);
     nZoomCount = 0;
-    for (size_t idx = 0; idx < nbIndex; ++idx)
-    {
-      size_t globalIndex = index(idx);
-      globalIndexAxis(idx) = globalIndex;
-      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end)
-      {
-        globalAxisZoom[nZoomCount] = globalIndex;
+    for (size_t idx = 0; idx < zoom_size; ++idx)
+    {
+      size_t globalZoomIndex = zoomByIndex() ? global_zoom_index(idx) : global_zoom_begin + idx;
+      if (globalZoomIndex >= minInd && globalZoomIndex <= maxInd)
+      {
+        globalAxisZoom[nZoomCount] = globalZoomIndex;
         ++nZoomCount;
-      }
+      } 
     }
 
@@ -585 +605 @@
     int zoom_end = global_zoom_begin + global_zoom_n - 1;
     int nb = 0;
-    for (size_t idx = 0; idx < n; ++idx)
+/*    for (size_t idx = 0; idx < n; ++idx)
     {
       size_t globalIndex = begin + idx;
       if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nb;
+    }*/
+
+    int end = (0 == n) ? begin : begin + n - 1;
+    int zoom_size = zoomByIndex() ? global_zoom_index.numElements() : global_zoom_n;
+    for (size_t idx = 0; idx < zoom_size; ++idx)
+    {
+      size_t globalZoomIndex = zoomByIndex() ? global_zoom_index(idx) : global_zoom_begin + idx;
+      if (globalZoomIndex >= begin && globalZoomIndex <= end) ++nb;
     }
 
@@ -609 +637 @@
     CArray<double,1> val(nb);
     nb = 0;
-    for (size_t idx = 0; idx < n; ++idx)
+/*    for (size_t idx = 0; idx < n; ++idx)
     {
       size_t globalIndex = begin + idx;
@@ -615 +643 @@
       {
         val(nb) = value(idx);
+        ++nb;
+      }
+    }*/
+
+    for (size_t idx = 0; idx < zoom_size; ++idx)
+    {
+      size_t globalZoomIndex = zoomByIndex() ? global_zoom_index(idx) : global_zoom_begin + idx;
+      if (globalZoomIndex >= begin && globalZoomIndex <= end)
+      {
+        val(nb) = value(globalZoomIndex-begin);
         ++nb;
       }
@@ -920 +958 @@
         const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid];
         const int end   = begin + ni - 1;
+        const bool zoomIndex = zoomByIndex();
 
         msgs.push_back(CMessage());
@@ -926 +965 @@
         msg << ni << begin << end;
         msg << global_zoom_begin.getValue() << global_zoom_n.getValue();
-        msg << isCompressible_;
+        msg << isCompressible_;        
+        msg << zoomIndex;
+        if (zoomIndex)
+          msg << global_zoom_index.getValue();
 
         event.push(*itRank,1,msg);
@@ -946 +988 @@
   {
     int ni_srv, begin_srv, end_srv, global_zoom_begin_tmp, global_zoom_n_tmp;
+    bool zoomIndex;    
+    CArray<int,1> zoom_index_recv;
+    std::vector<int> zoom_index_tmp;
+    std::vector<int>::iterator itZoomBeginSrv, itZoomEndSrv, itZoomSrv;
 
     buffer >> ni_srv >> begin_srv >> end_srv;
     buffer >> global_zoom_begin_tmp >> global_zoom_n_tmp;
     buffer >> isCompressible_;
+    buffer >> zoomIndex;
+    if (zoomIndex)
+    {
+      buffer >> zoom_index_recv;
+      global_zoom_index.reference(zoom_index_recv);
+      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());
+      itZoomBeginSrv = std::lower_bound(zoom_index_tmp.begin(), zoom_index_tmp.end(), begin_srv);
+      itZoomEndSrv   = std::upper_bound(zoom_index_tmp.begin(), zoom_index_tmp.end(), end_srv);      
+      int sz = std::distance(itZoomBeginSrv, itZoomEndSrv);
+      zoom_index_srv.resize(sz);
+      itZoomSrv = itZoomBeginSrv;
+      for (int i = 0; i < sz; ++i, ++itZoomSrv)
+      {
+        zoom_index_srv(i) = *(itZoomSrv);
+      }
+    }
+
     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_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_begin_srv = zoomIndex ? std::distance(itZoomBeginSrv, zoom_index_tmp.begin())
+                                 : global_zoom_begin > begin_srv ? global_zoom_begin : begin_srv ;
+    zoom_end_srv   = zoomIndex ? std::distance(zoom_index_tmp.begin(), itZoomEndSrv) - 1 
+                                 : global_zoom_end < end_srv ? global_zoom_end : end_srv ;
     zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
+     
+    global_zoom_begin_srv = zoomIndex ? 0 : global_zoom_begin ;
+    global_zoom_size_srv  = zoomIndex ? zoom_index_tmp.size() : global_zoom_n;
 
     if (zoom_size_srv<=0)
@@ -965 +1035 @@
     if (n_glo == n)
     {
-      zoom_begin_srv = global_zoom_begin;
-      zoom_end_srv   = global_zoom_end; //zoom_end;
-      zoom_size_srv  = zoom_end_srv - zoom_begin_srv + 1;
+      zoom_begin_srv = zoomIndex ? std::distance(itZoomBeginSrv, zoom_index_tmp.begin())
+                                   : global_zoom_begin;      
+      zoom_size_srv  = zoomIndex ? zoom_index_tmp.size()
+                                   : global_zoom_n;
     }
     if (hasValue)

XIOS/trunk/src/node/axis.hpp

@@ -122 +122 @@
         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;
         CArray<StdString,1> label_srv;
+        CArray<int,1> zoom_index_srv;
         bool hasValue;
 
@@ -138 +140 @@
          void sendDistributedValue();
          void sendNonDistributedValue();
+         bool zoomByIndex();
 
          static void recvIndex(CEventServer& event);

XIOS/trunk/src/node/grid.cpp

@@ -1253 +1253 @@
         std::vector<CAxis*> axisList = getAxis();
         std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize);
+        std::vector<CArray<int,1> > globalZoomIndex(numElement);
         for (int i = 0; i < numElement; ++i)
         {
@@ -1266 +1267 @@
             nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin;
             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;
           }
@@ -1272 +1284 @@
             nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv;
             nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv;
-            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;
+            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin_srv;
             nGlob[indexMap[i]] = axisList[axisId]->n_glo;
+            if (!axisList[axisId]->global_zoom_index.isEmpty())
+            {
+              globalZoomIndex[i].reference(axisList[axisId]->zoom_index_srv);                
+            }
+            else
+            {
+              globalZoomIndex[i].resize(nZoomSize[indexMap[i]]);
+              for (int idx = 0; idx < nZoomSize[indexMap[i]]; ++idx)
+                globalZoomIndex[i](idx) = nZoomBegin[indexMap[i]] + idx;
+            }
+            
             ++axisId;
           }
@@ -1282 +1305 @@
             nZoomBeginGlobal[indexMap[i]] = 0;
             nGlob[indexMap[i]] = 1;
+            globalZoomIndex[i].resize(1);
+            globalZoomIndex[i](0) = 0;
             ++scalarId;
           }
@@ -1289 +1314 @@
           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/trunk/src/node/zoom_axis.cpp

@@ -46 +46 @@
     axisGlobalSize   = axisDest->n_glo.getValue();
 
-    begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue();
-    n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue();
-    end   = begin+n-1;
+    bool zoomByIndex = !this->index.isEmpty() && (0 != this->index.numElements());
+
+    if (zoomByIndex)
+    {
+      begin = min(this->index);
+      end   = max(this->index);
+      n     = end - begin + 1;
+    }
+    else
+    {
+      begin = (this->begin.isEmpty()) ?  0 : this->begin.getValue();
+      n     = (this->n.isEmpty()) ?  axisGlobalSize : this->n.getValue();
+      end   = begin+n-1;
+    }
 
     if (begin < 0 || begin > axisGlobalSize - 1 || end < 0 || end > axisGlobalSize - 1
@@ -55 +66 @@
             << "One or more attributes among 'begin' (" << begin << "), 'end' (" << end << "), 'n' (" << n << ") "
             << "of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
+    
+    if (zoomByIndex && (!this->begin.isEmpty() || !this->n.isEmpty()))
+      ERROR("CZoomAxis::checkValid(CAxis* axisDest)",
+            << "Only one type of zoom is accepted. Define zoom by index with global_zoom_index or define zoom with begin and n. "
+            << "Axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
 
     this->begin.setValue(begin);

XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp

@@ -44 +44 @@
   zoomBegin_ = zoomAxis->begin.getValue();
   zoomSize_  = zoomAxis->n.getValue();
-  zoomEnd_   = zoomBegin_ + zoomSize_ - 1;
+  zoomEnd_   = zoomBegin_ + zoomSize_ - 1;  
 
   if (zoomSize_ > axisSource->n_glo.getValue())
@@ -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());
+  }
 }
 
@@ -60 +70 @@
 void CAxisAlgorithmZoom::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
 {
+  this->transformationMapping_.resize(1);
+  this->transformationWeight_.resize(1);
+
+  TransformationIndexMap& transMap = this->transformationMapping_[0];
+  TransformationWeightMap& transWeight = this->transformationWeight_[0];
+
   StdSize niSource = axisSrc_->n.getValue();
   StdSize ibeginSource = axisSrc_->begin.getValue();
@@ -69 +85 @@
   if (iend < ibegin) ni = 0;
 
-  this->transformationMapping_.resize(1);
-  this->transformationWeight_.resize(1);
-
-  TransformationIndexMap& transMap = this->transformationMapping_[0];
-  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);
+    }
   }
 
@@ -92 +116 @@
   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());
+  }
 }
 

XIOS/trunk/src/transformation/axis_algorithm_zoom.hpp

@@ -48 +48 @@
   StdSize zoomSize_;
 
+  std::vector<int> zoomIndex_;
+
 private: