Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/client_server_mapping.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/client_server_mapping.cpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/client_server_mapping.cpp	(revision 1794)
@@ -27,5 +27,5 @@
   \param [in] nClient number of clients
   \param [in] clientIntraComm MPI communication of clients
-  \param [in] connectedServerRank Rank of servers connected to one client
+  \param [in] connectedServerRank Rank of servers connected to the current client
 */
 std::map<int,int> CClientServerMapping::computeConnectedClients(int nbServer, int nbClient,
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/source_filter.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/source_filter.cpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/source_filter.cpp	(revision 1794)
@@ -34,5 +34,5 @@
     packet->status = CDataPacket::NO_ERROR;
 
-    packet->data.resize(grid->storeIndex_client.numElements());    
+    packet->data.resize(grid->storeIndex_client_.numElements());    
     
     if (compression)
@@ -80,14 +80,14 @@
     packet->status = CDataPacket::NO_ERROR;
     
-    if (data.size() != grid->storeIndex_fromSrv.size())
+    if (data.size() != grid->storeIndex_fromSrv_.size())
       ERROR("CSourceFilter::streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data)",
             << "Incoherent data received from servers,"
-            << " expected " << grid->storeIndex_fromSrv.size() << " chunks but " << data.size() << " were given.");
+            << " expected " << grid->storeIndex_fromSrv_.size() << " chunks but " << data.size() << " were given.");
 
-    packet->data.resize(grid->storeIndex_client.numElements());
+    packet->data.resize(grid->storeIndex_client_.numElements());
     std::map<int, CArray<double, 1> >::const_iterator it, itEnd = data.end();
     for (it = data.begin(); it != itEnd; it++)
     {      
-      CArray<int,1>& index = grid->storeIndex_fromSrv[it->first];
+      CArray<int,1>& index = grid->storeIndex_fromSrv_[it->first];
       for (int n = 0; n < index.numElements(); n++)
         packet->data(index(n)) = it->second(n);
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/spatial_transform_filter.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/spatial_transform_filter.cpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/filter/spatial_transform_filter.cpp	(revision 1794)
@@ -174,5 +174,5 @@
         gridTransformation->computeAll(dataAuxInputs, packet->timestamp);
       }
