Changeset 1460 for XIOS/dev/branch_openmp/src/node/axis.cpp

Timestamp:

03/22/18 10:43:20 (6 years ago)

Author:

yushan

Message:

branch_openmp merged with XIOS_DEV_CMIP6@1459

File:

• XIOS/dev/branch_openmp/src/node/axis.cpp (modified) (27 diffs)

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

@@ -10 +10 @@
 #include "context_server.hpp"
 #include "xios_spl.hpp"
-#include "inverse_axis.hpp"
-#include "zoom_axis.hpp"
-#include "interpolate_axis.hpp"
 #include "server_distribution_description.hpp"
 #include "client_server_mapping_distributed.hpp"
 #include "distribution_client.hpp"
 
+using namespace ep_lib;
+
 namespace xios {
 
-   /// ////////////////////// Définitions ////////////////////// ///
+   /// ////////////////////// Definitions ////////////////////// ///
 
    CAxis::CAxis(void)
       : CObjectTemplate<CAxis>()
-      , CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
+      , CAxisAttributes(), isChecked(false), relFiles()
+      , areClientAttributesChecked_(false)
       , isClientAfterTransformationChecked(false)
-      , isDistributed_(false), hasBounds_(false), isCompressible_(false)
-      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), hasLabel(false)
+      , hasBounds(false), isCompressible_(false)
+      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
+      , transformationMap_()
+      , hasValue(false), hasLabel(false)
+      , computedWrittenIndex_(false)
+      , clients()
    {
    }
@@ -33 +36 @@
    CAxis::CAxis(const StdString & id)
       : CObjectTemplate<CAxis>(id)
-      , CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
+      , CAxisAttributes(), isChecked(false), relFiles()
+      , areClientAttributesChecked_(false)
       , isClientAfterTransformationChecked(false)
-      , isDistributed_(false), hasBounds_(false), isCompressible_(false)
-      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), hasLabel(false)
+      , hasBounds(false), isCompressible_(false)
+      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
+      , transformationMap_()
+      , hasValue(false), hasLabel(false)
+      , computedWrittenIndex_(false)
+      , clients()
    {
    }
@@ -52 +59 @@
      m["inverse_axis"] = TRANS_INVERSE_AXIS;
      m["reduce_domain"] = TRANS_REDUCE_DOMAIN_TO_AXIS;
+     m["reduce_axis"] = TRANS_REDUCE_AXIS_TO_AXIS;
      m["extract_domain"] = TRANS_EXTRACT_DOMAIN_TO_AXIS;
+     m["temporal_splitting"] = TRANS_TEMPORAL_SPLITTING;
+     m["duplicate_scalar"] = TRANS_DUPLICATE_SCALAR_TO_AXIS;
    }
 
@@ -63 +73 @@
      (*CAxis::transformationMapList_ptr)["reduce_domain"]    = TRANS_REDUCE_DOMAIN_TO_AXIS;
      (*CAxis::transformationMapList_ptr)["extract_domain"]   = TRANS_EXTRACT_DOMAIN_TO_AXIS;
+     (*CAxis::transformationMapList_ptr)["reduce_axis"]      = TRANS_REDUCE_AXIS_TO_AXIS;
+     (*CAxis::transformationMapList_ptr)["temporal_splitting"] = TRANS_TEMPORAL_SPLITTING;
+     (*CAxis::transformationMapList_ptr)["duplicate_scalar"] = TRANS_DUPLICATE_SCALAR_TO_AXIS;
    }
 
@@ -84 +97 @@
    bool CAxis::isDistributed(void) const
    {
-      return isDistributed_;
+      bool distributed = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) ||
+             (!this->n.isEmpty() && (this->n != this->n_glo));
+      // A same stupid condition to make sure that if there is only one client, axis
+      // should be considered to be distributed. This should be a temporary solution     
+      distributed |= (1 == CContext::getCurrent()->client->clientSize);
+      return distributed;
    }
 
@@ -109 +127 @@
    //----------------------------------------------------------------
 
-   const std::vector<int>& CAxis::getIndexesToWrite(void) const
-   {
-     return indexesToWrite;
-   }
-
    /*!
      Returns the number of indexes written by each server.
      \return the number of indexes written by each server
    */