-      packet->data.resize(gridTransformation->getGridDestination()->storeIndex_client.numElements());
+      packet->data.resize(gridTransformation->getGridDestination()->storeIndex_client_.numElements());
       if (0 != packet->data.numElements())
         (packet->data)(0) = defaultValue;
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.cpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/node/field.cpp	(revision 1794)
@@ -162,5 +162,5 @@
        if (client->isServerLeader())
        {
-          for (it = grid->storeIndex_toSrv[client].begin(); it != grid->storeIndex_toSrv[client].end(); it++)
+          for (it = grid->storeIndex_toSrv_[client].begin(); it != grid->storeIndex_toSrv_[client].end(); it++)
           {
             int rank = it->first;
@@ -182,5 +182,5 @@
     else
     {
-      for (it = grid->storeIndex_toSrv[client].begin(); it != grid->storeIndex_toSrv[client].end(); it++)
+      for (it = grid->storeIndex_toSrv_[client].begin(); it != grid->storeIndex_toSrv_[client].end(); it++)
       {
         int rank = it->first;
@@ -194,5 +194,5 @@
 
         list_msg.back() << getId() << data_tmp;
-        event.push(rank, grid->nbSenders[receiverSize][rank], list_msg.back());
+        event.push(rank, grid->nbSenders_[receiverSize][rank], list_msg.back());
       }
       client->sendEvent(event);
@@ -231,5 +231,5 @@
     if (0 == recvDataSrv.numElements())
     {            
-      CArray<int,1>& storeClient = grid->storeIndex_client;
+      CArray<int,1>& storeClient = grid->storeIndex_client_;
 
       // Gather all data from different clients      
@@ -248,5 +248,5 @@
     if (opeDate <= currDate)
     {
-      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin(); it != grid->outLocalIndexStoreOnClient.end(); ++it)
+      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient_.begin(); it != grid->outLocalIndexStoreOnClient_.end(); ++it)
       {
         CArray<double,1> tmp;
@@ -445,6 +445,6 @@
     else
     {
-      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin(); 
-                                                  it != grid->outLocalIndexStoreOnClient.end(); ++it)
+      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient_.begin(); 
+                                                  it != grid->outLocalIndexStoreOnClient_.end(); ++it)
       {
         CArray<size_t,1>& indexTmp = it->second;
@@ -472,5 +472,5 @@
         }
 
-        event.push(it->first, grid->nbReadSenders[client][it->first], msg);
+        event.push(it->first, grid->nbReadSenders_[client][it->first], msg);
       }
       client->sendEvent(event);
@@ -498,5 +498,5 @@
         if (0 == recvDataSrv.numElements())
         {            
-          CArray<int,1>& storeClient = grid->storeIndex_client;          
+          CArray<int,1>& storeClient = grid->storeIndex_client_;          
           recvDataSrv.resize(storeClient.numElements());          
         }
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.cpp	(revision 1794)
@@ -695,24 +695,24 @@
      int nbStoreGridMask = clientDistribution_->getLocalMaskIndexOnClient().size();
      // nbStoreGridMask = nbStoreIndex if grid mask is defined, and 0 otherwise
-     storeIndex_client.resize(nbStoreIndex);
-     storeMask_client.resize(nbStoreGridMask);
-     for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx];
-     for (int idx = 0; idx < nbStoreGridMask; ++idx) storeMask_client(idx) = (clientDistribution_->getLocalMaskIndexOnClient())[idx];
+     storeIndex_client_.resize(nbStoreIndex);
+     storeMask_client_.resize(nbStoreGridMask);
+     for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndex_client_(idx) = (clientDistribution_->getLocalDataIndexOnClient())[idx];
+     for (int idx = 0; idx < nbStoreGridMask; ++idx) storeMask_client_(idx) = (clientDistribution_->getLocalMaskIndexOnClient())[idx];
 
      if (0 == serverDistribution_) isDataDistributed_= clientDistribution_->isDataDistributed();
      else
      {
-        // Mapping global index received from clients to the storeIndex_client
+        // Mapping global index received from clients to the storeIndex_client_
         CDistributionClient::GlobalLocalDataMap& globalDataIndex = clientDistribution_->getGlobalDataIndexOnClient();
         CDistributionClient::GlobalLocalDataMap::const_iterator itGloe = globalDataIndex.end();
-        map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(),
-                                               ite = outGlobalIndexFromClient.end(), it;
+        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];
+          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];
           size_t nbIndex = 0;
 
@@ -772,5 +772,5 @@
             connectedDataSize_.erase(receiverSize);
             globalIndexOnServer_.erase(receiverSize);
-            nbSenders.erase(receiverSize);
+            nbSenders_.erase(receiverSize);
          }
 
@@ -872,5 +872,5 @@
          }
 
-         nbSenders[receiverSize] = clientServerMap_->computeConnectedClients(receiverSize, client->clientSize, client->intraComm, connectedServerRank_[receiverSize]);
+         nbSenders_[receiverSize] = clientServerMap_->computeConnectedClients(receiverSize, client->clientSize, client->intraComm, connectedServerRank_[receiverSize]);
        }
      }
@@ -911,5 +911,5 @@
        if (serverDistribution_!=0) serverDistribution_->partialClear() ;
        if (clientDistribution_!=0) clientDistribution_->partialClear() ;
-       outGlobalIndexFromClient.clear() ;
+       outGlobalIndexFromClient_.clear() ;
      }
    }
@@ -1310,8 +1310,8 @@
    TRY
    {
-      const StdSize size = storeIndex_client.numElements();
+      const StdSize size = storeIndex_client_.numElements();
 
       stored.resize(size);
-      for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
+      for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client_(i)];
    }
    CATCH
@@ -1320,7 +1320,7 @@
    TRY
    {
-      const StdSize size = storeIndex_client.numElements();
-
-      for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i);
+      const StdSize size = storeIndex_client_.numElements();
+
+      for(StdSize i = 0; i < size; i++) data[storeIndex_client_(i)] = stored(i);
    }
    CATCH