-   int CAxis::getNumberWrittenIndexes() const
-   {
-     return numberWrittenIndexes_;
+   int CAxis::getNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   {
+     int writtenSize;
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     return numberWrittenIndexes_[writtenSize];
    }
 
@@ -127 +142 @@
      \return the total number of indexes written by the servers
    */
-   int CAxis::getTotalNumberWrittenIndexes() const
-   {
-     return totalNumberWrittenIndexes_;
+   int CAxis::getTotalNumberWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   {
+     int writtenSize;
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     return totalNumberWrittenIndexes_[writtenSize];
    }
 
@@ -136 +153 @@
      \return the offset of indexes written by each server
    */
-   int CAxis::getOffsetWrittenIndexes() const
-   {
-     return offsetWrittenIndexes_;
+   int CAxis::getOffsetWrittenIndexes(ep_lib::MPI_Comm writtenCom)
+   {
+     int writtenSize;
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     return offsetWrittenIndexes_[writtenSize];
+   }
+
+   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(ep_lib::MPI_Comm writtenCom)
+   {
+     int writtenSize;
+     ep_lib::MPI_Comm_size(writtenCom, &writtenSize);
+     return compressedIndexToWriteOnServer[writtenSize];
    }
 
    //----------------------------------------------------------------
 
-   /*!
+      /*!
     * Compute the minimum buffer size required to send the attributes to the server(s).
     *
     * \return A map associating the server rank with its minimum buffer size.
     */
-   std::map<int, StdSize> CAxis::getAttributesBufferSize()
-   {
-     CContextClient* client = CContext::getCurrent()->client;
-
-     std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes();
-
-     bool isNonDistributed = (n == n_glo);
+   std::map<int, StdSize> CAxis::getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
+                                                         CServerDistributionDescription::ServerDistributionType distType)
+   {
+
+     std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes(client);
+
+//     bool isNonDistributed = (n_glo == n);
+     bool isDistributed = (orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
+                         || (index.numElements() != n_glo);
 
      if (client->isServerLeader())
@@ -161 +189 @@
        size_t size = 6 * sizeof(size_t);
        // size estimation for sendNonDistributedValue
-       if (isNonDistributed)
-         size = std::max(size, CArray<double,1>::size(n_glo) + (isCompressible_ ? CArray<int,1>::size(n_glo) : 0));
+       if (!isDistributed)
+       {
+//         size = std::max(size, CArray<double,1>::size(n_glo) + (isCompressible_ ? CArray<int,1>::size(n_glo) : 0));
+         size += CArray<int,1>::size(n_glo);
+         size += CArray<int,1>::size(n_glo);
+         size += CArray<bool,1>::size(n_glo);
+         size += CArray<double,1>::size(n_glo);
+         if (hasBounds)
+           size += CArray<double,2>::size(2*n_glo);
+         if (hasLabel)
+          size += CArray<StdString,1>::size(n_glo);
+       }
        size += CEventClient::headerSize + getId().size() + sizeof(size_t);
 
@@ -171 +209 @@
            attributesSizes[*itRank] = size;
        }
+       const std::list<int>& ranksNonLeaders = client->getRanksServerNotLeader();
+       for (std::list<int>::const_iterator itRank = ranksNonLeaders.begin(), itRankEnd = ranksNonLeaders.end(); itRank != itRankEnd; ++itRank)
+       {
+         if (size > attributesSizes[*itRank])
+           attributesSizes[*itRank] = size;
+       }
+
      }
 
-     if (!isNonDistributed)
+     if (isDistributed)
      {
        // size estimation for sendDistributedValue
-       std::map<int, std::vector<size_t> >::const_iterator it, ite = indSrv_.end();
-       for (it = indSrv_.begin(); it != ite; ++it)
+       boost::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end();
+       for (it = indSrv_[client->serverSize].begin(); it != ite; ++it)
        {
-         size_t sizeIndexEvent = CArray<int,1>::size(it->second.size());
-         if (isCompressible_)
-           sizeIndexEvent += CArray<int,1>::size(indWrittenSrv_[it->first].size());
-
-         size_t sizeValEvent = CArray<double,1>::size(it->second.size());
-         if (hasBounds_)
-           sizeValEvent += CArray<double,2>::size(2 * it->second.size());
- 
+         size_t size = 6 * sizeof(size_t);
+         size += CArray<int,1>::size(it->second.size());
+         size += CArray<int,1>::size(it->second.size());
+         size += CArray<bool,1>::size(it->second.size());
+         size += CArray<double,1>::size(it->second.size());
+         if (hasBounds)
+           size += CArray<double,2>::size(2 * it->second.size());
          if (hasLabel)
-           sizeValEvent += CArray<StdString,1>::size(it->second.size());
-
-         size_t size = CEventClient::headerSize + getId().size() + sizeof(size_t) + std::max(sizeIndexEvent, sizeValEvent);
+           size += CArray<StdString,1>::size(it->second.size());
+
+         size += CEventClient::headerSize + getId().size() + sizeof(size_t);
          if (size > attributesSizes[it->first])
            attributesSizes[it->first] = size;
@@ -213 +257 @@
    }
 
-   void CAxis::fillInValues(const CArray<double,1>& values)
-   {
-     this->value = values;
-   }
-
+   /*!
+     Check common attributes of an axis.
+     This check should be done in the very beginning of work flow
+   */
    void CAxis::checkAttributes(void)
    {
@@ -260 +303 @@
       }
 
+      // Remove this check because it doen't make sense in case of a hole or overlapping axes
       if (!this->value.isEmpty())
       {
-        StdSize true_size = value.numElements();
-        if (this->n.getValue() != true_size)
-          ERROR("CAxis::checkAttributes(void)",
-                << "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
-                << "The axis is wrongly defined, attribute 'value' has a different size (" << true_size << ") than the one defined by the \'size\' attribute (" << n.getValue() << ").");
+//        StdSize true_size = value.numElements();
+//        if (this->n.getValue() != true_size)
+//          ERROR("CAxis::checkAttributes(void)",
+//                << "[ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] "
+//                << "The axis is wrongly defined, attribute 'value' has a different size (" << true_size << ") than the one defined by the \'size\' attribute (" << n.getValue() << ").");
         this->hasValue = true;
       }
 
-      this->checkData();
-      this->checkZoom();
-      this->checkMask();
       this->checkBounds();
-      this->checkLabel();
-
-      isDistributed_ = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) ||
-                       (!this->n.isEmpty() && (this->n != this->n_glo));
-
-      // A same stupid condition to make sure that if there is only one client, axis
-      // should be considered to be distributed. This should be a temporary solution     
-      isDistributed_ |= (1 == CContext::getCurrent()->client->clientSize);
-   }
-
+
+      CContext* context=CContext::getCurrent();
+      if (context->hasClient)
+      {
+        this->checkData();
+        this->checkZoom();
+        this->checkMask();
+        this->checkLabel();
+      }
+   }
+
+   /*!
+      Check the validity of data and fill in values if any.
+   */
    void CAxis::checkData()
    {
@@ -306 +351 @@
    }
 
+   /*!
+     Check validity of zoom info and fill in values if any.
+   */
    void CAxis::checkZoom(void)
    {
      if (global_zoom_begin.isEmpty()) global_zoom_begin.setValue(0);
      if (global_zoom_n.isEmpty()) global_zoom_n.setValue(n_glo.getValue());
-   }
-
+     if (zoom_index.isEmpty())
+     {
+       zoom_index.setValue(index.getValue());
+     }
+     if (zoom_n.isEmpty()) zoom_n.setValue(n);
+     if (zoom_begin.isEmpty()) zoom_begin.setValue(begin);
+   }
+
+    size_t CAxis::getGlobalWrittenSize(void)
+    {
+      if (zoomByIndex()) return  global_zoom_index.numElements();
+      else return global_zoom_n ;
+    }
+
+   /*!
+     Check validity of mask info and fill in values if any.
+   */
    void CAxis::checkMask()
    {
@@ -333 +396 @@
    }
 
-  void CAxis::checkBounds()
-  {
-    if (!bounds.isEmpty())
-    {
-      if (bounds.extent(0) != 2 || bounds.extent(1) != n)
-        ERROR("CAxis::checkAttributes(void)",
-              << "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension 2 x axis size." << std::endl
-              << "Axis size is " << n.getValue() << "." << std::endl
-              << "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1) << ".");
-      hasBounds_ = true;
-    }
-    else hasBounds_ = false;
-  }
+   /*!
+     Check validity of bounds info and fill in values if any.
+   */
+   void CAxis::checkBounds()
+   {
+     if (!bounds.isEmpty())
+     {
+       if (bounds.extent(0) != 2 || bounds.extent(1) != n)
+         ERROR("CAxis::checkAttributes(void)",
+               << "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension 2 x axis size." << std::endl
+               << "Axis size is " << n.getValue() << "." << std::endl
+               << "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1) << ".");
+       hasBounds = true;
+     }
+     else hasBounds = false;
+   }
 
   void CAxis::checkLabel()
@@ -360 +426 @@
     else hasLabel = false;
   }
+
+  /*!
+    Check whether we can do compressed output
+  */
   void CAxis::checkEligibilityForCompressedOutput()
   {
@@ -366 +436 @@
   }
 
+  /*
+    Check whether we do zooming by indexing
+    return true if do zooming by index
+  */
   bool CAxis::zoomByIndex()
   {
@@ -371 +445 @@
   }
 
+  /*!
+    Dispatch event from the lower communication layer then process event according to its type
+  */
   bool CAxis::dispatchEvent(CEventServer& event)
-   {
-      if (SuperClass::dispatchEvent(event)) return true;
-      else
-      {
-        switch(event.type)
-        {
-           case EVENT_ID_SERVER_ATTRIBUT :
-             recvServerAttribut(event);
-             return true;
-             break;
-           case EVENT_ID_INDEX:
-            recvIndex(event);
+  {
+     if (SuperClass::dispatchEvent(event)) return true;
+     else
+     {
+       switch(event.type)
+       {
+          case EVENT_ID_DISTRIBUTION_ATTRIBUTE :
+            recvDistributionAttribute(event);
             return true;
             break;
-          case EVENT_ID_DISTRIBUTED_VALUE:
-            recvDistributedValue(event);
-            return true;
-            break;
-          case EVENT_ID_NON_DISTRIBUTED_VALUE:
-            recvNonDistributedValue(event);
-            return true;
-            break;
-           default :
-             ERROR("bool CAxis::dispatchEvent(CEventServer& event)",
-                    << "Unknown Event");
-           return false;
-         }
-      }
-   }
-
+         case EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES:
+           recvNonDistributedAttributes(event);
+           return true;
+           break;
+         case EVENT_ID_DISTRIBUTED_ATTRIBUTES:
+           recvDistributedAttributes(event);
+           return true;
+           break;
+          default :
+            ERROR("bool CAxis::dispatchEvent(CEventServer& event)",
+                   << "Unknown Event");
+          return false;
+        }
+     }
+  }
+  
+  /*!
+     Check attributes on client side (This name is still adequate???)
+   */
    void CAxis::checkAttributesOnClient()
    {
      if (this->areClientAttributesChecked_) return;
 
-     this->checkAttributes();
+     CContext* context=CContext::getCurrent();
+     if (context->hasClient && !context->hasServer) this->checkAttributes();
 
      this->areClientAttributesChecked_ = true;
    }
 
+   /*
+     The (spatial) transformation sometimes can change attributes of an axis (e.g zoom can change mask or generate can change whole attributes)
+     Therefore, we should recheck them.
+   */
    void CAxis::checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid,
                                                           CServerDistributionDescription::ServerDistributionType distType)
@@ -418 +499 @@
      if (this->isClientAfterTransformationChecked) return;
      if (context->hasClient)
-     {
-       if (n.getValue() != n_glo.getValue()) computeConnectedServer(globalDim, orderPositionInGrid, distType);
+     {        
+       if (orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
+         computeConnectedClients(globalDim, orderPositionInGrid, distType);
+       else if (index.numElements() != n_glo) computeConnectedClients(globalDim, orderPositionInGrid,  CServerDistributionDescription::ROOT_DISTRIBUTION);
      }
 
@@ -425 +508 @@
    }
 
-   // Send all checked attributes to server
+   /*
+     Send all checked attributes to server? (We dont have notion of server any more so client==server)
+     \param [in] globalDim global dimension of grid containing this axis
+     \param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
+     \param [in] distType distribution type of the server. For now, we only have band distribution.
+
+   */
    void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
                                      CServerDistributionDescription::ServerDistributionType distType)
@@ -434 +523 @@
 
      if (this->isChecked) return;
-     if (context->hasClient)
+     if (context->hasClient) sendAttributes(globalDim, orderPositionInGrid, distType);    
+
+     this->isChecked = true;
+   }
+
+   /*!
+    Send attributes from one client to other clients
+    \param[in] globalDim global dimension of grid which contains this axis
+    \param[in] order
+  */
+  void CAxis::sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
+                             CServerDistributionDescription::ServerDistributionType distType)
+  {
+     sendDistributionAttribute(globalDim, orderPositionInGrid, distType);
+
+     // if (index.numElements() == n_glo.getValue())
+     if ((orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
+         || (index.numElements() != n_glo))
      {
-       sendServerAttribut(globalDim, orderPositionInGrid, distType);
-       if (hasValue) sendValue();
+       sendDistributedAttributes();       
      }
-
-     this->isChecked = true;
-   }
-
-  void CAxis::sendValue()
-  {
-     if (n.getValue() == n_glo.getValue())
-       sendNonDistributedValue();
      else
-       sendDistributedValue();
-  }
-
-  void CAxis::computeConnectedServer(const std::vector<int>& globalDim, int orderPositionInGrid,
+     {
+       sendNonDistributedAttributes();    
+     }     
+  }
+
+  /*
+    Compute the connection between group of clients (or clients/servers).
+    (E.g: Suppose we have 2 group of clients in two model: A (client role) connect to B (server role),
+    this function calculate number of clients B connect to one client of A)
+     \param [in] globalDim global dimension of grid containing this axis
+     \param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
+     \param [in] distType distribution type of the server. For now, we only have band distribution.
+  */
+  void CAxis::computeConnectedClients(const std::vector<int>& globalDim, int orderPositionInGrid,
                                      CServerDistributionDescription::ServerDistributionType distType)
   {
     CContext* context = CContext::getCurrent();
-    CContextClient* client = context->client;
-    int nbServer = client->serverSize;
-    int range, clientSize = client->clientSize;
-    int rank = client->clientRank;
-
-    size_t ni = this->n.getValue();
-    size_t ibegin = this->begin.getValue();
-    size_t zoom_end = global_zoom_begin+global_zoom_n-1;
-    size_t nZoomCount = 0;
-    size_t nbIndex = index.numElements();
-
-    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;
-    }*/
+
+    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1;
+
+    connectedServerRank_.clear();
+    nbSenders.clear();
+
+    for (int p = 0; p < nbSrvPools; ++p)
+    {
+      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client;
+      int nbServer = client->serverSize;
+      int range, clientSize = client->clientSize;
+      int rank = client->clientRank;
+
+      if (connectedServerRank_.find(nbServer) == connectedServerRank_.end())
+      {
+        size_t ni = this->n.getValue();
+        size_t ibegin = this->begin.getValue();
+        size_t global_zoom_end = global_zoom_begin+global_zoom_n-1;
+        size_t nZoomCount = 0;
+        size_t nbIndex = index.numElements();
+
+        // First of all, we should compute the mapping of the global index and local index of the current client
+        if (globalLocalIndexMap_.empty())
+        {
+          for (size_t idx = 0; idx < nbIndex; ++idx)
+          {
+            globalLocalIndexMap_[index(idx)] = idx;
+          }
+        }
+
+        // Calculate the compressed index if any
+        std::set<int> writtenInd;
+        if (isCompressible_)
+        {
+          for (int idx = 0; idx < data_index.numElements(); ++idx)
+          {
+            int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni);
+
+            if (ind >= 0 && ind < ni && mask(ind))
+            {
+              ind += ibegin;
+              if (ind >= global_zoom_begin && ind <= global_zoom_end)
+                writtenInd.insert(ind);
+            }
+          }
+        }
+
+        // Compute the global index of the current client (process) hold
+        std::vector<int> nGlobAxis(1);
+        nGlobAxis[0] = n_glo.getValue();
+
+        size_t globalSizeIndex = 1, indexBegin, indexEnd;
+        for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[i];
+        indexBegin = 0;
+        if (globalSizeIndex <= clientSize)
+        {
+          indexBegin = rank%globalSizeIndex;
+          indexEnd = indexBegin;
+        }
+        else
+        {
+          for (int i = 0; i < clientSize; ++i)
+          {
+            range = globalSizeIndex / clientSize;
+            if (i < (globalSizeIndex%clientSize)) ++range;
+            if (i == client->clientRank) break;
+            indexBegin += range;
+          }
+          indexEnd = indexBegin + range - 1;
+        }
+
+        CArray<size_t,1> globalIndex(index.numElements());
+        for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
+          globalIndex(idx) = index(idx);
+
+        // Describe the distribution of server side
+
+        CServerDistributionDescription serverDescription(nGlobAxis, nbServer, distType);
+
+        std::vector<int> serverZeroIndex;
+        serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);      
+
+        std::list<int> serverZeroIndexLeader;
+        std::list<int> serverZeroIndexNotLeader; 
+        CContextClient::computeLeader(client->clientRank, client->clientSize, serverZeroIndex.size(), serverZeroIndexLeader, serverZeroIndexNotLeader);
+
+        for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it)
+          *it = serverZeroIndex[*it];
+
+        // Find out the connection between client and server side
+        CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
+        clientServerMap->computeServerIndexMapping(globalIndex, nbServer);
+        CClientServerMapping::GlobalIndexMap& globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();      
+
+        indSrv_[nbServer].swap(globalIndexAxisOnServer);
+
+        if (distType==CServerDistributionDescription::ROOT_DISTRIBUTION)
+        {
+          for(int i=1; i<nbServer; ++i) 
+          {
+            indSrv_[nbServer].insert(pair<int, vector<size_t> >(i,indSrv_[nbServer][0]) ) ;
+          }
+
+          serverZeroIndexLeader.clear() ;
+        }
+
+        CClientServerMapping::GlobalIndexMap::const_iterator it  = indSrv_[nbServer].begin(),
+                                                             ite = indSrv_[nbServer].end();
+
+        for (it = indSrv_[nbServer].begin(); it != ite; ++it) connectedServerRank_[nbServer].push_back(it->first);
+
+        for (std::list<int>::const_iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it)
+          connectedServerRank_[nbServer].push_back(*it);
+
+         // Even if a client has no index, it must connect to at least one server and 
+         // send an "empty" data to this server
+         if (connectedServerRank_[nbServer].empty())
+          connectedServerRank_[nbServer].push_back(client->clientRank % client->serverSize);
+
+         nbSenders[nbServer] = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]);
+
+        delete clientServerMap;
+      }
+    }
+  }
+
+  /*
+    Compute the index of data to write into file
+    (Different from the previous version, this version of XIOS allows data be written into file (classical role),
+    or transfered to another clients)
+  */
+  void CAxis::computeWrittenIndex()
+  {  
+    if (computedWrittenIndex_) return;
+    computedWrittenIndex_ = true;
+
+    CContext* context=CContext::getCurrent();      
+    CContextServer* server = context->server; 
+
+    // We describe the distribution of client (server) on which data are written
+    std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1);
+    nBegin[0]       = zoom_begin;
+    nSize[0]        = zoom_n;   
+    nBeginGlobal[0] = 0; 
+    nGlob[0]        = n_glo;
+    CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob); 
+    const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
+
+    // Because all written data are local on a client, 
+    // we need to compute the local index on the server from its corresponding global index
+    size_t nbWritten = 0, indGlo;      
+    boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+                                                        ite = globalLocalIndexMap_.end(), it;          
+    CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
+                                     itSrve = writtenGlobalIndex.end(), itSrv;  
+    if (!zoomByIndex())
+    {   
+      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+      {
+        indGlo = *itSrv;
+        if (ite != globalLocalIndexMap_.find(indGlo))
+        {          
+          ++nbWritten;
+        }                 
+      }
+
+      localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements());
+//      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;
+         }
+      }
+    }
+
+  }
+
+  void CAxis::computeWrittenCompressedIndex(ep_lib::MPI_Comm writtenComm)
+  {
+    int writtenCommSize;
+    ep_lib::MPI_Comm_size(writtenComm, &writtenCommSize);
+    if (compressedIndexToWriteOnServer.find(writtenCommSize) != compressedIndexToWriteOnServer.end())
+      return;
+
+    if (isCompressible())
+    {
+      size_t nbWritten = 0, indGlo;
+      CContext* context=CContext::getCurrent();      
+      CContextServer* server = context->server; 
+
+      // We describe the distribution of client (server) on which data are written
+      std::vector<int> nBegin(1), nSize(1), nBeginGlobal(1), nGlob(1);
+      nBegin[0]       = zoom_begin;
+      nSize[0]        = zoom_n;   
+      nBeginGlobal[0] = 0; 
+      nGlob[0]        = n_glo;
+      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob); 
+      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
+      boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+                                                          ite = globalLocalIndexMap_.end(), it;   
+
+      CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
+                                       itSrve = writtenGlobalIndex.end(), itSrv;
+      boost::unordered_map<size_t,size_t> localGlobalIndexMap;
+      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+      {
+        indGlo = *itSrv;
+        if (ite != globalLocalIndexMap_.find(indGlo))
+        {
+          localGlobalIndexMap[localIndexToWriteOnServer(nbWritten)] = indGlo;
+          ++nbWritten;
+        }                 
+      }
+
+      nbWritten = 0;
+      for (int idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
+        {
+          ++nbWritten;
+        }
+      }
+
+      compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten);
+      nbWritten = 0;
+      for (int idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_index(idx)))
+        {
+          compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_index(idx)];
+          ++nbWritten;
+        }
+      }
+
+      numberWrittenIndexes_[writtenCommSize] = nbWritten;
+      if (isDistributed())
+      {
+             
+        ep_lib::MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        ep_lib::MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
+      }
+      else
+        totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize];
+    }
+  }
+
+  /*!
+    Send distribution information from a group of client (client role) to another group of client (server role)
+    The distribution of a group of client (server role) is imposed by the group of client (client role)
+    \param [in] globalDim global dimension of grid containing this axis
+    \param [in] orderPositionInGrid the relative order of this axis in the grid (e.g grid composed of domain+axis -> orderPositionInGrid is 2)
+    \param [in] distType distribution type of the server. For now, we only have band distribution.
+  */
+  void CAxis::sendDistributionAttribute(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                        CServerDistributionDescription::ServerDistributionType distType)
+  {
+    std::list<CContextClient*>::iterator it;
+    for (it=clients.begin(); it!=clients.end(); ++it)
+    {
+      CContextClient* client = *it;
+      int nbServer = client->serverSize;
+
+      CServerDistributionDescription serverDescription(globalDim, nbServer);
+      serverDescription.computeServerDistribution();
+
+      std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
+      std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
+
+      CEventClient event(getType(),EVENT_ID_DISTRIBUTION_ATTRIBUTE);
+      if (client->isServerLeader())
+      {
+        std::list<CMessage> msgs;
+
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          // Use const int to ensure CMessage holds a copy of the value instead of just a reference
+          const int begin = serverIndexBegin[*itRank][orderPositionInGrid];
+          const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid];
+          const int end   = begin + ni - 1;          
+
+          msgs.push_back(CMessage());
+          CMessage& msg = msgs.back();
+          msg << this->getId();
+          msg << ni << begin << end;          
+          msg << isCompressible_;                    
+
+          event.push(*itRank,1,msg);
+        }
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+    }
+  }
+
+  /*
+    Receive distribution attribute from another client
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvDistributionAttribute(CEventServer& event)
+  {
+    CBufferIn* buffer = event.subEvents.begin()->buffer;
+    string axisId;
+    *buffer >> axisId;
+    get(axisId)->recvDistributionAttribute(*buffer);
+  }
+
+  /*
+    Receive distribution attribute from another client
+    \param [in] buffer buffer containing data of these attributes
+  */
+  void CAxis::recvDistributionAttribute(CBufferIn& buffer)
+  {
+    int ni_srv, begin_srv, end_srv;
+    int global_zoom_end, zoom_end;
+    bool zoomIndex = zoomByIndex();
     
-    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 < zoom_size; ++idx)
-    {
-      size_t globalZoomIndex = zoomByIndex() ? global_zoom_index(idx) : global_zoom_begin + idx;
-      if (globalZoomIndex >= minInd && globalZoomIndex <= maxInd)
-      {
-        globalAxisZoom[nZoomCount] = globalZoomIndex;
-        ++nZoomCount;
-      }
-    }
-
-    std::set<int> writtenInd;
-    if (isCompressible_)
-    {
+    std::vector<int> zoom_index_tmp;
+    std::vector<int>::iterator itZoomBegin, itZoomEnd, itZoom;
+
+    buffer >> ni_srv >> begin_srv >> end_srv;    
+    buffer >> isCompressible_;            
+
+    // Set up new local size of axis on the receiving clients
+    n.setValue(ni_srv);
+    begin.setValue(begin_srv);
+
+    // 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(zoom_index_tmp.begin(), itZoomBegin)
+                           : 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_n = 0; zoom_begin=global_zoom_begin; //0; zoom_begin = 0; 
+    }
+
+    if (n_glo == n)
+    {
+      zoom_begin = zoomIndex ? std::distance(itZoomBegin, zoom_index_tmp.begin())
+                             : global_zoom_begin;      
+      zoom_n     = zoomIndex ? zoom_index_tmp.size() : global_zoom_n;
+    }
+  }
+
+  /*
+    Send attributes of axis from a group of client to other group of clients/servers 
+    on supposing that these attributes are not distributed among the sending group
+    In the future, if new attributes are added, they should also be processed in this function
+  */
+  void CAxis::sendNonDistributedAttributes()
+  {
+    std::list<CContextClient*>::iterator it;
+    for (it=clients.begin(); it!=clients.end(); ++it)
+  {
+    CContextClient* client = *it;
+
+      CEventClient event(getType(), EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES);
+      size_t nbIndex = index.numElements();
+      size_t nbDataIndex = 0;
+
       for (int idx = 0; idx < data_index.numElements(); ++idx)
       {
-        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni);
-
-        if (ind >= 0 && ind < ni && mask(ind))
-        {
-          ind += ibegin;
-          if (ind >= global_zoom_begin && ind <= zoom_end)
-            writtenInd.insert(ind);
-        }
-      }
-    }
-
-    CServerDistributionDescription serverDescriptionGlobal(globalDim, nbServer);
-    int distributedDimensionOnServer = serverDescriptionGlobal.getDimensionDistributed();
-    CClientServerMapping::GlobalIndexMap globalIndexAxisOnServer;
-    if (distributedDimensionOnServer == orderPositionInGrid) // So we have distributed axis on client side and also on server side*
-    {
-      std::vector<int> nGlobAxis(1);
-      nGlobAxis[0] = n_glo.getValue();
-
-      size_t globalSizeIndex = 1, indexBegin, indexEnd;
-      for (int i = 0; i < nGlobAxis.size(); ++i) globalSizeIndex *= nGlobAxis[i];
-      indexBegin = 0;
-      if (globalSizeIndex <= clientSize)
-      {
-        indexBegin = rank%globalSizeIndex;
-        indexEnd = indexBegin;
-      }
-      else
-      {
-        for (int i = 0; i < clientSize; ++i)
-        {
-          range = globalSizeIndex / clientSize;
-          if (i < (globalSizeIndex%clientSize)) ++range;
-          if (i == client->clientRank) break;
-          indexBegin += range;
-        }
-        indexEnd = indexBegin + range - 1;
-      }
-
-      CServerDistributionDescription serverDescription(nGlobAxis, nbServer);
-      serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd));
-      CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
-      clientServerMap->computeServerIndexMapping(globalIndexAxis);
-      globalIndexAxisOnServer = clientServerMap->getGlobalIndexOnServer();
-      delete clientServerMap;
-    }
-    else
-    {
-      std::vector<size_t> globalIndexServer(n_glo.getValue());
-      for (size_t idx = 0; idx < n_glo.getValue(); ++idx)
-      {
-        globalIndexServer[idx] = idx;
-      }
-
-      for (int idx = 0; idx < nbServer; ++idx)
-      {
-        globalIndexAxisOnServer[idx] = globalIndexServer;
-      }
-    }
-
-    CClientServerMapping::GlobalIndexMap::const_iterator it = globalIndexAxisOnServer.begin(),
-                                                         ite = globalIndexAxisOnServer.end();
-    std::vector<size_t>::const_iterator itbVec = (globalAxisZoom).begin(),
-                                        iteVec = (globalAxisZoom).end();
-    indSrv_.clear();
-    indWrittenSrv_.clear();
-    for (; it != ite; ++it)
-    {
-      int rank = it->first;
-      const std::vector<size_t>& globalIndexTmp = it->second;
-      int nb = globalIndexTmp.size();
-
-      for (int i = 0; i < nb; ++i)
-      {
-        if (std::binary_search(itbVec, iteVec, globalIndexTmp[i]))
-        {
-          indSrv_[rank].push_back(globalIndexTmp[i]);
-        }
-
-        if (writtenInd.count(globalIndexTmp[i]))
-        {
-          indWrittenSrv_[rank].push_back(globalIndexTmp[i]);
-        }
-      }
-    }
-
-    connectedServerRank_.clear();
-    for (it = globalIndexAxisOnServer.begin(); it != ite; ++it) {
-      connectedServerRank_.push_back(it->first);
-    }
-
-    if (!indSrv_.empty())
-    {
-      std::map<int, vector<size_t> >::const_iterator itIndSrv  = indSrv_.begin(),
-                                                     iteIndSrv = indSrv_.end();
-      connectedServerRank_.clear();
-      for (; itIndSrv != iteIndSrv; ++itIndSrv)
-        connectedServerRank_.push_back(itIndSrv->first);
-    }
-    nbConnectedClients_ = CClientServerMapping::computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_);
-  }
-
-  void CAxis::sendNonDistributedValue()
-  {
-    CContext* context = CContext::getCurrent();
-    CContextClient* client = context->client;
-    CEventClient event(getType(), EVENT_ID_NON_DISTRIBUTED_VALUE);
-
-    int zoom_end = global_zoom_begin + global_zoom_n - 1;
-    int nb = 0;
-/*    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;
-    }
-
-    int nbWritten = 0;
-    if (isCompressible_)
-    {
+        int ind = data_index(idx);
+        if (ind >= 0 && ind < nbIndex) ++nbDataIndex;
+      }
+
+      CArray<int,1> dataIndex(nbDataIndex);
+      nbDataIndex = 0;
       for (int idx = 0; idx < data_index.numElements(); ++idx)
       {
-        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, n);
-
-        if (ind >= 0 && ind < n && mask(ind))
-        {
-          ind += begin;
-          if (ind >= global_zoom_begin && ind <= zoom_end)
-            ++nbWritten;
-        }
-      }
-    }
-
-    CArray<double,1> val(nb);
-    nb = 0;
-/*    for (size_t idx = 0; idx < n; ++idx)
-    {
-      size_t globalIndex = begin + idx;
-      if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end)
-      {
-        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;
-      }
-    }
-
-    CArray<int, 1> writtenInd(nbWritten);
-    nbWritten = 0;
-    if (isCompressible_)
-    {
-      for (int idx = 0; idx < data_index.numElements(); ++idx)
-      {
-        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, n);
-
-        if (ind >= 0 && ind < n && mask(ind))
-        {
-          ind += begin;
-          if (ind >= global_zoom_begin && ind <= zoom_end)
-          {
-            writtenInd(nbWritten) = ind;
-            ++nbWritten;
-          }
-        }
-      }
-    }
-
-    if (client->isServerLeader())
-    {
-      std::list<CMessage> msgs;
-
-      const std::list<int>& ranks = client->getRanksServerLeader();
-      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
-      {
-        msgs.push_back(CMessage());
-        CMessage& msg = msgs.back();
-        msg << this->getId();
-        msg << val;
-        if (isCompressible_)
-          msg << writtenInd;
-        event.push(*itRank, 1, msg);
-      }
-      client->sendEvent(event);
-    }
-    else client->sendEvent(event);
-  }
-
-  void CAxis::sendDistributedValue(void)
-  {
-    int ns, n, i, j, ind, nv, idx;
-    CContext* context = CContext::getCurrent();
-    CContextClient* client=context->client;
-
-    // send value for each connected server
-    CEventClient eventIndex(getType(), EVENT_ID_INDEX);
-    CEventClient eventVal(getType(), EVENT_ID_DISTRIBUTED_VALUE);
-
-    list<CMessage> list_msgsIndex, list_msgsVal;
-    list<CArray<int,1> > list_indi;
-    list<CArray<int,1> > list_writtenInd;
-    list<CArray<double,1> > list_val;
-    list<CArray<double,2> > list_bounds;
-    list<CArray<StdString,1> > list_label;
-
-    std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
-    iteMap = indSrv_.end();
-    for (int k = 0; k < connectedServerRank_.size(); ++k)
-    {
-      int nbData = 0;
-      int rank = connectedServerRank_[k];
-      it = indSrv_.find(rank);
-      if (iteMap != it)
-        nbData = it->second.size();
-
-      list_indi.push_back(CArray<int,1>(nbData));
-      list_val.push_back(CArray<double,1>(nbData));
-
-      if (hasBounds_)
-      {
-        list_bounds.push_back(CArray<double,2>(2,nbData));
-      }
-      
-      if (hasLabel)
-      {
-        list_label.push_back(CArray<StdString,1>(nbData));
-      }
-
-      CArray<int,1>& indi = list_indi.back();
-      CArray<double,1>& val = list_val.back();
-
-      for (n = 0; n < nbData; ++n)
-      {
-        idx = static_cast<int>(it->second[n]);
-        ind = idx - begin;
-
-        val(n) = value(ind);
-        indi(n) = idx;
-
-        if (hasBounds_)
-        {
-          CArray<double,2>& boundsVal = list_bounds.back();
-          boundsVal(0, n) = bounds(0,n);
-          boundsVal(1, n) = bounds(1,n);
-        }
-        
-        if (hasLabel)
-        {
-          CArray<StdString,1>& labelVal = list_label.back();
-          labelVal(n) = label(n);
-        }
-      }
-
-      list_msgsIndex.push_back(CMessage());
-      list_msgsIndex.back() << this->getId() << list_indi.back();
-
-      if (isCompressible_)
-      {
-        std::vector<int>& writtenIndSrc = indWrittenSrv_[rank];
-        list_writtenInd.push_back(CArray<int,1>(writtenIndSrc.size()));
-        CArray<int,1>& writtenInd = list_writtenInd.back();
-
-        for (n = 0; n < writtenInd.numElements(); ++n)
-          writtenInd(n) = writtenIndSrc[n];
-
-        list_msgsIndex.back() << writtenInd;
-      }
-
-      list_msgsVal.push_back(CMessage());
-      list_msgsVal.back() << this->getId() << list_val.back();
-
-      if (hasBounds_)
-      {
-        list_msgsVal.back() << list_bounds.back();
-      }
- 
-      if (hasLabel)
-      {
-        list_msgsVal.back() << list_label.back();
-      }
-
-      eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back());
-      eventVal.push(rank, nbConnectedClients_[rank], list_msgsVal.back());
-    }
-
-    client->sendEvent(eventIndex);
-    client->sendEvent(eventVal);
-  }
-
-  void CAxis::recvIndex(CEventServer& event)
-  {
-    CAxis* axis;
-
+        int ind = data_index(idx);
+        if (ind >= 0 && ind < nbIndex)
+        {
+          dataIndex(nbDataIndex) = ind;
+          ++nbDataIndex;
+        }
+      }
+
+      if (client->isServerLeader())
+      {
+        std::list<CMessage> msgs;
+
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          msgs.push_back(CMessage());
+          CMessage& msg = msgs.back();
+          msg << this->getId();
+          msg << index.getValue() << dataIndex << mask.getValue();
+          msg << hasValue;
+          if (hasValue) msg << value.getValue();
+          msg << hasBounds;
+          if (hasBounds) msg << bounds.getValue();
+          msg << hasLabel;
+          if (hasLabel) msg << label.getValue();
+
+          event.push(*itRank, 1, msg);
+        }
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+    }
+  }
+
+  /*
+    Receive the non-distributed attributes from another group of clients
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvNonDistributedAttributes(CEventServer& event)
+  {
     list<CEventServer::SSubEvent>::iterator it;
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
@@ -818 +1031 @@
       string axisId;
       *buffer >> axisId;
-      axis = get(axisId);
-      axis->recvIndex(it->rank, *buffer);
-    }
-
-    if (axis->isCompressible_)
-    {
-      std::sort(axis->indexesToWrite.begin(), axis->indexesToWrite.end());
-
-      CContextServer* server = CContext::getCurrent()->server;
-      axis->numberWrittenIndexes_ = axis->indexesToWrite.size();
-      MPI_Allreduce(&axis->numberWrittenIndexes_, &axis->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
-      MPI_Scan(&axis->numberWrittenIndexes_, &axis->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
-      axis->offsetWrittenIndexes_ -= axis->numberWrittenIndexes_;
-    }
-  }
-
-  void CAxis::recvIndex(int rank, CBufferIn& buffer)
-  {
-    buffer >> indiSrv_[rank];
-
-    if (isCompressible_)
-    {
-      CArray<int, 1> writtenIndexes;
-      buffer >> writtenIndexes;
-      indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
-      for (int i = 0; i < writtenIndexes.numElements(); ++i)
-        indexesToWrite.push_back(writtenIndexes(i));
-    }
-  }
-
-  void CAxis::recvDistributedValue(CEventServer& event)
-  {
+      get(axisId)->recvNonDistributedAttributes(it->rank, *buffer);
+    }
+  }
+
+  /*
+    Receive the non-distributed attributes from another group of clients
+    \param [in] rank rank of the sender
+    \param [in] buffer buffer containing data sent from the sender
+  */
+  void CAxis::recvNonDistributedAttributes(int rank, CBufferIn& buffer)
+  { 
+    CArray<int,1> tmp_index, tmp_data_index, tmp_zoom_index;
+    CArray<bool,1> tmp_mask;
+    CArray<double,1> tmp_val;
+    CArray<double,2> tmp_bnds;
+    CArray<string,1> tmp_label;
+
+    buffer >> tmp_index;
+    index.reference(tmp_index);
+    buffer >> tmp_data_index;
+    data_index.reference(tmp_data_index);
+    buffer >> tmp_mask;
+    mask.reference(tmp_mask);
+
+    buffer >> hasValue;
+    if (hasValue)
+    {
+      buffer >> tmp_val;
+      value.reference(tmp_val);
+    }
+
+    buffer >> hasBounds;
+    if (hasBounds)
+    {
+      buffer >> tmp_bnds;
+      bounds.reference(tmp_bnds);
+    }
+
+    buffer >> hasLabel;
+    if (hasLabel)
+    {
+      buffer >> tmp_label;
+      label.reference(tmp_label);
+    }
+
+    // Some value should be reset here
+    data_begin.setValue(0);
+    globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor()));
+//    for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[idx] = index(idx);
+    for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[index(idx)] = idx;
+  }
+
+/*
+    Send attributes of axis from a group of client to other group of clients/servers 
+    on supposing that these attributes are distributed among the clients of the sending group
+    In the future, if new attributes are added, they should also be processed in this function
+  */
+  void CAxis::sendDistributedAttributes(void)
+  {
+    int ns, n, i, j, ind, nv, idx;
+    std::list<CContextClient*>::iterator it;
+
+    for (it=clients.begin(); it!=clients.end(); ++it)
+    {
+      CContextClient* client = *it;
+      int nbServer = client->serverSize;
+
+      CEventClient eventData(getType(), EVENT_ID_DISTRIBUTED_ATTRIBUTES);
+
+      list<CMessage> listData;
+      list<CArray<int,1> > list_indi, list_dataInd, list_zoomInd;
+      list<CArray<bool,1> > list_mask;
+      list<CArray<double,1> > list_val;
+      list<CArray<double,2> > list_bounds;
+      list<CArray<string,1> > list_label;
+
+      int nbIndex = index.numElements();
+      CArray<int,1> dataIndex(nbIndex);
+      dataIndex = -1;
+      for (idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        if (0 <= data_index(idx) && data_index(idx) < nbIndex)
+          dataIndex(idx) = 1;
+      }
+
+      boost::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap;
+      iteMap = indSrv_[nbServer].end();
+      for (int k = 0; k < connectedServerRank_[nbServer].size(); ++k)
+      {
+        int nbData = 0;
+        int rank = connectedServerRank_[nbServer][k];
+        it = indSrv_[nbServer].find(rank);
+        if (iteMap != it)
+          nbData = it->second.size();
+
+        list_indi.push_back(CArray<int,1>(nbData));
+        list_dataInd.push_back(CArray<int,1>(nbData));        
+        list_mask.push_back(CArray<bool,1>(nbData));
+
+        if (hasValue)
+          list_val.push_back(CArray<double,1>(nbData));
+
+        if (hasBounds)        
+          list_bounds.push_back(CArray<double,2>(2,nbData));
+
+        if (hasLabel)
+          list_label.push_back(CArray<string,1>(nbData));
+
+        CArray<int,1>& indi = list_indi.back();
+        CArray<int,1>& dataIndi = list_dataInd.back();        
+        CArray<bool,1>& maskIndi = list_mask.back();
+
+        for (n = 0; n < nbData; ++n)
+        {
+          idx = static_cast<int>(it->second[n]);
+          indi(n) = idx;
+
+          ind = globalLocalIndexMap_[idx];
+          dataIndi(n) = dataIndex(ind);
+          maskIndi(n) = mask(ind);
+
+          if (hasValue)
+          {
+            CArray<double,1>& val = list_val.back();
+            val(n) = value(ind);
+          }
+
+          if (hasBounds)
+          {
+            CArray<double,2>& boundsVal = list_bounds.back();
+            boundsVal(0, n) = bounds(0,ind);
+            boundsVal(1, n) = bounds(1,ind);
+          }
+
+          if (hasLabel)
+          {
+            CArray<string,1>& labelVal = list_label.back();
+            labelVal(n) = label(ind); 
+          }
+        }
+
+        listData.push_back(CMessage());
+        listData.back() << this->getId()
+                        << list_indi.back() << list_dataInd.back() << list_mask.back();
+
+        listData.back() << hasValue;
+        if (hasValue)
+          listData.back() << list_val.back();
+
+        listData.back() << hasBounds;
+        if (hasBounds)
+          listData.back() << list_bounds.back();
+
+        listData.back() << hasLabel;
+        if (hasLabel)
+          listData.back() << list_label.back();
+
+        eventData.push(rank, nbSenders[nbServer][rank], listData.back());
+      }
+
+      client->sendEvent(eventData);
+    }
+  }
+
+  /*
+    Receive the distributed attributes from another group of clients
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvDistributedAttributes(CEventServer& event)
+  {
+    string axisId;
+    vector<int> ranks;
+    vector<CBufferIn*> buffers;
+
     list<CEventServer::SSubEvent>::iterator it;
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
     {
+      ranks.push_back(it->rank);
       CBufferIn* buffer = it->buffer;
-      string axisId;
       *buffer >> axisId;
-      get(axisId)->recvDistributedValue(it->rank, *buffer);
-    }
-  }
-
-  void CAxis::recvDistributedValue(int rank, CBufferIn& buffer)
-  {
-    CArray<int,1> &indi = indiSrv_[rank];
-    CArray<double,1> val;
-    CArray<double,2> boundsVal;
-    CArray<StdString,1> labelVal;
-
-    buffer >> val;
-    if (hasBounds_) buffer >> boundsVal;
-    if (hasLabel) buffer >> labelVal;
-
-    int i, j, ind_srv;
-    for (int ind = 0; ind < indi.numElements(); ++ind)
-    {
-      i = indi(ind);
-      ind_srv = i - zoom_begin_srv;
-      value_srv(ind_srv) = val(ind);
-      if (hasBounds_)
-      {
-        bound_srv(0,ind_srv) = boundsVal(0, ind);
-        bound_srv(1,ind_srv) = boundsVal(1, ind);
-      }
-
+      buffers.push_back(buffer);
+    }
+    get(axisId)->recvDistributedAttributes(ranks, buffers);
+  }
+
+  /*
+    Receive the non-distributed attributes from another group of clients
+    \param [in] ranks rank of the sender
+    \param [in] buffers buffer containing data sent from the sender
+  */
+  void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers)
+  {
+    int nbReceived = ranks.size(), idx, ind, gloInd, locInd;
+    vector<CArray<int,1> > vec_indi(nbReceived), vec_dataInd(nbReceived), vec_zoomInd(nbReceived);    
+    vector<CArray<bool,1> > vec_mask(nbReceived);
+    vector<CArray<double,1> > vec_val(nbReceived);
+    vector<CArray<double,2> > vec_bounds(nbReceived);
+    vector<CArray<string,1> > vec_label(nbReceived);
+    
+    for (idx = 0; idx < nbReceived; ++idx)
+    {      
+      CBufferIn& buffer = *buffers[idx];
+      buffer >> vec_indi[idx];
+      buffer >> vec_dataInd[idx];      
+      buffer >> vec_mask[idx];
+
+      buffer >> hasValue;
+      if (hasValue)
+        buffer >> vec_val[idx];
+
+      buffer >> hasBounds;
+      if (hasBounds)
+        buffer >> vec_bounds[idx];
+
+      buffer >> hasLabel;
       if (hasLabel)
-      {
-        label_srv(ind_srv) = labelVal( ind);
-      }
-
-    }
-  }
-
-   void CAxis::recvNonDistributedValue(CEventServer& event)
-  {
-    CAxis* axis;
-
-    list<CEventServer::SSubEvent>::iterator it;
-    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
-    {
-      CBufferIn* buffer = it->buffer;
-      string axisId;
-      *buffer >> axisId;
-      axis = get(axisId);
-      axis->recvNonDistributedValue(it->rank, *buffer);
-    }
-
-    if (axis->isCompressible_)
-    {
-      std::sort(axis->indexesToWrite.begin(), axis->indexesToWrite.end());
-
-      axis->numberWrittenIndexes_ = axis->totalNumberWrittenIndexes_ = axis->indexesToWrite.size();
-      axis->offsetWrittenIndexes_ = 0;
-    }
-  }
-
-  void CAxis::recvNonDistributedValue(int rank, CBufferIn& buffer)
-  {
-    CArray<double,1> val;
-    buffer >> val;
-
-    for (int ind = 0; ind < val.numElements(); ++ind)
-    {
-      value_srv(ind) = val(ind);
-      if (hasBounds_)
-      {
-        bound_srv(0,ind) = bounds(0,ind);
-        bound_srv(1,ind) = bounds(1,ind);
-      }
-      if (hasLabel)
-      {
-        label_srv(ind) = label(ind);
-      }
-    }
-
-    if (isCompressible_)
-    {
-      CArray<int, 1> writtenIndexes;
-      buffer >> writtenIndexes;
-      indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
-      for (int i = 0; i < writtenIndexes.numElements(); ++i)
-        indexesToWrite.push_back(writtenIndexes(i));
-    }
-  }
-
-  void CAxis::sendServerAttribut(const std::vector<int>& globalDim, int orderPositionInGrid,
-                                 CServerDistributionDescription::ServerDistributionType distType)
-  {
-    CContext* context = CContext::getCurrent();
-    CContextClient* client = context->client;
-    int nbServer = client->serverSize;
-
-    CServerDistributionDescription serverDescription(globalDim, nbServer);
-    serverDescription.computeServerDistribution();
-
-    std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
-    std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
-
-    CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT);
-    if (client->isServerLeader())
-    {
-      std::list<CMessage> msgs;
-
-      const std::list<int>& ranks = client->getRanksServerLeader();
-      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
-      {
-        // Use const int to ensure CMessage holds a copy of the value instead of just a reference
-        const int begin = serverIndexBegin[*itRank][orderPositionInGrid];
-        const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid];
-        const int end   = begin + ni - 1;
-        const bool zoomIndex = zoomByIndex();
-
-        msgs.push_back(CMessage());
-        CMessage& msg = msgs.back();
-        msg << this->getId();
-        msg << ni << begin << end;
-        msg << global_zoom_begin.getValue() << global_zoom_n.getValue();
-        msg << isCompressible_;
-        msg << zoomIndex;
-        if (zoomIndex)
-          msg << global_zoom_index.getValue();
-
-        event.push(*itRank,1,msg);
-      }
-      client->sendEvent(event);
-    }
-    else client->sendEvent(event);
-  }
-
-  void CAxis::recvServerAttribut(CEventServer& event)
-  {
-    CBufferIn* buffer = event.subEvents.begin()->buffer;
-    string axisId;
-    *buffer >> axisId;
-    get(axisId)->recvServerAttribut(*buffer);
-  }
-
-  void CAxis::recvServerAttribut(CBufferIn& buffer)
-  {
-    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 = 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)
-    {
-      zoom_begin_srv = 0; zoom_end_srv = 0; zoom_size_srv = 0;
-    }
-
-    if (n_glo == n)
-    {
-      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;
-    }
+        buffer >> vec_label[idx]; 
+    }
+
+    // Estimate size of index array
+    int nbIndexGlob = 0;
+    for (idx = 0; idx < nbReceived; ++idx)
+    {
+      nbIndexGlob += vec_indi[idx].numElements();
+    }
+
+    // Recompute global index
+    // Take account of the overlapped index 
+    index.resize(nbIndexGlob);
+    globalLocalIndexMap_.rehash(std::ceil(index.numElements()/globalLocalIndexMap_.max_load_factor()));
+    nbIndexGlob = 0;
+    for (idx = 0; idx < nbReceived; ++idx)
+    {
+      CArray<int,1>& tmp = vec_indi[idx];
+      for (ind = 0; ind < tmp.numElements(); ++ind)
+      {
+         gloInd = tmp(ind);
+         if (0 == globalLocalIndexMap_.count(gloInd))
+         {
+           index(nbIndexGlob) = gloInd % n_glo;           
+           globalLocalIndexMap_[gloInd] = nbIndexGlob;  
+           ++nbIndexGlob;
+         } 
+      } 
+    }
+
+    // Resize index to its real size
+    if (nbIndexGlob==0) index.resize(nbIndexGlob) ;
+    else index.resizeAndPreserve(nbIndexGlob);
+
+    int nbData = nbIndexGlob;
+    CArray<int,1> nonCompressedData(nbData);
+    nonCompressedData = -1;   
+    mask.resize(nbData);
     if (hasValue)