@@ -1328,12 +1328,12 @@
    void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored) const
    {
-      const StdSize size = storeIndex_client.numElements();
+      const StdSize size = storeIndex_client_.numElements();
       stored.resize(size);
       const double nanValue = std::numeric_limits<double>::quiet_NaN();
 
-      if (storeMask_client.numElements() != 0)
-        for(StdSize i = 0; i < size; i++) stored(i) = (storeMask_client(i)) ? data[storeIndex_client(i)] : nanValue;
+      if (storeMask_client_.numElements() != 0)
+        for(StdSize i = 0; i < size; i++) stored(i) = (storeMask_client_(i)) ? data[storeIndex_client_(i)] : nanValue;
       else
-        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
+        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client_(i)];
    }
 
@@ -1356,17 +1356,17 @@
       clientDistribution_ = new CDistributionClient(rank, this);
 
-      storeIndex_client.resize(1);
-      storeIndex_client(0) = 0;      
+      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;
+        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];
+          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()",
@@ -1406,5 +1406,5 @@
           connectedDataSize_.erase(receiverSize);
           globalIndexOnServer_.erase(receiverSize);
-          nbSenders.erase(receiverSize);
+          nbSenders_.erase(receiverSize);
         }
 
@@ -1418,5 +1418,5 @@
             connectedServerRank_[receiverSize].push_back(rank);
             connectedDataSize_[receiverSize][rank] = nb;
-            nbSenders[receiverSize][rank] = nb;
+            nbSenders_[receiverSize][rank] = nb;
           }
         }
@@ -1430,5 +1430,5 @@
             connectedServerRank_[receiverSize].push_back(rank);
             connectedDataSize_[receiverSize][rank] = nb;
-            nbSenders[receiverSize][rank] = nb;
+            nbSenders_[receiverSize][rank] = nb;
           }
         }
@@ -1443,5 +1443,5 @@
   {
     CContext* context = CContext::getCurrent();
-    storeIndex_toSrv.clear();
+    storeIndex_toSrv_.clear();
     std::list<CContextClient*>::iterator it;
 
@@ -1462,8 +1462,8 @@
           int rank = *itRank;
           int nb = 1;
-          storeIndex_toSrv[client].insert(std::make_pair(rank, CArray<int,1>(nb)));
+          storeIndex_toSrv_[client].insert(std::make_pair(rank, CArray<int,1>(nb)));
           listOutIndex.push_back(CArray<size_t,1>(nb));
 
-          CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv[client][rank];
+          CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank];
           CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back();
 
@@ -1475,5 +1475,5 @@
 
           if (context->hasClient && !context->hasServer)
-            storeIndex_fromSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
+            storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
 
           listMsg.push_back(CMessage());
@@ -1498,5 +1498,5 @@
 
           if (context->hasClient && !context->hasServer)
-            storeIndex_fromSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
+            storeIndex_fromSrv_.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
         }
         client->sendEvent(event);
@@ -1510,5 +1510,5 @@
   {
     CContext* context = CContext::getCurrent();
-    storeIndex_toSrv.clear();
+    storeIndex_toSrv_.clear();
     std::list<CContextClient*>::iterator it;
 
@@ -1543,7 +1543,7 @@
           for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
           {
-            storeIndex_toSrv[client].insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
+            storeIndex_toSrv_[client].insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
             if (context->hasClient && !context->hasServer)
-              storeIndex_fromSrv.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
+              storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
             
             listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer));
@@ -1568,5 +1568,5 @@
            for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
            {
-             storeIndex_fromSrv.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
+             storeIndex_fromSrv_.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
            }
            client->sendEvent(event);
@@ -1604,8 +1604,8 @@
             nb = globalIndexTmp[rank].size();
 
-          storeIndex_toSrv[client].insert(make_pair(rank, CArray<int,1>(nb)));
+          storeIndex_toSrv_[client].insert(make_pair(rank, CArray<int,1>(nb)));
           listOutIndex.push_back(CArray<size_t,1>(nb));
 
-          CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv[client][rank];
+          CArray<int, 1>& outLocalIndexToServer = storeIndex_toSrv_[client][rank];
           CArray<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back();
 
@@ -1616,9 +1616,9 @@
           }
 