-    {
-      value_srv.resize(zoom_size_srv);
-      if (hasBounds_)  bound_srv.resize(2,zoom_size_srv);
-      if (hasLabel)  label_srv.resize(zoom_size_srv);
-    }
+      value.resize(nbData);
+    if (hasBounds)
+      bounds.resize(2,nbData);
+    if (hasLabel)
+      label.resize(nbData);
+
+    nbData = 0;
+    for (idx = 0; idx < nbReceived; ++idx)
+    {
+      CArray<int,1>& indi = vec_indi[idx];
+      CArray<int,1>& dataIndi = vec_dataInd[idx];
+      CArray<bool,1>& maskIndi = vec_mask[idx];
+      int nb = indi.numElements();
+      for (int n = 0; n < nb; ++n)
+      { 
+        locInd = globalLocalIndexMap_[size_t(indi(n))];
+
+        nonCompressedData(locInd) = (-1 == nonCompressedData(locInd)) ? dataIndi(n) : nonCompressedData(locInd);
+
+        if (!mask(locInd)) // Only rewrite mask if it's not true
+          mask(locInd) = maskIndi(n);
+        
+        if (hasValue)
+          value(locInd) = vec_val[idx](n);
+
+        if (hasBounds)
+        {
+          bounds(0,locInd) = vec_bounds[idx](0,n);
+          bounds(1,locInd) = vec_bounds[idx](1,n);
+        }
+
+        if (hasLabel)
+          label(locInd) = vec_label[idx](n);
+      }
+    }
+    
+    int nbCompressedData = 0; 
+    for (idx = 0; idx < nonCompressedData.numElements(); ++idx)
+    {
+      if (0 <= nonCompressedData(idx))
+        ++nbCompressedData;        
+    }
+
+    data_index.resize(nbCompressedData);
+    nbCompressedData = 0;
+    for (idx = 0; idx < nonCompressedData.numElements(); ++idx)
+    {
+      if (0 <= nonCompressedData(idx))
+      {
+        data_index(nbCompressedData) = idx % n;
+        ++nbCompressedData;        
+      }
+    }
+
+    data_begin.setValue(0);
   }
 