-          storeIndex_fromSrv.insert(make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
+          storeIndex_fromSrv_.insert(make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
           listMsg.push_back(CMessage());
           listMsg.back() << getId() << isDataDistributed_ << isCompressible_ << listOutIndex.back();
 
-          event.push(rank, nbSenders[receiverSize][rank], listMsg.back());
+          event.push(rank, nbSenders_[receiverSize][rank], listMsg.back());
         }
 
@@ -1654,5 +1654,5 @@
     connectedServerRankRead_ = ranks;
 
-    nbReadSenders.clear();
+    nbReadSenders_.clear();
     CContextServer* server = context->server  ;
     CContextClient* client = context->client;   
@@ -1750,5 +1750,5 @@
       CArray<size_t,1> outIndex;
       buffer >> outIndex;
-      outGlobalIndexFromClient.insert(std::make_pair(rank, outIndex));
+      outGlobalIndexFromClient_.insert(std::make_pair(rank, outIndex));
       connectedDataSizeRead_[rank] = outIndex.numElements();
 
@@ -1811,5 +1811,5 @@
     if (isScalarGrid()) return;
 
-    nbReadSenders[client] = CClientServerMappingDistributed::computeConnectedClients(context->client->serverSize, context->client->clientSize, context->client->intraComm, ranks);
+    nbReadSenders_[client] = CClientServerMappingDistributed::computeConnectedClients(context->client->serverSize, context->client->clientSize, context->client->intraComm, ranks);
 
   }
@@ -1975,4 +1975,7 @@
   TRY
   {
+    // This function is now useless because it will return false only if server and client size are equal to 1
+    // to be seriously check in future 
+
     if (isScalarGrid()) return false;
     else if (0 != client)
Index: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp
===================================================================
--- XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp	(revision 1787)
+++ XIOS/dev/dev_ym/XIOS_COUPLING/src/node/grid.hpp	(revision 1794)
@@ -205,43 +205,4 @@
          bool hasTransform();
          size_t getGlobalWrittenSize(void) ;
-      public:
-         CArray<int, 1> storeIndex_client;
-         CArray<bool, 1> storeMask_client;
-
-/** Map containing indexes that will be sent in sendIndex(). */
-         std::map<CContextClient*, map<int, CArray<int, 1> > > storeIndex_toSrv;
-
-/** Map storing the number of senders. Key = size of receiver's intracomm */
-         std::map<int, std::map<int,int> > nbSenders;
-
-         std::map<CContextClient*, std::map<int,int> > nbReadSenders;
-
-         map<int, CArray<int, 1> > storeIndex_fromSrv; // Support, for now, reading with level-1 server
-
-         map<int, CArray<size_t, 1> > compressedOutIndexFromClient;
-
-/** Map storing received indexes. Key = sender rank, value = index array. */
-         map<int, CArray<size_t, 1> > outGlobalIndexFromClient;
-
-// Manh Ha's comment: " A client receives global index from other clients (via recvIndex)
-// then does mapping these index into local index of STORE_CLIENTINDEX
-// In this way, store_clientIndex can be used as an input of a source filter
-// Maybe we need a flag to determine whether a client wants to write. TODO "
-
-/** Map storing received data. Key = sender rank, value = data array.
- *  The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData() */
-         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient; 
-
-/** Indexes calculated based on server-like distribution.
- *  They are used for writing/reading data and only calculated for server level that does the writing/reading.
- *  Along with localIndexToWriteOnClient, these indexes are used to correctly place incoming data. */
-         CArray<size_t,1> localIndexToWriteOnServer;
-
-/** Indexes calculated based on client-like distribution.
- *  They are used for writing/reading data and only calculated for server level that does the writing/reading.
- *  Along with localIndexToWriteOnServer, these indexes are used to correctly place incoming data. */
-         CArray<size_t,1> localIndexToWriteOnClient;
-
-         CArray<size_t,1> indexFromClients;
 
          bool hasMask(void) const;
@@ -303,4 +264,78 @@
         void computeConnectedClientsScalarGrid(); 
 
+
+      public:
+/** Array containing the local index of the grid
+ *  storeIndex_client[local_workflow_grid_index] -> local_model_grid_index. 
+ *  Used to store field from model into the worklow, or to return field into models.  
+ *  The size of the array is the number of local index of the workflow grid */        
+         CArray<int, 1> storeIndex_client_;
+
+/** Array containing the grid mask masked defined by the mask_nd grid attribute.        
+  * The corresponding masked field value provided by the model will be replaced by a NaN value
+  * in the workflow.  */
+         CArray<bool, 1> storeMask_client_;
+
+/** Map containing the indexes on client side that will be sent to each connected server.
+  * storeIndex_toSrv[&contextClient] -> map concerning the contextClient for which the data will be sent (client side)
+  * storeIndex_toSrv[&contextClient][rank] -> array of indexes that will be sent to each "rank" of the connected servers 
+  * storeIndex_toSrv[&contextClient][rank](index_of_buffer_sent_to_server) -> local index of the field of the workflow 
+  * grid that will be sent to server */
+         std::map<CContextClient*, map<int, CArray<int, 1> > > storeIndex_toSrv_;
+
+
+/** Map containing the indexes on client side that will be received from each connected server.
+  * This map is used to agreggate field data received from server (for reading) into a single array, which will be an entry
+  * point of the worklow on client side.
+  * storeIndex_toSrv[rank] -> array of indexes that will be received from each "rank" of the connected servers 
+  * storeIndex_toSrv[rank](index_of_buffer_received_from_server) -> local index of the field in the "workflow grid"
+  * that has been received from server */
+         std::map<int, CArray<int, 1> > storeIndex_fromSrv_; // Support, for now, reading with level-1 server
+
+
+/** Maps storing the number of participating clients for data sent a specific server for a given contextClient, identified
+  * by the servers communicator size. In future must be direcly identified by context.
+  * nbSender_[context_server_size] -> map the number of client sender by connected rank of servers
+  * nbSender_[context_server_size] [rank_server] -> the number of client participating to a send message for a server of rank "rank_server" 
+  * Usefull to indicate in a message the number of participant needed by the transfer protocol */
+         std::map<int, std::map<int,int> > nbSenders_;
+
+
+/** Maps storing the number of participating servers for data sent a specific client for a given contextClient.
+  * Symetric of nbSenders_, but for server side which want to send data to client.
+  * nbReadSender_[context_client_size] -> map the number of server sender by connected rank of clients
+  * nbReadSender_[context_client_size] [rank_client] -> the number of serverq participating to a send message for a client of rank "rank_client" 
+  * Usefull to indicate in a message the number of participant needed by the transfer protocol */
+         std::map<CContextClient*, std::map<int,int> > nbReadSenders_;
+
+
+// Manh Ha's comment: " A client receives global index from other clients (via recvIndex)
+// then does mapping these index into local index of STORE_CLIENTINDEX
+// In this way, store_clientIndex can be used as an input of a source filter
+// Maybe we need a flag to determine whether a client wants to write. TODO "
+
+/** Map storing received data on server side. This map is the equivalent of storeIndex_client, but for data not received from model
+  * instead that for client. This map is used to concatenate data received from several clients into a single array on server side
+  * which match the local workflow grid.
+  * outLocalIndexStoreOnClient_[client_rank] -> Array of index from client of rank "client_rank"
+  * outLocalIndexStoreOnClient_[client_rank](index of buffer from client) -> local index of the workflow grid
+  * The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData().
+  * Symetrically it is also used to send data from a server to sevral client for reading case. */
+         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient_; 
+
+
+/** Indexes calculated based on server-like distribution.
+ *  They are used for writing/reading data and only calculated for server level that does the writing/reading.
+ *  Along with localIndexToWriteOnClient, these indexes are used to correctly place incoming data. */
+         CArray<size_t,1> localIndexToWriteOnServer;
+
+/** Indexes calculated based on client-like distribution.
+  * They are used for writing/reading data and only calculated for server level that does the writing/reading.
+  * Along with localIndexToWriteOnServer, these indexes are used to correctly place incoming data. */
+         CArray<size_t,1> localIndexToWriteOnClient;
+
+         CArray<size_t,1> indexFromClients;
+
+
       private:
 
@@ -308,4 +343,7 @@
         std::list<CContextClient*> clients;
         std::set<CContextClient*> clientsSet;
+
+/** Map storing received indexes. Key = sender rank, value = index array. */
+         map<int, CArray<size_t, 1> > outGlobalIndexFromClient_;
 
         bool isChecked;