@@ -1090 +1375 @@
   }
 
+  /*
+    Add transformation into axis. This function only servers for Fortran interface
+    \param [in] transType transformation type
+    \param [in] id identifier of the transformation object
+  */
   CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)
   {
@@ -1096 +1386 @@
   }
 
+  /*
+    Check whether an axis has (spatial) transformation
+  */
   bool CAxis::hasTransformation()
   {
@@ -1101 +1394 @@
   }
 
+  /*
+    Set transformation
+    \param [in] axisTrans transformation to set
+  */
   void CAxis::setTransformations(const TransMapTypes& axisTrans)
   {
@@ -1106 +1403 @@
   }
 
+  /*
+    Return all transformation held by the axis
+    \return transformation the axis has
+  */
   CAxis::TransMapTypes CAxis::getAllTransformations(void)
   {
@@ -1111 +1412 @@
   }
 
+  /*
+    Duplicate transformation of another axis
+    \param [in] src axis whose transformations are copied
+  */
   void CAxis::duplicateTransformation(CAxis* src)
   {
@@ -1140 +1445 @@
   }
 
+  void CAxis::setContextClient(CContextClient* contextClient)
+  {
+    if (clientsSet.find(contextClient)==clientsSet.end())
+    {
+      clients.push_back(contextClient) ;
+      clientsSet.insert(contextClient);
+    }
+}
+
   void CAxis::parse(xml::CXMLNode & node)
   {