Changeset 2019 for XIOS/dev/dev_trunk_graph/src/node

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

-                      r1686
+                      r2019
    CAxis::CAxis(void)
       : CObjectTemplate<CAxis>()
+      , CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
+      , isClientAfterTransformationChecked(false)
+      , CAxisAttributes(), isChecked(false), relFiles()
       , hasBounds(false), isCompressible_(false)
-      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
       , transformationMap_(), hasValue(false), hasLabel(false)
+      , computedWrittenIndex_(false)
+          , clients()
+      , clients()
+   {
+   }
 …
    CAxis::CAxis(const StdString & id)
       : CObjectTemplate<CAxis>(id)
+      , CAxisAttributes(), isChecked(false), relFiles(), areClientAttributesChecked_(false)
+      , isClientAfterTransformationChecked(false)
+      , CAxisAttributes(), isChecked(false), relFiles()
       , hasBounds(false), isCompressible_(false)
-      , numberWrittenIndexes_(), totalNumberWrittenIndexes_(), offsetWrittenIndexes_()
       , transformationMap_(), hasValue(false), hasLabel(false)
+      , computedWrittenIndex_(false)
+          , clients()
+      , clients()
+   {
+   }
 …
       // A 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);
+      distributed |= (1 == CContext::getCurrent()->intraCommSize_);
       return distributed;
+   }
 …
    /*!
+    * Test whether the data defined on the axis can be outputted in a compressed way.
+    *
+    * \return true if and only if a mask was defined for this axis
+    * Compute if the axis can be ouput in a compressed way.
+    * In this case the workflow view on server side must be the same
+    * than the full view for all context rank. The result is stored on
+    * internal isCompressible_ attribute.
     */
+   bool CAxis::isCompressible(void) const
+   TRY
+   {
+      return isCompressible_;
+   void CAxis::computeIsCompressible(void)
+   TRY
+   {
+     // mesh is compressible contains some masked or indexed value, ie if full view is different of workflow view.
+     // But now assume that the size of the 2 view must be equal for everybody. True on server side
+     int isSameView = getLocalView(CElementView::FULL)->getSize() ==  getLocalView(CElementView::WORKFLOW)->getSize();
+     MPI_Allreduce(MPI_IN_PLACE, &isSameView, 1, MPI_INT, MPI_LAND, CContext::getCurrent()->getIntraComm()) ;
+     if (isSameView) isCompressible_ = false ;
+     else isCompressible_ = true ;
+     isCompressibleComputed_=true ;
+   }
    CATCH
 …
    CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   /*!
+     Returns the number of indexes written by each server.
+     \return the number of indexes written by each server
+   */
+   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return numberWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Returns the total number of indexes written by the servers.
+     \return the total number of indexes written by the servers
+   */
+   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return totalNumberWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Returns the offset of indexes written by each server.
+     \return the offset of indexes written by each server
+   */
+   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return offsetWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return compressedIndexToWriteOnServer[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+    //----------------------------------------------------------------
    /*!
 …
    TRY
+   {
+     if (checkAttributes_done_) return ;
      CContext* context=CContext::getCurrent();
 …
       if (!this->value.isEmpty())
+      {
+        // Avoid this check at writing because it fails in case of a hole
+        if (context->hasClient)
+        {
+          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->checkBounds();
+      if (context->hasClient)
+      {
+        this->checkMask();
+        this->checkData();
+        this->checkLabel();
+      }
+      this->checkMask();
+      this->checkData();
+      this->checkLabel();
+      initializeLocalElement() ;
+      addFullView() ;
+      addWorkflowView() ;
+      addModelView() ;
+      checkAttributes_done_ = true ;
+   }
    CATCH_DUMP_ATTR
    /*!
 …
         for (int i = 0; i < data_n; ++i)
+        {
           if ((i+data_begin) >= 0 && (i+data_begin<n) && !mask(i+data_begin))
             data_index(i) = -1;
+           if (data_index(i) >= 0 && data_index(i)<n)
+             if (!mask(data_index(i))) data_index(i) = -1;
+        }
+      }
 …
   CATCH_DUMP_ATTR
+  /*!
+    Check whether we can do compressed output
+  */
+  void CAxis::checkEligibilityForCompressedOutput()
+  TRY
+  {
+    // We don't check if the mask is valid here, just if a mask has been defined at this point.
+    isCompressible_ = !mask.isEmpty();
+  }
+  CATCH_DUMP_ATTR
   /*!
     Dispatch event from the lower communication layer then process event according to its type
 …
        switch(event.type)
+       {
+          case EVENT_ID_DISTRIBUTION_ATTRIBUTE :
+            recvDistributionAttribute(event);
+            return true;
+            break;
+         case EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES:
+           recvNonDistributedAttributes(event);
+         case EVENT_ID_AXIS_DISTRIBUTION:
+           recvAxisDistribution(event);
            return true;
            break;
          case EVENT_ID_DISTRIBUTED_ATTRIBUTES:
+         case EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE:
            recvDistributedAttributes(event);
            return true;
 …
   CATCH
+   /*!
+     Check attributes on client side (This name is still adequate???)
+   */
+   void CAxis::checkAttributesOnClient()
+   TRY
+   {
+     if (this->areClientAttributesChecked_) return;
+     CContext* context=CContext::getCurrent();
+     if (context->hasClient && !context->hasServer) this->checkAttributes();
+     this->areClientAttributesChecked_ = true;
+   }
+   CATCH_DUMP_ATTR
+   /*
+     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)
+   TRY
+   {
+     CContext* context=CContext::getCurrent() ;
+     if (this->isClientAfterTransformationChecked) return;
+     if (context->hasClient)
+     {
+       if (orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
+         computeConnectedClients(globalDim, orderPositionInGrid, distType);
+       else if (index.numElements() != n_glo) computeConnectedClients(globalDim, orderPositionInGrid,  CServerDistributionDescription::ROOT_DISTRIBUTION);
+     }
+     this->isClientAfterTransformationChecked = true;
+   }
+   CATCH_DUMP_ATTR
+   /*
+     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)
+   TRY
+   {
+     if (!this->areClientAttributesChecked_) checkAttributesOnClient();
+     if (!this->isClientAfterTransformationChecked) checkAttributesOnClientAfterTransformation(globalDim, orderPositionInGrid, distType);
+     CContext* context = CContext::getCurrent();
+     if (this->isChecked) return;
+     if (context->hasClient) sendAttributes(globalDim, orderPositionInGrid, distType);
+     this->isChecked = true;
+   }
+   CATCH_DUMP_ATTR
+  /*!
+    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)
+  TRY
+  {
+     sendDistributionAttribute(globalDim, orderPositionInGrid, distType);
+     // if (index.numElements() == n_glo.getValue())
+     if ((orderPositionInGrid == CServerDistributionDescription::defaultDistributedDimension(globalDim.size(), distType))
+         || (index.numElements() != n_glo))
+     {
+       sendDistributedAttributes();
+     }
+     else
+     {
+       sendNonDistributedAttributes();
+     }
+  }
+  CATCH_DUMP_ATTR
+  /*
+    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)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    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 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;
+//              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;
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*
+    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()
+  TRY
+  {
+    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]       = begin;
+    nSize[0]        = 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;
+    std::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;
+    localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements());
+    nbWritten = 0;
+    for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+    {
+      indGlo = *itSrv;
+      if (ite != globalLocalIndexMap_.find(indGlo))
+      {
+        localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo];
+      }
+      else
+      {
+        localIndexToWriteOnServer(nbWritten) = -1;
+      }
+      ++nbWritten;
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm)
+  TRY
+  {
+    int writtenCommSize;
+    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]       = 0;
+      nSize[0]        = n;
+      nBeginGlobal[0] = 0;
+      nGlob[0]        = n_glo;
+      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);
+      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
+      std::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;
+      std::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;
+//        }
+//      }
+      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;
+      bool distributed_glo, distributed=isDistributed() ;
+      MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, writtenComm) ;
+      if (distributed_glo)
+      {
+        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
+        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
+      }
+      else
+        totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize];
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    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)
+  TRY
+  {
+    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];
+          msgs.push_back(CMessage());
+          CMessage& msg = msgs.back();
+          msg << this->getId();
+          msg << ni << begin;
+          msg << isCompressible_;
+          event.push(*itRank,1,msg);
+        }
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*
+    Receive distribution attribute from another client
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvDistributionAttribute(CEventServer& event)
+  TRY
+  {
+    CBufferIn* buffer = event.subEvents.begin()->buffer;
+    string axisId;
+    *buffer >> axisId;
+    get(axisId)->recvDistributionAttribute(*buffer);
+  }
+  CATCH
+  /*
+    Receive distribution attribute from another client
+    \param [in] buffer buffer containing data of these attributes
+  */
+  void CAxis::recvDistributionAttribute(CBufferIn& buffer)
+  TRY
+  {
+    int ni_srv, begin_srv;
+    buffer >> ni_srv >> begin_srv;
+    buffer >> isCompressible_;
+    // Set up new local size of axis on the receiving clients
+    n.setValue(ni_srv);
+    begin.setValue(begin_srv);
+  }
+  CATCH_DUMP_ATTR
+  /*
+    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()
+  TRY
+  {
+    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 = 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 = 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);
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*
+    Receive the non-distributed attributes from another group of clients
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvNonDistributedAttributes(CEventServer& event)
+  TRY
+  {
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      string axisId;
+      *buffer >> axisId;
+      get(axisId)->recvNonDistributedAttributes(it->rank, *buffer);
+    }
+  }
+  CATCH
+  /*
+    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)
+  TRY
+  {
+    CArray<int,1> tmp_index, tmp_data_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;
+  }
+  CATCH_DUMP_ATTR
+  /*
+    Send axis attributes from a group of clients to another group of clients/servers
+    supposing that these attributes are distributed among the clients of the sending group
+    In future, if new attributes are added, they should also be processed in this function
+  */
+  void CAxis::sendDistributedAttributes(void)
+  TRY
+  {
+    int ind, 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<CArray<double,1> > list_val;
+      list<CArray<double,2> > list_bounds;
+      list<CArray<string,1> > list_label;
+      // Cut off the ghost points
+      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(data_index(idx)) = 1;
+      }
+      std::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, nbDataCount = 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));
+        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();
+        dataIndi = -1;
+        for (int n = 0; n < nbData; ++n)
+        {
+          idx = static_cast<int>(it->second[n]);
+          indi(n) = idx;
+          ind = globalLocalIndexMap_[idx];
+          dataIndi(n) = dataIndex(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();
+        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);
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*
+    Receive the distributed attributes from another group of clients
+    \param [in] event event containing data of these attributes
+  */
+  void CAxis::recvDistributedAttributes(CEventServer& event)
+  TRY
+  {
+    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;
+      *buffer >> axisId;
+      buffers.push_back(buffer);
+    }
+    get(axisId)->recvDistributedAttributes(ranks, buffers);
+  }
+  CATCH
+  /*
+    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)
+  TRY
+  {
+    int nbReceived = ranks.size(), idx, ind, gloInd, locInd;
+    vector<CArray<int,1> > vec_indi(nbReceived), vec_dataInd(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 >> hasValue;
+      if (hasValue)
+        buffer >> vec_val[idx];
+      buffer >> hasBounds;
+      if (hasBounds)
+        buffer >> vec_bounds[idx];
+      buffer >> hasLabel;
+      if (hasLabel)
+        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;
+    int nbIndLoc = 0;
+    for (idx = 0; idx < nbReceived; ++idx)
+    {
+      CArray<int,1>& tmp = vec_indi[idx];
+      for (ind = 0; ind < tmp.numElements(); ++ind)
+      {
+         gloInd = tmp(ind);
+         nbIndLoc = (gloInd % n_glo)-begin;
+         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 is incorporated into data_index and is not sent/received anymore
+    mask.resize(0);
+    if (hasValue)
+      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];
+      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 (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);
+    data_n.setValue(data_index.numElements());
+  }
+  CATCH_DUMP_ATTR
+   /* to remove later when reimplementing coupling */
+   void CAxis::sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid)
+   {
+     if (sendAxisToCouplerOut_done_.count(client)!=0) return ;
+     else sendAxisToCouplerOut_done_.insert(client) ;
+     string axisId="_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    }
+  void CAxis::makeAliasForCoupling(const string& fieldId, int posInGrid)
+  {
+    const string axisId = "_axis["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    this->createAlias(axisId) ;
+  }
   /*!
     Compare two axis objects.
 …
    * Go through the hierarchy to find the axis from which the transformations must be inherited
    */
   void CAxis::solveInheritanceTransformation()
+  void CAxis::solveInheritanceTransformation_old()
   TRY
+  {
 …
       for (size_t i = 0; i < refAxis.size(); ++i)
         refAxis[i]->setTransformations(axis->getAllTransformations());
+  }
+  CATCH_DUMP_ATTR
+  void CAxis::solveInheritanceTransformation()
+  TRY
+  {
+    if (solveInheritanceTransformation_done_) return;
+    else solveInheritanceTransformation_done_=true ;
+    CAxis* axis = this;
+    std::list<CAxis*> refAxis;
+    bool out=false ;
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("axis_ref");
+    refAxis.push_front(axis) ;
+    while (axis->hasDirectAxisReference() && !out)
+    {
+      CAxis* lastAxis=axis ;
+      axis = axis->getDirectAxisReference();
+      axis->solveRefInheritance() ;
+      if (!axis->SuperClass::isEqual(lastAxis,excludedAttr)) out=true ;
+      refAxis.push_front(axis) ;
+    }
+    CTransformationPaths::TPath path ;
+    auto& pathList = std::get<2>(path) ;
+    std::get<0>(path) = EElement::AXIS ;
+    std::get<1>(path) = refAxis.front()->getId() ;
+    for (auto& axis : refAxis)
+    {
+      CAxis::TransMapTypes transformations = axis->getAllTransformations();
+      for(auto& transformation : transformations) pathList.push_back({transformation.second->getTransformationType(),
+                                                                      transformation.second->getId()}) ;
+    }
+    transformationPaths_.addPath(path) ;
+  }
   CATCH_DUMP_ATTR
 …
   CATCH_DUMP_ATTR
+   //////////////////////////////////////////////////////////////////////////////////////
+   //  this part is related to distribution, element definition, views and connectors  //
+   //////////////////////////////////////////////////////////////////////////////////////
+   void CAxis::initializeLocalElement(void)
+   {
+      // after checkAttribute index of size n
+      int rank = CContext::getCurrent()->getIntraCommRank() ;
+      CArray<size_t,1> ind(n) ;
+      for (int i=0;i<n;i++) ind(i)=index(i) ;
+      localElement_ = new CLocalElement(rank, n_glo, ind) ;
+   }
+   void CAxis::addFullView(void)
+   {
+      CArray<int,1> index(n) ;
+      for(int i=0; i<n ; i++) index(i)=i ;
+      localElement_ -> addView(CElementView::FULL, index) ;
+   }
+   void CAxis::addWorkflowView(void)
+   {
+     // mask + data are included into data_index
+     int nk=data_index.numElements() ;
+     int nMask=0 ;
+     for(int k=0;k<nk;k++) if (data_index(k)>=0 && data_index(k)<n) nMask++ ;
+     CArray<int,1> index(nMask) ;
+     nMask=0 ;
+     for(int k=0;k<nk;k++)
+       if (data_index(k)>=0 && data_index(k)<n)
+       {
+         index(nMask) = data_index(k) ;
+         nMask++ ;
+       }
+     localElement_ -> addView(CElementView::WORKFLOW, index) ;
+   }
+   void CAxis::addModelView(void)
+   {
+     // information for model view is stored in data_index
+     localElement_->addView(CElementView::MODEL, data_index) ;
+   }
+   void CAxis::computeModelToWorkflowConnector(void)
+   {
+     CLocalView* srcView=getLocalView(CElementView::MODEL) ;
+     CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ;
+     modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);
+     modelToWorkflowConnector_->computeConnector() ;
+   }
+   void CAxis::computeRemoteElement(CContextClient* client, EDistributionType type)
+  {
+    CContext* context = CContext::getCurrent();
+    map<int, CArray<size_t,1>> globalIndex ;
+    if (type==EDistributionType::BANDS) // Bands distribution to send to file server
+    {
+      int nbServer = client->serverSize;
+      int nbClient = client->clientSize ;
+      int rankClient = client->clientRank ;
+      int size = nbServer / nbClient ;
+      int start ;
+      if (nbServer%nbClient > rankClient)
+      {
+       start = (size+1) * rankClient ;
+       size++ ;
+      }
+      else start = size*rankClient + nbServer%nbClient ;
+      for(int i=0; i<size; i++)
+      {
+        int rank=start+i ;
+        size_t indSize = n_glo/nbServer ;
+        size_t indStart ;
+        if (n_glo % nbServer > rank)
+        {
+          indStart = (indSize+1) * rank ;
+          indSize++ ;
+        }
+        else indStart = indSize*rank + n_glo%nbServer ;
+        auto& globalInd =  globalIndex[rank] ;
+        globalInd.resize(indSize) ;
+        for(size_t n = 0 ; n<indSize; n++) globalInd(n)=indStart+n ;
+      }
+    }
+    else if (type==EDistributionType::NONE) // domain is not distributed ie all servers get the same local domain
+    {
+      int nbServer = client->serverSize;
+      size_t nglo=n_glo ;
+      CArray<size_t,1> indGlo(nglo) ;
+      for(size_t i=0;i<nglo;i++) indGlo(i) = i ;
+      for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer].reference(indGlo.copy());
+    }
+    remoteElement_[client] = new CDistributedElement(n_glo, globalIndex) ;
+    remoteElement_[client]->addFullView() ;
+  }
+  void CAxis::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,
+                                 CScattererConnector* &scattererConnector, const string& axisId)
+  {
+    string serverAxisId = axisId.empty() ? this->getId() : axisId ;
+    CContext* context = CContext::getCurrent();
+    this->sendAllAttributesToServer(client, serverAxisId)  ;
+    CDistributedElement scatteredElement(n_glo,globalIndex) ;
+    scatteredElement.addFullView() ;
+    scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),
+                                                 context->getIntraComm(), client->getRemoteSize()) ;
+    scattererConnector->computeConnector() ;
+    // phase 0
+    // send remote element to construct the full view on server, ie without hole
+    CEventClient event0(getType(), EVENT_ID_AXIS_DISTRIBUTION);
+    CMessage message0 ;
+    message0<<serverAxisId<<0 ;
+    remoteElement_[client]->sendToServer(client,event0,message0) ;
+    // phase 1
+    // send the full view of element to construct the connector which connect distributed data coming from client to the full local view
+    CEventClient event1(getType(), EVENT_ID_AXIS_DISTRIBUTION);
+    CMessage message1 ;
+    message1<<serverAxisId<<1<<localElement_->getView(CElementView::FULL)->getGlobalSize() ;
+    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ;
+    sendDistributedAttributes(client, *scattererConnector, axisId) ;
+    // phase 2 send the mask : data index + mask2D
+    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize());
+    CArray<bool,1> maskOut ;
+    CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ;
+    workflowToFull.computeConnector() ;
+    maskIn=true ;
+    workflowToFull.transfer(maskIn,maskOut,false) ;
+    // phase 3 : prepare grid scatterer connector to send data from client to server
+    map<int,CArray<size_t,1>> workflowGlobalIndex ;
+    map<int,CArray<bool,1>> maskOut2 ;
+    scattererConnector->transfer(maskOut, maskOut2) ;
+    scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ;
+    scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ;
+    // create new workflow view for scattered element
+    CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ;
+    clientToServerElement.addFullView() ;
+    CEventClient event2(getType(), EVENT_ID_AXIS_DISTRIBUTION);
+    CMessage message2 ;
+    message2<<serverAxisId<<2 ;
+    clientToServerElement.sendToServer(client, event2, message2) ;
+    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL),
+                                                              context->getIntraComm(), client->getRemoteSize()) ;
+    clientToServerConnector_[client]->computeConnector() ;
+    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW));
+    clientFromServerConnector_[client]->computeConnector() ;
+  }
+  void CAxis::recvAxisDistribution(CEventServer& event)
+  TRY
+  {
+    string axisId;
+    int phasis ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> axisId >> phasis ;
+    get(axisId)->receivedAxisDistribution(event, phasis);
+  }
+  CATCH
+  void CAxis::receivedAxisDistribution(CEventServer& event, int phasis)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    if (phasis==0) // receive the remote element to construct the full view
+    {
+      localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ;
+      localElement_->addFullView() ;
+      // construct the local dimension and indexes
+      auto& globalIndex=localElement_->getGlobalIndex() ;
+      int nk=globalIndex.numElements() ;
+      int minK=n_glo,maxK=-1 ;
+      int nGlo=n_glo ;
+      int indGlo ;
+      for(int k=0;k<nk;k++)
+      {
+        indGlo=globalIndex(k) ;
+        if (indGlo<minK) minK=indGlo ;
+        if (indGlo>maxK) maxK=indGlo ;
+      }
+      if (maxK>=minK) { begin=minK ; n=maxK-minK+1 ; }
+      else {begin=0; n=0 ;}
+    }
+    else if (phasis==1) // receive the sent view from client to construct the full distributed full view on server
+    {
+      CContext* context = CContext::getCurrent();
+      CDistributedElement* elementFrom = new  CDistributedElement(event) ;
+      elementFrom->addFullView() ;
+      gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+      gathererConnector_->computeConnector() ;
+    }
+    else if (phasis==2)
+    {
+//      delete gathererConnector_ ;
+      elementFrom_ = new  CDistributedElement(event) ;
+      elementFrom_->addFullView() ;
+//      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+//      gathererConnector_ -> computeConnector() ;
+    }
+  }
+  CATCH
+  void CAxis::setServerMask(CArray<bool,1>& serverMask, CContextClient* client)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    localElement_->addView(CElementView::WORKFLOW, serverMask) ;
+    mask.reference(serverMask.copy()) ;
+    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
+    serverFromClientConnector_->computeConnector() ;
+    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL),
+                                                         context->getIntraComm(), client->getRemoteSize()) ;
+    serverToClientConnector_->computeConnector() ;
+  }
+  CATCH_DUMP_ATTR
+  void CAxis::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId)
+  {
+    string serverAxisId = axisId.empty() ? this->getId() : axisId ;
+    CContext* context = CContext::getCurrent();
+    if (hasValue)
+    {
+      { // send level value
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverAxisId<<string("value") ;
+        scattererConnector.transfer(value, client, event,message) ;
+      }
+    }
+    if (hasBounds)
+    {
+      { // send bounds level value
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverAxisId<<string("bounds") ;
+        scattererConnector.transfer(2, bounds, client, event,message) ;
+      }
+    }
+    if (hasLabel)
+    {
+      { // send label
+        // need to transform array of string (no fixed size for string) into array of array of char
+        // to use connector to transfer
+        // the strings must have fixed size which the maximum lenght over the string label.
+        int maxSize=0 ;
+        for(int i=0; i<label.numElements();i++)
+          if (maxSize < label(i).size()) maxSize=label(i).size() ;
+        MPI_Allreduce(MPI_IN_PLACE, &maxSize,1,MPI_INT,MPI_MAX, context->getIntraComm()) ;
+        maxSize=maxSize+1 ;
+        CArray<char,2> charArray(maxSize,label.numElements()) ;
+        for(int j=0; j<label.numElements();j++)
+        {
+          const char* str = label(j).c_str() ;
+          int strSize=label(j).size()+1 ;
+          for(int i=0; i<strSize; i++) charArray(i,j) = str[i] ;
+        }
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverAxisId<<string("label")<<maxSize ;
+        scattererConnector.transfer(maxSize, charArray, client, event,message) ;
+      }
+    }
+  }
+  void CAxis::recvDistributedAttributes(CEventServer& event)
+  TRY
+  {
+    string axisId;
+    string type ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> axisId >> type ;
+    get(axisId)->recvDistributedAttributes(event, type);
+  }
+  CATCH
+  void CAxis::recvDistributedAttributes(CEventServer& event, const string& type)
+  TRY
+  {
+    if (type=="value")
+    {
+      gathererConnector_->transfer(event, value, 0.);
+    }
+    else if (type=="bounds")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, 2, value, 0.);
+      bounds.resize(2,n) ;
+      if (bounds.numElements() > 0 ) bounds=CArray<double,2>(value.dataFirst(),shape(2,n),neverDeleteData) ;
+    }
+    else if (type=="label")
+    {
+      int maxSize ;
+      for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> maxSize ;
+      CArray<char,1> value ;
+      gathererConnector_->transfer(event, maxSize, value, '\0');
+      CArray<char,2> charArray(maxSize,n) ;
+      label.resize(n) ;
+      if (n>0)
+      {
+        charArray=CArray<char,2>(value.dataFirst(),shape(maxSize,n),neverDeleteData) ;
+        for(int j=0;j<n;j++)
+        {
+          int strSize ;
+          for(int i=0;i<maxSize;i++)
+            if (charArray(i,j)=='\0') { strSize=i ; break; }
+          string str(strSize,'\0') ;
+          for(int i=0;i<strSize;i++) str[i]=charArray(i,j) ;
+          label(j)=str ;
+        }
+      }
+    }
+  }
+  CATCH
   DEFINE_REF_FUNC(Axis,axis)

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

-                      r1653
+                      r2019
 #include "transformation.hpp"
 #include "transformation_enum.hpp"
+namespace xios {
+#include "transformation_path.hpp"
+#include "element.hpp"
+#include "local_connector.hpp"
+#include "scatterer_connector.hpp"
+#include "gatherer_connector.hpp"
+#include "distribution_type.hpp"
+#include "generic_algorithm_transformation.hpp"
+namespace xios
+{
    /// ////////////////////// DÃ©clarations ////////////////////// ///
 …
          enum EEventId
+         {
+           EVENT_ID_DISTRIBUTION_ATTRIBUTE,
+           EVENT_ID_DISTRIBUTED_VALUE,
+           EVENT_ID_NON_DISTRIBUTED_VALUE,
+           EVENT_ID_NON_DISTRIBUTED_ATTRIBUTES,
+           EVENT_ID_DISTRIBUTED_ATTRIBUTES
+           EVENT_ID_AXIS_DISTRIBUTION,
+           EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE
          } ;
 …
          typedef CAxisAttributes RelAttributes;
          typedef CAxisGroup      RelGroup;
-         typedef CTransformation<CAxis>::TransformationMapTypes TransMapTypes;
       public:
 …
          /// Accesseurs ///
          const std::set<StdString> & getRelFiles(void) const;
+         int getNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
+         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
+         CArray<int, 1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid,
                                                         CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
 …
          bool isWrittenCompressed(const StdString& filename) const;
          bool isDistributed(void) const;
+         bool isCompressible(void) const;
+      public:
+        /*!
+            \brief return if the axis can be written or not in a compressed way.
+            ie if there are some masked or indexed point on the domain. Valid only on server side.
+            \return true if domain can be writtedn in a compressed way
+         */
+         bool isCompressible(void) { if (!isCompressibleComputed_) computeIsCompressible() ; return isCompressible_ ;}
+      private:
+         bool isCompressible_ ; /** specify if the domain can be written in a compressed way */
+         bool isCompressibleComputed_=false ; /** Indicate if compressability has been computed*/
+         void computeIsCompressible() ;
+      public:
          /// Mutateur ///
 …
          void addRelFileCompressed(const StdString& filename);
+         /// VÃ©rifications ///
+         void checkAttributes(void);
          /// Destructeur ///
 …
          static bool dispatchEvent(CEventServer& event);
+         void checkAttributesOnClient();
+         void checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                                         CServerDistributionDescription::ServerDistributionType distType = CServerDistributionDescription::BAND_DISTRIBUTION);
+         void sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                    CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
+         void checkEligibilityForCompressedOutput();
+         /// VÃ©rifications ///
+         void checkAttributes(void);
+         bool checkAttributes_done_ = false ;
          size_t getGlobalWrittenSize(void) ;
+         void computeWrittenIndex();
+         void computeWrittenCompressedIndex(MPI_Comm);
+         bool hasTransformation();
+         void solveInheritanceTransformation();
+         TransMapTypes getAllTransformations();
+         void duplicateTransformation(CAxis*);
+         CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
+      //////////////////////////
+      ///// transformations ////
+      //////////////////////////
+      public:
+        typedef CTransformation<CAxis>::TransformationMapTypes TransMapTypes;
+      private:
+        static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+        static std::map<StdString, ETranformationType> transformationMapList_;
+        static bool dummyTransformationMapList_;
+        TransMapTypes transformationMap_;
+      public:
+        CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
+        CTransformation<CAxis>* addTransformation(ETranformationType transType, CTransformation<CAxis>* transformation) ;
+        void setTransformations(const TransMapTypes&);
+        void duplicateTransformation(CAxis*);
+        TransMapTypes getAllTransformations();
+        bool hasTransformation();
+        void solveInheritanceTransformation_old(); // to remove later
+        void solveInheritanceTransformation();
+      private:
+        bool solveInheritanceTransformation_done_= false ;
+      private:
+        CGenericAlgorithmTransformation* transformationAlgorithm_ = nullptr ;
+      public:
+        void setTransformationAlgorithm(CGenericAlgorithmTransformation* transformationAlgorithm) { transformationAlgorithm_=transformationAlgorithm ;}
+        CGenericAlgorithmTransformation* getTransformationAlgorithm(void) { return transformationAlgorithm_ ;}
+      private:
+        CTransformationPaths transformationPaths_ ;
+      public:
+        CTransformationPaths getTransformationPaths(void) {return transformationPaths_;}
+        void setTransformationPaths(const CTransformationPaths& transformationPaths) { transformationPaths_=transformationPaths ;}
+      ////////////////////////////
          bool isEqual(CAxis* axis);
 …
         bool hasLabel;
-        CArray<int,1> localIndexToWriteOnServer;
       private:
          void checkData();
 …
          void checkBounds();
          void checkLabel();
+         void sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
+                             CServerDistributionDescription::ServerDistributionType distType);
+         void sendDistributionAttribute(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                        CServerDistributionDescription::ServerDistributionType distType);
+         void computeConnectedClients(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                     CServerDistributionDescription::ServerDistributionType distType);
+         void sendNonDistributedAttributes(void);
+         void sendDistributedAttributes(void);
+         static void recvNonDistributedAttributes(CEventServer& event);
+         static void recvDistributedAttributes(CEventServer& event);
+         static void recvDistributionAttribute(CEventServer& event);
+         void recvNonDistributedAttributes(int rank, CBufferIn& buffer);
+         void recvDistributedAttributes(vector<int>& rank, vector<CBufferIn*> buffers);
+         void recvDistributionAttribute(CBufferIn& buffer);
+         void setTransformations(const TransMapTypes&);
+      private:
+/** Clients that have to send a domain. There can be multiple clients in case of secondary server, otherwise only one client. */
+      public:
+         void sendAxisToCouplerOut(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, const string& fieldId, int posInGrid) ;
+      private:
+         std::set<CContextClient*> sendAxisToCouplerOut_done_ ;
+      public:
+         void makeAliasForCoupling(const string& fieldId, int posInGrid) ;
+      private:
+/** Clients that have to send a axis. There can be multiple clients in case of secondary server, otherwise only one client. */
          std::list<CContextClient*> clients;
          std::set<CContextClient*> clientsSet;
+      private:
+         /** define if the axis is completed or not ie all attributes have been received before in case
+             of grid reading from file or coupling */
+         bool isCompleted_=true ;
+      public:
+         /*!
+           \brief Check if a axis is completed
+           Before make any axis processing, we must be sure that all axis informations have
+           been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+           other context (coupling). So all direct reference of the axis (axis_ref) must be also completed
+           \return true if axis and axis reference are completed
+          */
+         bool isCompleted(void)
+         {
+           if (hasDirectAxisReference()) if (!getDirectAxisReference()->isCompleted()) return false;
+           else return isCompleted_ ;
+         }
+         void setCompleted(void) { isCompleted_=true ; }
+         void unsetCompleted(void) { isCompleted_=false ; }
+      private:
          bool isChecked;
-         bool areClientAttributesChecked_;
-         bool isClientAfterTransformationChecked;
          std::set<StdString> relFiles, relFilesCompressed;
+         TransMapTypes transformationMap_;
+         //! True if and only if the data defined on the axis can be outputted in a compressed way
+         bool isCompressible_;
+         std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server
+         std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server
+         // std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server
+         std::unordered_map<size_t,size_t> globalLocalIndexMap_;
+         std::vector<int> indexesToWrite;
+         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
+         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer;
+          std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server
          std::map<int, std::vector<int> > connectedServerRank_;
+         bool computedWrittenIndex_;
+       private:
+         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+         static std::map<StdString, ETranformationType> transformationMapList_;
+         static bool dummyTransformationMapList_;
+       //////////////////////////////////////////////////////////////////////////////////////
+       //  this part is related to distribution, element definition, views and connectors  //
+       //////////////////////////////////////////////////////////////////////////////////////
+        private:
+         CLocalElement* localElement_ = nullptr ;
+         void initializeLocalElement(void) ;
+        public:
+         CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; }
+         CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;}
+        private:
+         void addFullView(void) ;
+         void addWorkflowView(void) ;
+         void addModelView(void) ;
+        private:
+         CLocalConnector* modelToWorkflowConnector_ ;
+         void computeModelToWorkflowConnector(void)  ;
+        public:
+         CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;}
+       public:
+         void computeRemoteElement(CContextClient* client, EDistributionType) ;
+         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector,
+                                 const string& axisId="") ;
+         static void recvAxisDistribution(CEventServer& event) ;
+         void receivedAxisDistribution(CEventServer& event, int phasis) ;
+         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client ) ;
+         void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& axisId) ;
+         static void recvDistributedAttributes(CEventServer& event) ;
+         void recvDistributedAttributes(CEventServer& event, const string& type) ;
+       private:
+         map<CContextClient*, CDistributedElement*> remoteElement_ ;
+       public:
+         CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;}
+       private:
+         map<CContextClient*, CScattererConnector*> clientToServerConnector_ ;
+       public:
+         CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;}
+       private:
+         CGathererConnector*  gathererConnector_ ;
+       public:
+         CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;}
+       private:
+         CGathererConnector* serverFromClientConnector_ ;
+         CDistributedElement* elementFrom_ ;
+       public:
+        CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;}
+       private:
+         CScattererConnector*  serverToClientConnector_ = nullptr ;
+       public:
+         CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}
+       private:
+          map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ;
+       public:
+         CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}
          DECLARE_REF_FUNC(Axis,axis)

XIOS/dev/dev_trunk_graph/src/node/compute_connectivity_domain.cpp

-                      r944
+                      r2019
 #include "compute_connectivity_domain.hpp"
+#include "domain_algorithm_compute_connectivity.hpp"
 #include "type.hpp"
 …
   bool CComputeConnectivityDomain::registerTrans()
+  {
     registerTransformation(TRANS_COMPUTE_CONNECTIVITY_DOMAIN, CComputeConnectivityDomain::create);
+    registerTransformation(TRANS_COMPUTE_CONNECTIVITY_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CComputeConnectivityDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmComputeConnectivity::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/compute_connectivity_domain.hpp

-                      r934
+                      r2019
   class CComputeConnectivityDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CComputeConnectivityDomain> SuperClass;
       typedef CComputeConnectivityDomainAttributes SuperClassAttribute;
+      typedef CComputeConnectivityDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_COMPUTE_CONNECTIVITY_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();
       static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
       static bool _dummyRegistered;
+  }; // class CComputeConnectivityDomain
+    public:
+   }; // class CComputeConnectivityDomain
   DECLARE_GROUP(CComputeConnectivityDomain);

XIOS/dev/dev_trunk_graph/src/node/context.cpp

-                      r1612
+                      r2019
 #include "server.hpp"
 #include "distribute_file_server2.hpp"
+#include "services_manager.hpp"
+#include "contexts_manager.hpp"
+#include "cxios.hpp"
+#include "client.hpp"
+#include "coupler_in.hpp"
+#include "coupler_out.hpp"
 namespace xios {
 …
       , calendar(), hasClient(false), hasServer(false)
       , isPostProcessed(false), finalized(false)
       , idServer_(), client(0), server(0)
       , allProcessed(false), countChildCtx_(0)
+      , client(nullptr), server(nullptr)
+      , allProcessed(false), countChildContextFinalized_(0), isProcessingEvent_(false)
    { /* Ne rien faire de plus */ }
 …
       , calendar(), hasClient(false), hasServer(false)
       , isPostProcessed(false), finalized(false)
       , idServer_(), client(0), server(0)
       , allProcessed(false), countChildCtx_(0)
+      , client(nullptr), server(nullptr)
+      , allProcessed(false), countChildContextFinalized_(0), isProcessingEvent_(false)
    { /* Ne rien faire de plus */ }
 …
    ///---------------------------------------------------------------
+   //! Initialize client side
+   void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/)
+   TRY
+   {
+     hasClient = true;
+     MPI_Comm intraCommServer, interCommServer;
+   void CContext::setClientServerBuffer(vector<CField*>& fields, bool bufferForWriting)
+   TRY
+   {
+      // Estimated minimum event size for small events (20 is an arbitrary constant just for safety)
+     const size_t minEventSize = CEventClient::headerSize + 20 * sizeof(int);
+      // Ensure there is at least some room for 20 of such events in the buffers
+     size_t minBufferSize = std::max(CXios::minBufferSize, 20 * minEventSize);
+#define DECLARE_NODE(Name_, name_)    \
+     if (minBufferSize < sizeof(C##Name_##Definition)) minBufferSize = sizeof(C##Name_##Definition);
+#define DECLARE_NODE_PAR(Name_, name_)
+#include "node_type.conf"
+#undef DECLARE_NODE
+#undef DECLARE_NODE_PAR
+     map<CContextClient*,map<int,size_t>> dataSize ;
+     map<CContextClient*,map<int,size_t>> maxEventSize ;
+     map<CContextClient*,map<int,size_t>> attributesSize ;
+     for(auto field : fields)
+     {
+       field->setContextClientDataBufferSize(dataSize, maxEventSize, bufferForWriting) ;
+       field->setContextClientAttributesBufferSize(attributesSize, maxEventSize, bufferForWriting) ;
+     }
+     if (CServer::serverLevel != 1)
+      // initClient is called by client
+     {
+       client = new CContextClient(this, intraComm, interComm, cxtServer);
+       if (cxtServer) // Attached mode
+     for(auto& it : attributesSize)
+     {
+       auto contextClient = it.first ;
+       auto& contextDataSize =  dataSize[contextClient] ;
+       auto& contextAttributesSize =  attributesSize[contextClient] ;
+       auto& contextMaxEventSize =  maxEventSize[contextClient] ;
+       for (auto& it : contextAttributesSize)
+       {
+         intraCommServer = intraComm;
+         interCommServer = interComm;
+         auto serverRank=it.first ;
+         auto& buffer = contextAttributesSize[serverRank] ;
+         if (contextDataSize[serverRank] > buffer) buffer=contextDataSize[serverRank] ;
+         buffer *= CXios::bufferSizeFactor;
+         if (buffer < minBufferSize) buffer = minBufferSize;
+         if (buffer > CXios::maxBufferSize ) buffer = CXios::maxBufferSize;
+       }
+       else
+       {
+         MPI_Comm_dup(intraComm, &intraCommServer);
+         comms.push_back(intraCommServer);
+         MPI_Comm_dup(interComm, &interCommServer);
+         comms.push_back(interCommServer);
+       }
+/* for registry take the id of client context */
+/* for servers, supress the _server_ from id  */
+       string contextRegistryId=getId() ;
+       size_t pos=contextRegistryId.find("_server_") ;
+       if (pos!=std::string::npos)  contextRegistryId=contextRegistryId.substr(0,pos) ;
+       registryIn=new CRegistry(intraComm);
+       registryIn->setPath(contextRegistryId) ;
+       if (client->clientRank==0) registryIn->fromFile("xios_registry.bin") ;
+       registryIn->bcastRegistry() ;
+       registryOut=new CRegistry(intraComm) ;
+       registryOut->setPath(contextRegistryId) ;
+       server = new CContextServer(this, intraCommServer, interCommServer);
+     }
+     else
+     // initClient is called by primary server
+     {
+       clientPrimServer.push_back(new CContextClient(this, intraComm, interComm));
+       MPI_Comm_dup(intraComm, &intraCommServer);
+       comms.push_back(intraCommServer);
+       MPI_Comm_dup(interComm, &interCommServer);
+       comms.push_back(interCommServer);
+       serverPrimServer.push_back(new CContextServer(this, intraCommServer, interCommServer));
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+       // Leaders will have to send some control events so ensure there is some room for those in the buffers
+       if (contextClient->isServerLeader())
+         for(auto& rank : contextClient->getRanksServerLeader())
+           if (!contextAttributesSize.count(rank))
+           {
+             contextAttributesSize[rank] = minBufferSize;
+             contextMaxEventSize[rank] = minEventSize;
+           }
+       contextClient->setBufferSize(contextAttributesSize, contextMaxEventSize);
+     }
+   }
+   CATCH_DUMP_ATTR
+    /*!
     Sets client buffers.
     \param [in] contextClient
 …
     This flag is only true for client and server-1 for communication with server-2
   */
+  // ym obsolete to be removed
    void CContext::setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting)
    TRY
+   {
       // Estimated minimum event size for small events (10 is an arbitrary constant just for safety)
      const size_t minEventSize = CEventClient::headerSize + getIdServer().size() + 10 * sizeof(int);
+      // Estimated minimum event size for small events (20 is an arbitrary constant just for safety)
+     const size_t minEventSize = CEventClient::headerSize + 20 * sizeof(int);
       // Ensure there is at least some room for 20 of such events in the buffers
 …
    CATCH_DUMP_ATTR
+ /*!
+    * Compute the required buffer size to send the fields data.
+    * \param maxEventSize [in/out] the size of the bigger event for each connected server
+    * \param [in] contextClient
+    * \param [in] bufferForWriting True if buffers are used for sending data for writing
+      This flag is only true for client and server-1 for communication with server-2
+    */
+   std::map<int, StdSize> CContext::getDataBufferSize(std::map<int, StdSize>& maxEventSize,
+                                                      CContextClient* contextClient, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+     std::map<int, StdSize> dataSize;
+     // Find all reference domain and axis of all active fields
+     std::vector<CFile*>& fileList = bufferForWriting ? this->enabledWriteModeFiles : this->enabledReadModeFiles;
+     size_t numEnabledFiles = fileList.size();
+     for (size_t i = 0; i < numEnabledFiles; ++i)
+     {
+       CFile* file = fileList[i];
+       if (file->getContextClient() == contextClient)
+       {
+         std::vector<CField*> enabledFields = file->getEnabledFields();
+         size_t numEnabledFields = enabledFields.size();
+         for (size_t j = 0; j < numEnabledFields; ++j)
+         {
+           // const std::vector<std::map<int, StdSize> > mapSize = enabledFields[j]->getGridDataBufferSize(contextClient);
+           const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataBufferSize(contextClient,bufferForWriting);
+           std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+           for (; it != itE; ++it)
+           {
+             // If dataSize[it->first] does not exist, it will be zero-initialized
+             // so we can use it safely without checking for its existance
+           if (CXios::isOptPerformance)
+               dataSize[it->first] += it->second;
+             else if (dataSize[it->first] < it->second)
+               dataSize[it->first] = it->second;
+           if (maxEventSize[it->first] < it->second)
+               maxEventSize[it->first] = it->second;
+           }
+         }
+       }
+     }
+     return dataSize;
+   }
+   CATCH_DUMP_ATTR
+/*!
+    * Compute the required buffer size to send the attributes (mostly those grid related).
+    * \param maxEventSize [in/out] the size of the bigger event for each connected server
+    * \param [in] contextClient
+    * \param [in] bufferForWriting True if buffers are used for sending data for writing
+      This flag is only true for client and server-1 for communication with server-2
+    */
+   std::map<int, StdSize> CContext::getAttributesBufferSize(std::map<int, StdSize>& maxEventSize,
+                                                           CContextClient* contextClient, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+   // As calendar attributes are sent even if there are no active files or fields, maps are initialized according the size of calendar attributes
+     std::map<int, StdSize> attributesSize = CCalendarWrapper::get(CCalendarWrapper::GetDefName())->getMinimumBufferSizeForAttributes(contextClient);
+     maxEventSize = CCalendarWrapper::get(CCalendarWrapper::GetDefName())->getMinimumBufferSizeForAttributes(contextClient);
+     std::vector<CFile*>& fileList = this->enabledFiles;
+     size_t numEnabledFiles = fileList.size();
+     for (size_t i = 0; i < numEnabledFiles; ++i)
+     {
+//         CFile* file = this->enabledWriteModeFiles[i];
+        CFile* file = fileList[i];
+        std::vector<CField*> enabledFields = file->getEnabledFields();
+        size_t numEnabledFields = enabledFields.size();
+        for (size_t j = 0; j < numEnabledFields; ++j)
+        {
+          const std::map<int, StdSize> mapSize = enabledFields[j]->getGridAttributesBufferSize(contextClient, bufferForWriting);
+          std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+          for (; it != itE; ++it)
+          {
+         // If attributesSize[it->first] does not exist, it will be zero-initialized
+         // so we can use it safely without checking for its existence
+             if (attributesSize[it->first] < it->second)
+         attributesSize[it->first] = it->second;
+         if (maxEventSize[it->first] < it->second)
+         maxEventSize[it->first] = it->second;
+          }
+        }
+     }
+     return attributesSize;
+   }
+   CATCH_DUMP_ATTR
    //! Verify whether a context is initialized
    bool CContext::isInitialized(void)
 …
    CATCH_DUMP_ATTR
+   void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/)
+   void CContext::init(CServerContext* parentServerContext, MPI_Comm intraComm, int serviceType)
+   TRY
+   {
+     parentServerContext_ = parentServerContext ;
+     if (serviceType==CServicesManager::CLIENT)
+       initClient(intraComm, serviceType) ;
+     else
+       initServer(intraComm, serviceType) ;
+    }
+    CATCH_DUMP_ATTR
+//! Initialize client side
+   void CContext::initClient(MPI_Comm intraComm, int serviceType)
+   TRY
+   {
+      intraComm_=intraComm ;
+      MPI_Comm_rank(intraComm_, &intraCommRank_) ;
+      MPI_Comm_size(intraComm_, &intraCommSize_) ;
+      serviceType_ = CServicesManager::CLIENT ;
+      if (serviceType_==CServicesManager::CLIENT)
+      {
+        hasClient=true ;
+        hasServer=false ;
+      }
+      contextId_ = getId() ;
+      attached_mode=true ;
+      if (!CXios::isUsingServer()) attached_mode=false ;
+      string contextRegistryId=getId() ;
+      registryIn=new CRegistry(intraComm);
+      registryIn->setPath(contextRegistryId) ;
+      int commRank ;
+      MPI_Comm_rank(intraComm_,&commRank) ;
+      if (commRank==0) registryIn->fromFile("xios_registry.bin") ;
+      registryIn->bcastRegistry() ;
+      registryOut=new CRegistry(intraComm_) ;
+      registryOut->setPath(contextRegistryId) ;
+   }
+   CATCH_DUMP_ATTR
+   void CContext::initServer(MPI_Comm intraComm, int serviceType)
    TRY
+   {
      hasServer=true;
+     server = new CContextServer(this,intraComm,interComm);
+/* for registry take the id of client context */
+/* for servers, supress the _server_ from id  */
+     string contextRegistryId=getId() ;
+     size_t pos=contextRegistryId.find("_server_") ;
+     if (pos!=std::string::npos)  contextRegistryId=contextRegistryId.substr(0,pos) ;
+     intraComm_=intraComm ;
+     MPI_Comm_rank(intraComm_, &intraCommRank_) ;
+     MPI_Comm_size(intraComm_, &intraCommSize_) ;
+     serviceType_=serviceType ;
+     if (serviceType_==CServicesManager::GATHERER)
+     {
+       hasClient=true ;
+       hasServer=true ;
+     }
+     else if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)
+     {
+       hasClient=false ;
+       hasServer=true ;
+     }
+     CXios::getContextsManager()->getContextId(getId(), contextId_, intraComm) ;
      registryIn=new CRegistry(intraComm);
+     registryIn->setPath(contextRegistryId) ;
+     if (server->intraCommRank==0) registryIn->fromFile("xios_registry.bin") ;
+     registryIn->setPath(contextId_) ;
+     int commRank ;
+     MPI_Comm_rank(intraComm_,&commRank) ;
+     if (commRank==0) registryIn->fromFile("xios_registry.bin") ;
      registryIn->bcastRegistry() ;
      registryOut=new CRegistry(intraComm) ;
+     registryOut->setPath(contextRegistryId) ;
+     MPI_Comm intraCommClient, interCommClient;
+     if (cxtClient) // Attached mode
+     {
+       intraCommClient = intraComm;
+       interCommClient = interComm;
+     }
+     else
+     {
+       MPI_Comm_dup(intraComm, &intraCommClient);
+       comms.push_back(intraCommClient);
+       MPI_Comm_dup(interComm, &interCommClient);
+       comms.push_back(interCommClient);
+     }
+     client = new CContextClient(this,intraCommClient,interCommClient, cxtClient);
+   }
+   CATCH_DUMP_ATTR
+   //! Try to send the buffers and receive possible answers
+  bool CContext::checkBuffersAndListen(bool enableEventsProcessing /*= true*/)
+     registryOut->setPath(contextId_) ;
+   }
+   CATCH_DUMP_ATTR
+  void CContext::createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer) // for servers
   TRY
+  {
+    bool clientReady, serverFinished;
+    // Only classical servers are non-blocking
+    if (CServer::serverLevel == 0)
+    {
+      client->checkBuffers();
+      bool hasTmpBufferedEvent = client->hasTemporarilyBufferedEvent();
+      if (hasTmpBufferedEvent)
+        hasTmpBufferedEvent = !client->sendTemporarilyBufferedEvent();
+      // Don't process events if there is a temporarily buffered event
+      return server->eventLoop(!hasTmpBufferedEvent || !enableEventsProcessing);
+    }
+    else if (CServer::serverLevel == 1)
+    {
+      if (!finalized)
+        client->checkBuffers();
+      bool serverFinished = true;
+      if (!finalized)
+        serverFinished = server->eventLoop(enableEventsProcessing);
+      bool serverPrimFinished = true;
+      for (int i = 0; i < clientPrimServer.size(); ++i)
+      {
+        if (!finalized)
+          clientPrimServer[i]->checkBuffers();
+        if (!finalized)
+          serverPrimFinished *= serverPrimServer[i]->eventLoop(enableEventsProcessing);
+      }
+      return ( serverFinished && serverPrimFinished);
+    }
+    else if (CServer::serverLevel == 2)
+    {
+      client->checkBuffers();
+      return server->eventLoop(enableEventsProcessing);
+    }
+    MPI_Comm intraCommClient ;
+    MPI_Comm_dup(intraComm_, &intraCommClient);
+    comms.push_back(intraCommClient);
+    // attached_mode=parentServerContext_->isAttachedMode() ; //ym probably inherited from source context
+    server = new CContextServer(this,intraComm_, interCommServer); // check if we need to dupl. intraComm_ ?
+    client = new CContextClient(this,intraCommClient,interCommClient);
+    client->setAssociatedServer(server) ;
+    server->setAssociatedClient(client) ;
+  }
+   CATCH_DUMP_ATTR
+   //! Terminate a context
+  CATCH_DUMP_ATTR
+  void CContext::createServerInterComm(void)
+  TRY
+  {
+    MPI_Comm interCommClient, interCommServer ;
+    if (serviceType_ == CServicesManager::CLIENT)
+    {
+      int commRank ;
+      MPI_Comm_rank(intraComm_,&commRank) ;
+      if (commRank==0)
+      {
+        if (attached_mode) CXios::getContextsManager()->createServerContext(CClient::getPoolRessource()->getId(), CXios::defaultServerId, 0, getContextId()) ;
+        else if (CXios::usingServer2) CXios::getContextsManager()->createServerContext(CXios::defaultPoolId, CXios::defaultGathererId, 0, getContextId()) ;
+        else  CXios::getContextsManager()->createServerContext(CXios::defaultPoolId, CXios::defaultServerId, 0, getContextId()) ;
+      }
+      MPI_Comm interComm ;
+      if (attached_mode)
+      {
+        parentServerContext_->createIntercomm(CClient::getPoolRessource()->getId(), CXios::defaultServerId, 0, getContextId(), intraComm_,
+                                              interCommClient, interCommServer) ;
+        int type ;
+        if (commRank==0) CXios::getServicesManager()->getServiceType(CClient::getPoolRessource()->getId(), CXios::defaultServerId, 0, type) ;
+        MPI_Bcast(&type,1,MPI_INT,0,intraComm_) ;
+        setCurrent(getId()) ; // getCurrent/setCurrent may be supress, it can cause a lot of trouble
+      }
+      else if (CXios::usingServer2)
+      {
+//      CXios::getContextsManager()->createServerContextIntercomm(CXios::defaultPoolId, CXios::defaultGathererId, 0, getContextId(), intraComm_, interComm) ;
+        parentServerContext_->createIntercomm(CXios::defaultPoolId, CXios::defaultGathererId, 0, getContextId(), intraComm_,
+                                              interCommClient, interCommServer) ;
+        int type ;
+        if (commRank==0) CXios::getServicesManager()->getServiceType(CXios::defaultPoolId, CXios::defaultGathererId, 0, type) ;
+        MPI_Bcast(&type,1,MPI_INT,0,intraComm_) ;
+      }
+      else
+      {
+        //CXios::getContextsManager()->createServerContextIntercomm(CXios::defaultPoolId, CXios::defaultServerId, 0, getContextId(), intraComm_, interComm) ;
+        parentServerContext_->createIntercomm(CXios::defaultPoolId, CXios::defaultServerId, 0, getContextId(), intraComm_,
+                                              interCommClient, interCommServer) ;
+        int type ;
+        if (commRank==0) CXios::getServicesManager()->getServiceType(CXios::defaultPoolId, CXios::defaultServerId, 0, type) ;
+        MPI_Bcast(&type,1,MPI_INT,0,intraComm_) ;
+      }
+        // intraComm client is not duplicated. In all the code we use client->intraComm for MPI
+        // in future better to replace it by intracommuncator associated to the context
+      MPI_Comm intraCommClient, intraCommServer ;
+      intraCommClient=intraComm_ ;
+      MPI_Comm_dup(intraComm_, &intraCommServer) ;
+      client = new CContextClient(this, intraCommClient, interCommClient);
+      server = new CContextServer(this, intraCommServer, interCommServer);
+      client->setAssociatedServer(server) ;
+      server->setAssociatedClient(client) ;
+    }
+    if (serviceType_ == CServicesManager::GATHERER)
+    {
+      int commRank ;
+      MPI_Comm_rank(intraComm_,&commRank) ;
+      int nbPartitions ;
+      if (commRank==0)
+      {
+        CXios::getServicesManager()->getServiceNbPartitions(CXios::defaultPoolId, CXios::defaultServerId, 0, nbPartitions) ;
+        for(int i=0 ; i<nbPartitions; i++)
+          CXios::getContextsManager()->createServerContext(CXios::defaultPoolId, CXios::defaultServerId, i, getContextId()) ;
+      }
+      MPI_Bcast(&nbPartitions, 1, MPI_INT, 0, intraComm_) ;
+      MPI_Comm interComm ;
+      for(int i=0 ; i<nbPartitions; i++)
+      {
+        parentServerContext_->createIntercomm(CXios::defaultPoolId, CXios::defaultServerId, i, getContextId(), intraComm_, interCommClient, interCommServer) ;
+        int type ;
+        if (commRank==0) CXios::getServicesManager()->getServiceType(CXios::defaultPoolId, CXios::defaultServerId, 0, type) ;
+        MPI_Bcast(&type,1,MPI_INT,0,intraComm_) ;
+        primServerId_.push_back(CXios::getContextsManager()->getServerContextName(CXios::defaultPoolId, CXios::defaultServerId, i, type, getContextId())) ;
+        // intraComm client is not duplicated. In all the code we use client->intraComm for MPI
+        // in future better to replace it by intracommuncator associated to the context
+        MPI_Comm intraCommClient, intraCommServer ;
+        intraCommClient=intraComm_ ;
+        MPI_Comm_dup(intraComm_, &intraCommServer) ;
+        CContextClient* client = new CContextClient(this, intraCommClient, interCommClient) ;
+        CContextServer* server = new CContextServer(this, intraCommServer, interCommServer) ;
+        client->setAssociatedServer(server) ;
+        server->setAssociatedClient(client) ;
+        clientPrimServer.push_back(client);
+        serverPrimServer.push_back(server);
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  bool CContext::eventLoop(bool enableEventsProcessing)
+  {
+    bool finished=true;
+    if (client!=nullptr && !finalized) client->checkBuffers();
+    for (int i = 0; i < clientPrimServer.size(); ++i)
+    {
+      if (!finalized) clientPrimServer[i]->checkBuffers();
+      if (!finalized) finished &= serverPrimServer[i]->eventLoop(enableEventsProcessing);
+    }
+    for (auto couplerOut : couplerOutClient_)
+      if (!finalized) couplerOut.second->checkBuffers();
+    for (auto couplerIn : couplerInClient_)
+      if (!finalized) couplerIn.second->checkBuffers();
+    for (auto couplerOut : couplerOutServer_)
+      if (!finalized) couplerOut.second->eventLoop(enableEventsProcessing);
+    for (auto couplerIn : couplerInServer_)
+      if (!finalized) couplerIn.second->eventLoop(enableEventsProcessing);
+    if (server!=nullptr) if (!finalized) finished &= server->eventLoop(enableEventsProcessing);
+    return finalized && finished ;
+  }
+  void CContext::addCouplingChanel(const std::string& fullContextId, bool out)
+  {
+     int contextLeader ;
+     if (out)
+     {
+       if (couplerOutClient_.find(fullContextId)==couplerOutClient_.end())
+       {
+         bool ok=CXios::getContextsManager()->getContextLeader(fullContextId, contextLeader, getIntraComm()) ;
+         MPI_Comm interComm, interCommClient, interCommServer  ;
+         MPI_Comm intraCommClient, intraCommServer ;
+         if (ok) MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
+        MPI_Comm_dup(intraComm_, &intraCommClient) ;
+        MPI_Comm_dup(intraComm_, &intraCommServer) ;
+        MPI_Comm_dup(interComm, &interCommClient) ;
+        MPI_Comm_dup(interComm, &interCommServer) ;
+        CContextClient* client = new CContextClient(this, intraCommClient, interCommClient);
+        CContextServer* server = new CContextServer(this, intraCommServer, interCommServer);
+        client->setAssociatedServer(server) ;
+        server->setAssociatedClient(client) ;
+        MPI_Comm_free(&interComm) ;
+        couplerOutClient_[fullContextId] = client ;
+        couplerOutServer_[fullContextId] = server ;
+/*
+      // for now, we don't now which beffer size must be used for client coupler
+      // It will be evaluated later. Fix a constant size for now...
+      // set to 10Mb for development
+       map<int,size_t> bufferSize, maxEventSize ;
+       for(int i=0;i<client->getRemoteSize();i++)
+       {
+         bufferSize[i]=10000000 ;
+         maxEventSize[i]=10000000 ;
+       }
+       client->setBufferSize(bufferSize, maxEventSize);
+*/
+      }
+    }
+    else if (couplerInClient_.find(fullContextId)==couplerInClient_.end())
+    {
+      bool ok=CXios::getContextsManager()->getContextLeader(fullContextId, contextLeader, getIntraComm()) ;
+       MPI_Comm interComm, interCommClient, interCommServer  ;
+       MPI_Comm intraCommClient, intraCommServer ;
+       if (ok) MPI_Intercomm_create(getIntraComm(), 0, CXios::getXiosComm(), contextLeader, 0, &interComm) ;
+       MPI_Comm_dup(intraComm_, &intraCommClient) ;
+       MPI_Comm_dup(intraComm_, &intraCommServer) ;
+       MPI_Comm_dup(interComm, &interCommServer) ;
+       MPI_Comm_dup(interComm, &interCommClient) ;
+       CContextServer* server = new CContextServer(this, intraCommServer, interCommServer);
+       CContextClient* client = new CContextClient(this, intraCommClient, interCommClient);
+       client->setAssociatedServer(server) ;
+       server->setAssociatedClient(client) ;
+       MPI_Comm_free(&interComm) ;
+       map<int,size_t> bufferSize, maxEventSize ;
+       for(int i=0;i<client->getRemoteSize();i++)
+       {
+         bufferSize[i]=10000000 ;
+         maxEventSize[i]=10000000 ;
+       }
+       client->setBufferSize(bufferSize, maxEventSize);
+       couplerInClient_[fullContextId] = client ;
+       couplerInServer_[fullContextId] = server ;
+    }
+  }
+  void CContext::globalEventLoop(void)
+  {
+    CXios::getDaemonsManager()->eventLoop() ;
+    setCurrent(getId()) ;
+  }
    void CContext::finalize(void)
    TRY
+   {
+      if (hasClient && !hasServer) // For now we only use server level 1 to read data
+      {
+        doPreTimestepOperationsForEnabledReadModeFiles();
+      }
+     // Send registry upon calling the function the first time
+     if (countChildCtx_ == 0)
+       if (hasClient) sendRegistry() ;
+     // Client:
+     // (1) blocking send context finalize to its server
+     // (2) blocking receive context finalize from its server
+     // (3) some memory deallocations
+     if (CXios::isClient)
+     {
+       // Make sure that client (model) enters the loop only once
+       if (countChildCtx_ < 1)
+       {
+         ++countChildCtx_;
+         client->finalize();
+         while (client->havePendingRequests())
+            client->checkBuffers();
+         while (!server->hasFinished())
+           server->eventLoop();
+         if (hasServer) // Mode attache
+      registryOut->hierarchicalGatherRegistry() ;
+      if (server->intraCommRank==0) CXios::globalRegistry->mergeRegistry(*registryOut) ;
+      if (serviceType_==CServicesManager::CLIENT)
+      {
+//ym        doPreTimestepOperationsForEnabledReadModeFiles(); // For now we only use server level 1 to read data
+        triggerLateFields() ;
+        // inform couplerIn that I am finished
+        for(auto& couplerInClient : couplerInClient_) sendCouplerInContextFinalized(couplerInClient.second) ;
+        // wait until received message from couplerOut that they have finished
+        bool couplersInFinalized ;
+        do
+        {
+          couplersInFinalized=true ;
+          for(auto& couplerOutClient : couplerOutClient_) couplersInFinalized &= isCouplerInContextFinalized(couplerOutClient.second) ;
+          globalEventLoop() ;
+        } while (!couplersInFinalized) ;
+        info(100)<<"DEBUG: context "<<getId()<<" Send client finalize"<<endl ;
+        client->finalize();
+        info(100)<<"DEBUG: context "<<getId()<<" Client finalize sent"<<endl ;
+        while (client->havePendingRequests()) client->checkBuffers();
+        info(100)<<"DEBUG: context "<<getId()<<" no pending request ok"<<endl ;
+        bool notifiedFinalized=false ;
+        do
+        {
+          notifiedFinalized=client->isNotifiedFinalized() ;
+        } while (!notifiedFinalized) ;
+        client->releaseBuffers();
+        info(100)<<"DEBUG: context "<<getId()<<" release client ok"<<endl ;
+      }
+      else if (serviceType_==CServicesManager::GATHERER)
+      {
+         for (int i = 0; i < clientPrimServer.size(); ++i)
+         {
+           closeAllFile();
+           registryOut->hierarchicalGatherRegistry() ;
+           if (server->intraCommRank==0) CXios::globalRegistry->mergeRegistry(*registryOut) ;
+           clientPrimServer[i]->finalize();
+           bool bufferReleased;
+           do
+           {
+             clientPrimServer[i]->checkBuffers();
+             bufferReleased = !clientPrimServer[i]->havePendingRequests();
+           } while (!bufferReleased);
+           bool notifiedFinalized=false ;
+           do
+           {
+             notifiedFinalized=clientPrimServer[i]->isNotifiedFinalized() ;
+           } while (!notifiedFinalized) ;
+           clientPrimServer[i]->releaseBuffers();
+         }
+         //! Deallocate client buffers
+         client->releaseBuffers();
+         //! Free internally allocated communicators
+         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           MPI_Comm_free(&(*it));
+         comms.clear();
+         info(20)<<"CContext: Context <"<<getId()<<"> is finalized."<<endl;
+       }
+     }
+     else if (CXios::isServer)
+     {
+       // First context finalize message received from a model
+       // Send context finalize to its child contexts (if any)
+       if (countChildCtx_ == 0)
+         for (int i = 0; i < clientPrimServer.size(); ++i)
+           clientPrimServer[i]->finalize();
+       // (Last) context finalized message received
+       if (countChildCtx_ == clientPrimServer.size())
+       {
+         // Blocking send of context finalize message to its client (e.g. primary server or model)
+         info(100)<<"DEBUG: context "<<getId()<<" Send client finalize<<"<<endl ;
+         client->finalize();
+         bool bufferReleased;
+         do
+         {
+           client->checkBuffers();
+           bufferReleased = !client->havePendingRequests();
+         } while (!bufferReleased);
+         finalized = true;
+         closeAllFile(); // Just move to here to make sure that server-level 1 can close files
+         if (hasServer && !hasClient)
+         {
+           registryOut->hierarchicalGatherRegistry() ;
+           if (server->intraCommRank==0) CXios::globalRegistry->mergeRegistry(*registryOut) ;
+         }
+         //! Deallocate client buffers
+         client->releaseBuffers();
+         for (int i = 0; i < clientPrimServer.size(); ++i)
+           clientPrimServer[i]->releaseBuffers();
+         //! Free internally allocated communicators
+         for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it)
+           MPI_Comm_free(&(*it));
+         comms.clear();
+         info(20)<<"CContext: Context <"<<getId()<<"> is finalized."<<endl;
+       }
+       ++countChildCtx_;
+     }
+         closeAllFile();
+      }
+      else if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)
+      {
+        closeAllFile();
+      }
+      freeComms() ;
+      parentServerContext_->freeComm() ;
+      finalized = true;
+      info(20)<<"CContext: Context <"<<getId()<<"> is finalized."<<endl;
+   }
    CATCH_DUMP_ATTR
 …
    CATCH_DUMP_ATTR
+   void CContext::postProcessingGlobalAttributes()
+   TRY
+   {
+     if (allProcessed) return;
+     // After xml is parsed, there are some more works with post processing
+     postProcessing();
+     // Check grid and calculate its distribution
+     checkGridEnabledFields();
+     // Distribute files between secondary servers according to the data size
+     distributeFiles();
+     setClientServerBuffer(client, (hasClient && !hasServer));
+     for (int i = 0; i < clientPrimServer.size(); ++i)
+         setClientServerBuffer(clientPrimServer[i], true);
+     if (hasClient)
+     {
+      // Send all attributes of current context to server
+      this->sendAllAttributesToServer();
+      // Send all attributes of current calendar
+      CCalendarWrapper::get(CCalendarWrapper::GetDefName())->sendAllAttributesToServer();
+      // We have enough information to send to server
+      // First of all, send all enabled files
+      sendEnabledFiles(this->enabledWriteModeFiles);
+      // We only use server-level 1 (for now) to read data
+      if (!hasServer)
+        sendEnabledFiles(this->enabledReadModeFiles);
+      // Then, send all enabled fields
+      sendEnabledFieldsInFiles(this->enabledWriteModeFiles);
+      if (!hasServer)
+        sendEnabledFieldsInFiles(this->enabledReadModeFiles);
+      // Then, check whether we have domain_ref, axis_ref or scalar_ref attached to the enabled fields
+      // If any, so send them to server
+       sendRefDomainsAxisScalars(this->enabledWriteModeFiles);
+      if (!hasServer)
+        sendRefDomainsAxisScalars(this->enabledReadModeFiles);
+       // Check whether enabled fields have grid_ref, if any, send this info to server
+      sendRefGrid(this->enabledFiles);
+      // This code may be useful in the future when we want to seperate completely read and write
+      // sendRefGrid(this->enabledWriteModeFiles);
+      // if (!hasServer)
+      //   sendRefGrid(this->enabledReadModeFiles);
+      // A grid of enabled fields composed of several components which must be checked then their
+      // checked attributes should be sent to server
+      sendGridComponentEnabledFieldsInFiles(this->enabledFiles); // This code can be seperated in two (one for reading, another for writing)
+       // We have a xml tree on the server side and now, it should be also processed
+      sendPostProcessing();
+      // Finally, we send information of grid itself to server
+      sendGridEnabledFieldsInFiles(this->enabledWriteModeFiles);
+      if (!hasServer)
+        sendGridEnabledFieldsInFiles(this->enabledReadModeFiles);
+     }
+     allProcessed = true;
+   }
+   CATCH_DUMP_ATTR
+   void CContext::sendPostProcessingGlobalAttributes()
+   TRY
+   {
+      // Use correct context client to send message
+     // int nbSrvPools = (hasServer) ? clientPrimServer.size() : 1;
+    int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (0 != clientPrimServer.size()) ? clientPrimServer[i] : client;
+       CEventClient event(getType(),EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES);
+       if (contextClientTmp->isServerLeader())
+       {
+         CMessage msg;
+         if (hasServer)
+           msg<<this->getIdServer(i);
+         else
+           msg<<this->getIdServer();
+         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+           event.push(*itRank,1,msg);
+         contextClientTmp->sendEvent(event);
+       }
+       else contextClientTmp->sendEvent(event);
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CContext::recvPostProcessingGlobalAttributes(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->recvPostProcessingGlobalAttributes(*buffer);
+   }
+   CATCH
+   void CContext::recvPostProcessingGlobalAttributes(CBufferIn& buffer)
+   TRY
+   {
+      postProcessingGlobalAttributes();
+   }
+   CATCH_DUMP_ATTR
    /*!
    \brief Close all the context defintion and do processing data
 …
    and the active fields (fields will be written onto active files)
    */
+   void CContext::closeDefinition(void)
+   TRY
+   {
+    CTimer::get("Context : close definition").resume() ;
+    postProcessingGlobalAttributes();
+    if (hasClient) sendPostProcessingGlobalAttributes();
+    // There are some processings that should be done after all of above. For example: check mask or index
+    this->buildFilterGraphOfEnabledFields();
+  void CContext::closeDefinition(void)
+   TRY
+   {
+     CTimer::get("Context : close definition").resume() ;
+     // create intercommunicator with servers.
+     // not sure it is the good place to be called here
+     createServerInterComm() ;
+     // After xml is parsed, there are some more works with post processing
+//     postProcessing();
+     if (hasClient && !hasServer)
+    {
+      buildFilterGraphOfFieldsWithReadAccess();
+      postProcessFilterGraph();
+    }
+    // Make sure the calendar was correctly created
+    if (serviceType_!=CServicesManager::CLIENT) CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar();
+    if (!calendar)
+      ERROR("CContext::postProcessing()", << "A calendar must be defined for the context \"" << getId() << "!\"")
+    else if (calendar->getTimeStep() == NoneDu)
+      ERROR("CContext::postProcessing()", << "A timestep must be defined for the context \"" << getId() << "!\"")
+    // Calendar first update to set the current date equals to the start date
+    calendar->update(0);
+    // RÃ©solution des hÃ©ritages descendants (cÃ d des hÃ©ritages de groupes)
+    // pour chacun des contextes.
+    solveDescInheritance(true);
+    // Solve inheritance for field to know if enabled or not.
+    for (auto field : CField::getAll()) field->solveRefInheritance();
+    // Check if some axis, domains or grids are eligible to for compressed indexed output.
+    // Warning: This must be done after solving the inheritance and before the rest of post-processing
+    // --> later ????    checkAxisDomainsGridsEligibilityForCompressedOutput();
+      // Check if some automatic time series should be generated
+      // Warning: This must be done after solving the inheritance and before the rest of post-processing
+    // The timeseries should only be prepared in client
+    prepareTimeseries();
+    //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers Ã  sortir.
+    findEnabledFiles();
+    findEnabledWriteModeFiles();
+    findEnabledReadModeFiles();
+    findEnabledCouplerIn();
+    findEnabledCouplerOut();
+    createCouplerInterCommunicator() ;
+    // Find all enabled fields of each file
+    vector<CField*>&& fileOutField = findAllEnabledFieldsInFileOut(this->enabledWriteModeFiles);
+    vector<CField*>&& fileInField = findAllEnabledFieldsInFileIn(this->enabledReadModeFiles);
+    vector<CField*>&& couplerOutField = findAllEnabledFieldsCouplerOut(this->enabledCouplerOut);
+    vector<CField*>&& couplerInField = findAllEnabledFieldsCouplerIn(this->enabledCouplerIn);
+    findFieldsWithReadAccess();
+    vector<CField*>& fieldWithReadAccess = fieldsWithReadAccess_ ;
+    vector<CField*> fieldModelIn ; // fields potentially from model
+    // define if files are on clientSied or serverSide
+    if (serviceType_==CServicesManager::CLIENT)
+    {
+      for (auto& file : enabledWriteModeFiles) file->setClientSide() ;
+      for (auto& file : enabledReadModeFiles) file->setClientSide() ;
+    }
+    else
+    {
+      for (auto& file : enabledWriteModeFiles) file->setServerSide() ;
+      for (auto& file : enabledReadModeFiles) file->setServerSide() ;
+    }
+    checkGridEnabledFields();
+    if (hasClient) this->sendProcessingGridOfEnabledFields();
+    if (hasClient) this->sendCloseDefinition();
+    // Nettoyage de l'arborescence
+    if (hasClient) CleanTree(); // Only on client side??
+    if (hasClient)
+    {
+      sendCreateFileHeader();
+      if (!hasServer) startPrefetchingOfEnabledReadModeFiles();
+    }
+    CTimer::get("Context : close definition").suspend() ;
+   }
+   CATCH_DUMP_ATTR
+   void CContext::findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
+   TRY
+   {
+     for (unsigned int i = 0; i < activeFiles.size(); i++)
+     (void)activeFiles[i]->getEnabledFields();
+   }
+   CATCH_DUMP_ATTR
+    for (auto& field : couplerInField)
+    {
+      field->unsetGridCompleted() ;
+    }
+// find all field potentially at workflow end
+    vector<CField*> endWorkflowFields ;
+    endWorkflowFields.reserve(fileOutField.size()+couplerOutField.size()+fieldWithReadAccess.size()) ;
+    endWorkflowFields.insert(endWorkflowFields.end(),fileOutField.begin(), fileOutField.end()) ;
+    endWorkflowFields.insert(endWorkflowFields.end(),couplerOutField.begin(), couplerOutField.end()) ;
+    endWorkflowFields.insert(endWorkflowFields.end(),fieldWithReadAccess.begin(), fieldWithReadAccess.end()) ;
+    bool workflowGraphIsCompleted ;
+    bool first=true ;
+    do
+    {
+      workflowGraphIsCompleted=true;
+      for(auto endWorkflowField : endWorkflowFields)
+      {
+        workflowGraphIsCompleted &= endWorkflowField->buildWorkflowGraph(garbageCollector) ;
+      }
+      for(auto couplerIn : enabledCouplerIn) couplerIn->assignContext() ;
+      for(auto field : couplerInField) field->makeGridAliasForCoupling();
+      for(auto field : couplerInField) this->sendCouplerInReady(field->getContextClient()) ;
+      // assign context to coupler out and related fields
+      for(auto couplerOut : enabledCouplerOut) couplerOut->assignContext() ;
+      // for now supose that all coupling out endpoint are succesfull. The difficultie is client/server buffer evaluation
+      for(auto field : couplerOutField)
+      {
+        // connect to couplerOut -> to do
+      }
+      if (first) setClientServerBuffer(couplerOutField, true) ; // set buffer context --> to check
+      bool couplersReady ;
+      do
+      {
+        couplersReady=true ;
+        for(auto field : couplerOutField)
+        {
+          bool ready = isCouplerInReady(field->getContextClient()) ;
+          if (ready) field->sendFieldToCouplerOut() ;
+          couplersReady &= ready ;
+        }
+        if (!couplersReady) this->eventLoop() ;
+      } while (!couplersReady) ;
+      first=false ;
+      this->eventLoop() ;
+    } while (!workflowGraphIsCompleted) ;
+    for( auto field : couplerInField) couplerInFields_.push_back(field) ;
+    // get all field coming potentially from model
+    for (auto field : CField::getAll() ) if (field->getModelIn()) fieldModelIn.push_back(field) ;
+    // Distribute files between secondary servers according to the data size => assign a context to a file and then to fields
+    if (serviceType_==CServicesManager::GATHERER) distributeFiles(this->enabledWriteModeFiles);
+    else if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledWriteModeFiles) file->setContextClient(client) ;
+    // client side, assign context for file reading
+    if (serviceType_==CServicesManager::CLIENT) for(auto file : this->enabledReadModeFiles) file->setContextClient(client) ;
+    // server side, assign context where to send file data read
+    if (serviceType_==CServicesManager::CServicesManager::GATHERER || serviceType_==CServicesManager::IO_SERVER)
+      for(auto file : this->enabledReadModeFiles) file->setContextClient(client) ;
+    // workflow endpoint => sent to IO/SERVER
+    if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER)
+    {
+      for(auto field : fileOutField)
+      {
+        field->connectToFileServer(garbageCollector) ; // connect the field to server filter
+      }
+      setClientServerBuffer(fileOutField, true) ; // set buffer context --> to review
+      for(auto field : fileOutField) field->sendFieldToFileServer() ;
+    }
+    // workflow endpoint => write to file
+    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)
+    {
+      for(auto field : fileOutField)
+      {
+        field->connectToFileWriter(garbageCollector) ; // connect the field to server filter
+      }
+    }
+    // workflow endpoint => Send data from server to client
+    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::GATHERER)
+    {
+      for(auto field : fileInField)
+      {
+        field->connectToServerToClient(garbageCollector) ;
+      }
+    }
+    // workflow endpoint => sent to model on client side
+    if (serviceType_==CServicesManager::CLIENT)
+    {
+      for(auto field : fieldWithReadAccess) field->connectToModelOutput(garbageCollector) ;
+    }
+    // workflow startpoint => data from model
+    if (serviceType_==CServicesManager::CLIENT)
+    {
+      for(auto field : fieldModelIn)
+      {
+        field->connectToModelInput(garbageCollector) ; // connect the field to server filter
+        // grid index will be computed on the fly
+      }
+    }
+    // workflow startpoint => data from client on server side
+    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::GATHERER || serviceType_==CServicesManager::OUT_SERVER)
+    {
+      for(auto field : fieldModelIn)
+      {
+        field->connectToClientInput(garbageCollector) ; // connect the field to server filter
+      }
+    }
+    for(auto field : couplerInField)
+    {
+      field->connectToCouplerIn(garbageCollector) ; // connect the field to server filter
+    }
+    for(auto field : couplerOutField)
+    {
+      field->connectToCouplerOut(garbageCollector) ; // for now the same kind of filter that for file server
+    }
+     // workflow startpoint => data from server on client side
+    if (serviceType_==CServicesManager::CLIENT)
+    {
+      for(auto field : fileInField)
+      {
+        field->sendFieldToInputFileServer() ;
+        field->connectToServerInput(garbageCollector) ; // connect the field to server filter
+        fileInFields_.push_back(field) ;
+      }
+    }
+    // workflow startpoint => data read from file on server side
+    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::GATHERER)
+    {
+      for(auto field : fileInField)
+      {
+        field->connectToFileReader(garbageCollector) ;
+      }
+    }
+    // construct slave server list
+    if (serviceType_==CServicesManager::CLIENT || serviceType_==CServicesManager::GATHERER)
+    {
+      for(auto field : fileOutField) slaveServers_.insert(field->getContextClient()) ;
+      for(auto field : fileInField)  slaveServers_.insert(field->getContextClient()) ;
+    }
+    for(auto& slaveServer : slaveServers_) sendCloseDefinition(slaveServer) ;
+    if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)
+    {
+      createFileHeader();
+    }
+    if (serviceType_==CServicesManager::CLIENT) startPrefetchingOfEnabledReadModeFiles();
+    // send signal to couplerIn context that definition phasis is done
+    for(auto& couplerInClient : couplerInClient_) sendCouplerInCloseDefinition(couplerInClient.second) ;
+    // wait until all couplerIn signal that closeDefition is done.
+    bool ok;
+    do
+    {
+      ok = true ;
+      for(auto& couplerOutClient : couplerOutClient_) ok &= isCouplerInCloseDefinition(couplerOutClient.second) ;
+      this->eventLoop() ;
+    } while (!ok) ;
+     CTimer::get("Context : close definition").suspend() ;
+  }
+  CATCH_DUMP_ATTR
+  vector<CField*> CContext::findAllEnabledFieldsInFileOut(const std::vector<CFile*>& activeFiles)
+   TRY
+   {
+     vector<CField*> fields ;
+     for(auto file : activeFiles)
+     {
+        const vector<CField*>&& fieldList=file->getEnabledFields() ;
+        for(auto field : fieldList) field->setFileOut(file) ;
+        fields.insert(fields.end(),fieldList.begin(),fieldList.end());
+     }
+     return fields ;
+   }
+   CATCH_DUMP_ATTR
+   vector<CField*> CContext::findAllEnabledFieldsInFileIn(const std::vector<CFile*>& activeFiles)
+   TRY
+   {
+     vector<CField*> fields ;
+     for(auto file : activeFiles)
+     {
+        const vector<CField*>&& fieldList=file->getEnabledFields() ;
+        for(auto field : fieldList) field->setFileIn(file) ;
+        fields.insert(fields.end(),fieldList.begin(),fieldList.end());
+     }
+     return fields ;
+   }
+   CATCH_DUMP_ATTR
+   vector<CField*> CContext::findAllEnabledFieldsCouplerOut(const std::vector<CCouplerOut*>& activeCouplerOut)
+   TRY
+   {
+     vector<CField*> fields ;
+     for (auto couplerOut :activeCouplerOut)
+     {
+        const vector<CField*>&& fieldList=couplerOut->getEnabledFields() ;
+        for(auto field : fieldList) field->setCouplerOut(couplerOut) ;
+        fields.insert(fields.end(),fieldList.begin(),fieldList.end());
+     }
+     return fields ;
+   }
+   CATCH_DUMP_ATTR
+   vector<CField*> CContext::findAllEnabledFieldsCouplerIn(const std::vector<CCouplerIn*>& activeCouplerIn)
+   TRY
+   {
+     vector<CField*> fields ;
+     for (auto couplerIn :activeCouplerIn)
+     {
+        const vector<CField*>&& fieldList=couplerIn->getEnabledFields() ;
+        for(auto field : fieldList) field->setCouplerIn(couplerIn) ;
+        fields.insert(fields.end(),fieldList.begin(),fieldList.end());
+     }
+     return fields ;
+   }
+   CATCH_DUMP_ATTR
+ /*!
+  * Send context attribute and calendar to file server, it must be done once by context file server
+  * \param[in] client : context client to send
+  */
+  void CContext::sendContextToFileServer(CContextClient* client)
+  {
+    if (sendToFileServer_done_.count(client)!=0) return ;
+    else sendToFileServer_done_.insert(client) ;
+    this->sendAllAttributesToServer(client); // Send all attributes of current context to server
+    CCalendarWrapper::get(CCalendarWrapper::GetDefName())->sendAllAttributesToServer(client); // Send all attributes of current cale
+  }
    void CContext::readAttributesOfEnabledFieldsInReadModeFiles()
    TRY
 …
    CATCH_DUMP_ATTR
-   void CContext::sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
-   TRY
+   {
-     int size = activeFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       activeFiles[i]->sendGridComponentOfEnabledFields();
+     }
+   }
-   CATCH_DUMP_ATTR
-   /*!
-      Send active (enabled) fields in file from a client to others
-      \param [in] activeFiles files contains enabled fields to send
-   */
-   void CContext::sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
-   TRY
+   {
-     int size = activeFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       activeFiles[i]->sendGridOfEnabledFields();
+     }
+   }
-   CATCH_DUMP_ATTR
-   void CContext::checkGridEnabledFields()
-   TRY
+   {
-     int size = enabledFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       enabledFiles[i]->checkGridOfEnabledFields();
+     }
+   }
-   CATCH_DUMP_ATTR
-   /*!
-      Check grid of active (enabled) fields in file
-      \param [in] activeFiles files contains enabled fields whose grid needs checking
-   */
-   void CContext::checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)
-   TRY
+   {
-     int size = activeFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       activeFiles[i]->checkGridOfEnabledFields();
+     }
+   }
-   CATCH_DUMP_ATTR
-    /*!
-      Go up the hierachical tree via field_ref and do check of attributes of fields
-      This can be done in a client then all computed information will be sent from this client to others
-      \param [in] sendToServer Flag to indicate whether calculated information will be sent
-   */
-   void CContext::solveOnlyRefOfEnabledFields(bool sendToServer)
-   TRY
+   {
-     int size = this->enabledFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFiles[i]->solveOnlyRefOfEnabledFields(sendToServer);
+     }
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFiles[i]->generateNewTransformationGridDest();
+     }
+   }
-   CATCH_DUMP_ATTR
-    /*!
-      Go up the hierachical tree via field_ref and do check of attributes of fields.
-      The transformation can be done in this step.
-      All computed information will be sent from this client to others.
-      \param [in] sendToServer Flag to indicate whether calculated information will be sent
-   */
-   void CContext::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer)
-   TRY
+   {
-     int size = this->enabledFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFiles[i]->solveAllRefOfEnabledFieldsAndTransform(sendToServer);
+     }
+   }
-   CATCH_DUMP_ATTR
-   void CContext::buildFilterGraphOfEnabledFields()
-   TRY
+   {
-     int size = this->enabledFiles.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFiles[i]->buildFilterGraphOfEnabledFields(garbageCollector);
+     }
+   }
-   CATCH_DUMP_ATTR
    void CContext::postProcessFilterGraph()
 …
   TRY
+  {
     fieldsWithReadAccess.clear();
+    fieldsWithReadAccess_.clear();
     const vector<CField*> allFields = CField::getAll();
     for (size_t i = 0; i < allFields.size(); ++i)
+    {
       CField* field = allFields[i];
       if (field->file && !field->file->mode.isEmpty() && field->file->mode == CFile::mode_attr::read)
         field->read_access = true;
       else if (!field->read_access.isEmpty() && field->read_access && (field->enabled.isEmpty() || field->enabled))
         fieldsWithReadAccess.push_back(field);
+      if (!field->read_access.isEmpty() && field->read_access && (field->enabled.isEmpty() || field->enabled))
+      {
+        fieldsWithReadAccess_.push_back(field);
+        field->setModelOut() ;
+      }
+    }
+  }
   CATCH_DUMP_ATTR
+  void CContext::solveAllRefOfFieldsWithReadAccess()
+  TRY
+  {
+    for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i)
+      fieldsWithReadAccess[i]->solveAllReferenceEnabledField(false);
+  }
+  CATCH_DUMP_ATTR
+  void CContext::buildFilterGraphOfFieldsWithReadAccess()
+  TRY
+  {
+    for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i)
+      fieldsWithReadAccess[i]->buildFilterGraph(garbageCollector, true);
+  }
+  CATCH_DUMP_ATTR
    void CContext::solveAllInheritance(bool apply)
    TRY
 …
      // RÃ©solution des hÃ©ritages par rÃ©fÃ©rence au niveau des fichiers.
       const vector<CFile*> allFiles=CFile::getAll();
+      const vector<CCouplerIn*> allCouplerIn=CCouplerIn::getAll();
+      const vector<CCouplerOut*> allCouplerOut=CCouplerOut::getAll();
       const vector<CGrid*> allGrids= CGrid::getAll();
+      if (hasClient && !hasServer)
+      //if (hasClient)
+      if (serviceType_==CServicesManager::CLIENT)
+      {
         for (unsigned int i = 0; i < allFiles.size(); i++)
           allFiles[i]->solveFieldRefInheritance(apply);
+        for (unsigned int i = 0; i < allCouplerIn.size(); i++)
+          allCouplerIn[i]->solveFieldRefInheritance(apply);
+        for (unsigned int i = 0; i < allCouplerOut.size(); i++)
+          allCouplerOut[i]->solveFieldRefInheritance(apply);
+      }
 …
       unsigned int i = 0;
       for (i = 0; i < vecSize; ++i)
         allGrids[i]->solveDomainAxisRefInheritance(apply);
+        allGrids[i]->solveElementsRefInheritance(apply);
+   }
 …
    CATCH_DUMP_ATTR
+   void CContext::distributeFiles(void)
+   void CContext::findEnabledCouplerIn(void)
+   TRY
+   {
+      const std::vector<CCouplerIn*> allCouplerIn = CCouplerIn::getAll();
+      bool enabled ;
+      for (size_t i = 0; i < allCouplerIn.size(); i++)
+      {
+        if (allCouplerIn[i]->enabled.isEmpty()) enabled=true ;
+        else enabled=allCouplerIn[i]->enabled ;
+        if (enabled) enabledCouplerIn.push_back(allCouplerIn[i]) ;
+      }
+   }
+   CATCH_DUMP_ATTR
+   void CContext::findEnabledCouplerOut(void)
+   TRY
+   {
+      const std::vector<CCouplerOut*> allCouplerOut = CCouplerOut::getAll();
+      bool enabled ;
+      for (size_t i = 0; i < allCouplerOut.size(); i++)
+      {
+        if (allCouplerOut[i]->enabled.isEmpty()) enabled=true ;
+        else enabled=allCouplerOut[i]->enabled ;
+        if (enabled) enabledCouplerOut.push_back(allCouplerOut[i]) ;
+      }
+   }
+   CATCH_DUMP_ATTR
+   void CContext::distributeFiles(const vector<CFile*>& files)
    TRY
+   {
 …
      distFileMemory=CXios::getin<bool>("server2_dist_file_memory", distFileMemory);
      if (distFileMemory) distributeFileOverMemoryBandwith() ;
      else distributeFileOverBandwith() ;
+   }
    CATCH_DUMP_ATTR
    void CContext::distributeFileOverBandwith(void)
+     if (distFileMemory) distributeFileOverMemoryBandwith(files) ;
+     else distributeFileOverBandwith(files) ;
+   }
+   CATCH_DUMP_ATTR
+   void CContext::distributeFileOverBandwith(const vector<CFile*>& files)
    TRY
+   {
      double eps=std::numeric_limits<double>::epsilon()*10 ;
+     // If primary server
+     if (hasServer && hasClient)
+     {
+       std::ofstream ofs(("distribute_file_"+getId()+".dat").c_str(), std::ofstream::out);
+       int nbPools = clientPrimServer.size();
+       // (1) Find all enabled files in write mode
+       // for (int i = 0; i < this->enabledFiles.size(); ++i)
+       // {
+       //   if (enabledFiles[i]->mode.isEmpty() || (!enabledFiles[i]->mode.isEmpty() && enabledFiles[i]->mode.getValue() == CFile::mode_attr::write ))
+       //    enabledWriteModeFiles.push_back(enabledFiles[i]);
+       // }
+       // (2) Estimate the data volume for each file
+       int size = this->enabledWriteModeFiles.size();
+       std::vector<std::pair<double, CFile*> > dataSizeMap;
+       double dataPerPool = 0;
+       int nfield=0 ;
+       ofs<<size<<endl ;
+       for (size_t i = 0; i < size; ++i)
+     std::ofstream ofs(("distribute_file_"+getId()+".dat").c_str(), std::ofstream::out);
+     int nbPools = clientPrimServer.size();
+     // (1) Find all enabled files in write mode
+     // for (int i = 0; i < this->enabledFiles.size(); ++i)
+     // {
+     //   if (enabledFiles[i]->mode.isEmpty() || (!enabledFiles[i]->mode.isEmpty() && enabledFiles[i]->mode.getValue() == CFile::mode_attr::write ))
+     //    enabledWriteModeFiles.push_back(enabledFiles[i]);
+     // }
+     // (2) Estimate the data volume for each file
+     int size = files.size();
+     std::vector<std::pair<double, CFile*> > dataSizeMap;
+     double dataPerPool = 0;
+     int nfield=0 ;
+     ofs<<size<<endl ;
+     for (size_t i = 0; i < size; ++i)
+     {
+       CFile* file = files[i];
+       ofs<<file->getId()<<endl ;
+       StdSize dataSize=0;
+       std::vector<CField*> enabledFields = file->getEnabledFields();
+       size_t numEnabledFields = enabledFields.size();
+       ofs<<numEnabledFields<<endl ;
+       for (size_t j = 0; j < numEnabledFields; ++j)
+       {
+         CFile* file = this->enabledWriteModeFiles[i];
+         ofs<<file->getId()<<endl ;
+         StdSize dataSize=0;
+         std::vector<CField*> enabledFields = file->getEnabledFields();
+         size_t numEnabledFields = enabledFields.size();
+         ofs<<numEnabledFields<<endl ;
+         for (size_t j = 0; j < numEnabledFields; ++j)
+         dataSize += enabledFields[j]->getGlobalWrittenSize() ;
+         ofs<<enabledFields[j]->getGrid()->getId()<<endl ;
+         ofs<<enabledFields[j]->getGlobalWrittenSize()<<endl ;
+       }
+       double outFreqSec = (Time)(calendar->getCurrentDate()+file->output_freq)-(Time)(calendar->getCurrentDate()) ;
+       double dataSizeSec= dataSize/ outFreqSec;
+       ofs<<dataSizeSec<<endl ;
+       nfield++ ;
+// add epsilon*nField to dataSizeSec in order to  preserve reproductive ordering when sorting
+       dataSizeMap.push_back(make_pair(dataSizeSec + dataSizeSec * eps * nfield , file));
+       dataPerPool += dataSizeSec;
+     }
+     dataPerPool /= nbPools;
+     std::sort(dataSizeMap.begin(), dataSizeMap.end());
+     // (3) Assign contextClient to each enabled file
+     std::multimap<double,int> poolDataSize ;
+// multimap is not garanty to preserve stable sorting in c++98 but it seems it does for c++11
+     int j;
+     double dataSize ;
+     for (j = 0 ; j < nbPools ; ++j) poolDataSize.insert(std::pair<double,int>(0.,j)) ;
+     for (int i = dataSizeMap.size()-1; i >= 0; --i)
+     {
+       dataSize=(*poolDataSize.begin()).first ;
+       j=(*poolDataSize.begin()).second ;
+       dataSizeMap[i].second->setContextClient(clientPrimServer[j]);
+       dataSize+=dataSizeMap[i].first;
+       poolDataSize.erase(poolDataSize.begin()) ;
+       poolDataSize.insert(std::pair<double,int>(dataSize,j)) ;
+     }
+     for (std::multimap<double,int>:: iterator it=poolDataSize.begin() ; it!=poolDataSize.end(); ++it) info(30)<<"Load Balancing for servers (perfect=1) : "<<it->second<<" :  ratio "<<it->first*1./dataPerPool<<endl ;
+   }
+   CATCH_DUMP_ATTR
+   void CContext::distributeFileOverMemoryBandwith(const vector<CFile*>& filesList)
+   TRY
+   {
+     int nbPools = clientPrimServer.size();
+     double ratio=0.5 ;
+     ratio=CXios::getin<double>("server2_dist_file_memory_ratio", ratio);
+     int nFiles = filesList.size();
+     vector<SDistFile> files(nFiles);
+     vector<SDistGrid> grids;
+     map<string,int> gridMap ;
+     string gridId;
+     int gridIndex=0 ;
+     for (size_t i = 0; i < nFiles; ++i)
+     {
+       StdSize dataSize=0;
+       CFile* file = filesList[i];
+       std::vector<CField*> enabledFields = file->getEnabledFields();
+       size_t numEnabledFields = enabledFields.size();
+       files[i].id_=file->getId() ;
+       files[i].nbGrids_=numEnabledFields;
+       files[i].assignedGrid_ = new int[files[i].nbGrids_] ;
+       for (size_t j = 0; j < numEnabledFields; ++j)
+       {
+         gridId=enabledFields[j]->getGrid()->getId() ;
+         if (gridMap.find(gridId)==gridMap.end())
+         {
+           dataSize += enabledFields[j]->getGlobalWrittenSize() ;
+           ofs<<enabledFields[j]->grid->getId()<<endl ;
+           ofs<<enabledFields[j]->getGlobalWrittenSize()<<endl ;
+            gridMap[gridId]=gridIndex  ;
+            SDistGrid newGrid;
+            grids.push_back(newGrid) ;
+            gridIndex++ ;
+         }
+         double outFreqSec = (Time)(calendar->getCurrentDate()+file->output_freq)-(Time)(calendar->getCurrentDate()) ;
+         double dataSizeSec= dataSize/ outFreqSec;
+         ofs<<dataSizeSec<<endl ;
+         nfield++ ;
+// add epsilon*nField to dataSizeSec in order to  preserve reproductive ordering when sorting
+         dataSizeMap.push_back(make_pair(dataSizeSec + dataSizeSec * eps * nfield , file));
+         dataPerPool += dataSizeSec;
+         files[i].assignedGrid_[j]=gridMap[gridId] ;
+         grids[files[i].assignedGrid_[j]].size_=enabledFields[j]->getGlobalWrittenSize() ;
+         dataSize += enabledFields[j]->getGlobalWrittenSize() ; // usefull
+       }
+       dataPerPool /= nbPools;
+       std::sort(dataSizeMap.begin(), dataSizeMap.end());
+       // (3) Assign contextClient to each enabled file
+       std::multimap<double,int> poolDataSize ;
+// multimap is not garanty to preserve stable sorting in c++98 but it seems it does for c++11
+       int j;
+       double dataSize ;
+       for (j = 0 ; j < nbPools ; ++j) poolDataSize.insert(std::pair<double,int>(0.,j)) ;
+       for (int i = dataSizeMap.size()-1; i >= 0; --i)
+       double outFreqSec = (Time)(calendar->getCurrentDate()+file->output_freq)-(Time)(calendar->getCurrentDate()) ;
+       files[i].bandwith_= dataSize/ outFreqSec ;
+     }
+     double bandwith=0 ;
+     double memory=0 ;
+     for(int i=0; i<nFiles; i++)  bandwith+=files[i].bandwith_ ;
+     for(int i=0; i<nFiles; i++)  files[i].bandwith_ = files[i].bandwith_/bandwith * ratio ;
+     for(int i=0; i<grids.size(); i++)  memory+=grids[i].size_ ;
+     for(int i=0; i<grids.size(); i++)  grids[i].size_ = grids[i].size_ / memory * (1.0-ratio) ;
+     distributeFileOverServer2(nbPools, grids.size(), &grids[0], nFiles, &files[0]) ;
+     vector<double> memorySize(nbPools,0.) ;
+     vector< set<int> > serverGrids(nbPools) ;
+     vector<double> bandwithSize(nbPools,0.) ;
+     for (size_t i = 0; i < nFiles; ++i)
+     {
+       bandwithSize[files[i].assignedServer_] += files[i].bandwith_* bandwith /ratio ;
+       for(int j=0 ; j<files[i].nbGrids_;j++)
+       {
+         dataSize=(*poolDataSize.begin()).first ;
+         j=(*poolDataSize.begin()).second ;
+         dataSizeMap[i].second->setContextClient(clientPrimServer[j]);
+         dataSize+=dataSizeMap[i].first;
+         poolDataSize.erase(poolDataSize.begin()) ;
+         poolDataSize.insert(std::pair<double,int>(dataSize,j)) ;
+         if (serverGrids[files[i].assignedServer_].find(files[i].assignedGrid_[j]) == serverGrids[files[i].assignedServer_].end())
+         {
+           memorySize[files[i].assignedServer_]+= grids[files[i].assignedGrid_[j]].size_ * memory / (1.0-ratio);
+           serverGrids[files[i].assignedServer_].insert(files[i].assignedGrid_[j]) ;
+         }
+       }
+       for (std::multimap<double,int>:: iterator it=poolDataSize.begin() ; it!=poolDataSize.end(); ++it) info(30)<<"Load Balancing for servers (perfect=1) : "<<it->second<<" :  ratio "<<it->first*1./dataPerPool<<endl ;
+       for (int i = 0; i < this->enabledReadModeFiles.size(); ++i)
+       {
+         enabledReadModeFiles[i]->setContextClient(client);
+       }
+     }
+     else
+     {
+       for (int i = 0; i < this->enabledFiles.size(); ++i)
+         enabledFiles[i]->setContextClient(client);
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CContext::distributeFileOverMemoryBandwith(void)
+   TRY
+   {
+     // If primary server
+     if (hasServer && hasClient)
+     {
+       int nbPools = clientPrimServer.size();
+       double ratio=0.5 ;
+       ratio=CXios::getin<double>("server2_dist_file_memory_ratio", ratio);
+       int nFiles = this->enabledWriteModeFiles.size();
+       vector<SDistFile> files(nFiles);
+       vector<SDistGrid> grids;
+       map<string,int> gridMap ;
+       string gridId;
+       int gridIndex=0 ;
+       for (size_t i = 0; i < nFiles; ++i)
+       {
+         StdSize dataSize=0;
+         CFile* file = this->enabledWriteModeFiles[i];
+         std::vector<CField*> enabledFields = file->getEnabledFields();
+         size_t numEnabledFields = enabledFields.size();
+         files[i].id_=file->getId() ;
+         files[i].nbGrids_=numEnabledFields;
+         files[i].assignedGrid_ = new int[files[i].nbGrids_] ;
+         for (size_t j = 0; j < numEnabledFields; ++j)
+         {
+           gridId=enabledFields[j]->grid->getId() ;
+           if (gridMap.find(gridId)==gridMap.end())
+           {
+              gridMap[gridId]=gridIndex  ;
+              SDistGrid newGrid;
+              grids.push_back(newGrid) ;
+              gridIndex++ ;
+           }
+           files[i].assignedGrid_[j]=gridMap[gridId] ;
+           grids[files[i].assignedGrid_[j]].size_=enabledFields[j]->getGlobalWrittenSize() ;
+           dataSize += enabledFields[j]->getGlobalWrittenSize() ; // usefull
+         }
+         double outFreqSec = (Time)(calendar->getCurrentDate()+file->output_freq)-(Time)(calendar->getCurrentDate()) ;
+         files[i].bandwith_= dataSize/ outFreqSec ;
+       }
+       double bandwith=0 ;
+       double memory=0 ;
+       for(int i=0; i<nFiles; i++)  bandwith+=files[i].bandwith_ ;
+       for(int i=0; i<nFiles; i++)  files[i].bandwith_ = files[i].bandwith_/bandwith * ratio ;
+       for(int i=0; i<grids.size(); i++)  memory+=grids[i].size_ ;
+       for(int i=0; i<grids.size(); i++)  grids[i].size_ = grids[i].size_ / memory * (1.0-ratio) ;
+       distributeFileOverServer2(nbPools, grids.size(), &grids[0], nFiles, &files[0]) ;
+       vector<double> memorySize(nbPools,0.) ;
+       vector< set<int> > serverGrids(nbPools) ;
+       vector<double> bandwithSize(nbPools,0.) ;
+       for (size_t i = 0; i < nFiles; ++i)
+       {
+         bandwithSize[files[i].assignedServer_] += files[i].bandwith_* bandwith /ratio ;
+         for(int j=0 ; j<files[i].nbGrids_;j++)
+         {
+           if (serverGrids[files[i].assignedServer_].find(files[i].assignedGrid_[j]) == serverGrids[files[i].assignedServer_].end())
+           {
+             memorySize[files[i].assignedServer_]+= grids[files[i].assignedGrid_[j]].size_ * memory / (1.0-ratio);
+             serverGrids[files[i].assignedServer_].insert(files[i].assignedGrid_[j]) ;
+           }
+         }
+         enabledWriteModeFiles[i]->setContextClient(clientPrimServer[files[i].assignedServer_]) ;
+         delete [] files[i].assignedGrid_ ;
+       }
+       for (int i = 0; i < nbPools; ++i) info(100)<<"Pool server level2 "<<i<<"   assigned file bandwith "<<bandwithSize[i]*86400.*4./1024/1024.<<" Mb / days"<<endl ;
+       for (int i = 0; i < nbPools; ++i) info(100)<<"Pool server level2 "<<i<<"   assigned grid memory "<<memorySize[i]*100/1024./1024.<<" Mb"<<endl ;
+       for (int i = 0; i < this->enabledReadModeFiles.size(); ++i)
+       {
+         enabledReadModeFiles[i]->setContextClient(client);
+       }
+   }
+   else
+   {
+     for (int i = 0; i < this->enabledFiles.size(); ++i)
+        enabledFiles[i]->setContextClient(client);
+   }
+}
+       filesList[i]->setContextClient(clientPrimServer[files[i].assignedServer_]) ;
+       delete [] files[i].assignedGrid_ ;
+     }
+     for (int i = 0; i < nbPools; ++i) info(100)<<"Pool server level2 "<<i<<"   assigned file bandwith "<<bandwithSize[i]*86400.*4./1024/1024.<<" Mb / days"<<endl ;
+     for (int i = 0; i < nbPools; ++i) info(100)<<"Pool server level2 "<<i<<"   assigned grid memory "<<memorySize[i]*100/1024./1024.<<" Mb"<<endl ;
+   }
    CATCH_DUMP_ATTR
 …
              return true;
              break;
+           case EVENT_ID_POST_PROCESS:
+             recvPostProcessing(event);
+             return true;
+            case EVENT_ID_SEND_REGISTRY:
+           case EVENT_ID_SEND_REGISTRY:
              recvRegistry(event);
              return true;
              break;
             case EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES:
              recvPostProcessingGlobalAttributes(event);
+           case EVENT_ID_COUPLER_IN_READY:
+             recvCouplerInReady(event);
              return true;
              break;
             case EVENT_ID_PROCESS_GRID_ENABLED_FIELDS:
              recvProcessingGridOfEnabledFields(event);
+           case EVENT_ID_COUPLER_IN_CLOSE_DEFINITION:
+             recvCouplerInCloseDefinition(event);
              return true;
              break;
+           case EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED:
+             recvCouplerInContextFinalized(event);
+             return true;
+             break;
            default :
              ERROR("bool CContext::dispatchEvent(CEventServer& event)",
 …
    //! Client side: Send a message to server to make it close
+   // ym obsolete
    void CContext::sendCloseDefinition(void)
    TRY
+   {
+     // Use correct context client to send message
+     int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (hasServer) ? clientPrimServer[i] : client;
+    int nbSrvPools ;
+    if (serviceType_==CServicesManager::CLIENT) nbSrvPools = 1 ;
+    else if (serviceType_==CServicesManager::GATHERER) nbSrvPools = this->clientPrimServer.size() ;
+    else nbSrvPools = 0 ;
+    CContextClient* contextClientTmp ;
+    for (int i = 0; i < nbSrvPools; ++i)
+     {
+       if (serviceType_==CServicesManager::CLIENT) contextClientTmp = client ;
+       else if (serviceType_==CServicesManager::GATHERER ) contextClientTmp = clientPrimServer[i] ;
        CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION);
        if (contextClientTmp->isServerLeader())
+       {
          CMessage msg;
-         if (hasServer)
-           msg<<this->getIdServer(i);
-         else
-           msg<<this->getIdServer();
          const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
 …
+   }
    CATCH_DUMP_ATTR
+   //  ! Client side: Send a message to server to make it close
+   void CContext::sendCloseDefinition(CContextClient* client)
+   TRY
+   {
+      if (sendCloseDefinition_done_.count(client)!=0) return ;
+      else sendCloseDefinition_done_.insert(client) ;
+      CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        for(auto rank : client->getRanksServerLeader()) event.push(rank,1,msg);
+        client->sendEvent(event);
+      }
+     else client->sendEvent(event);
+   }
+   CATCH_DUMP_ATTR
    //! Server side: Receive a message of client announcing a context close
 …
+   {
       CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->closeDefinition();
+      getCurrent()->closeDefinition();
+   }
    CATCH
 …
    TRY
+   {
+     // Use correct context client to send message
+    int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (hasServer) ? clientPrimServer[i] : client;
+       CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR);
+         if (contextClientTmp->isServerLeader())
+         {
+           CMessage msg;
+           if (hasServer)
+             msg<<this->getIdServer(i)<<step;
+           else
+             msg<<this->getIdServer()<<step;
+           const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+           for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+             event.push(*itRank,1,msg);
+           contextClientTmp->sendEvent(event);
+         }
+         else contextClientTmp->sendEvent(event);
+     CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR);
+     for(auto client : slaveServers_)
+     {
+       if (client->isServerLeader())
+       {
+         CMessage msg;
+         msg<<step;
+         for (auto& rank : client->getRanksServerLeader() ) event.push(rank,1,msg);
+         client->sendEvent(event);
+       }
+       else client->sendEvent(event);
+     }
+   }
 …
+   {
       CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->recvUpdateCalendar(*buffer);
+      getCurrent()->recvUpdateCalendar(*buffer);
+   }
    CATCH
 …
       buffer>>step;
       updateCalendar(step);
       if (hasClient && hasServer)
+      if (serviceType_==CServicesManager::GATHERER)
+      {
         sendUpdateCalendar(step);
 …
    TRY
+   {
+     // Use correct context client to send message
+     // int nbSrvPools = (hasServer) ? clientPrimServer.size() : 1;
+     int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     int nbSrvPools ;
+     if (serviceType_==CServicesManager::CLIENT) nbSrvPools = 1 ;
+     else if (serviceType_==CServicesManager::GATHERER) nbSrvPools = this->clientPrimServer.size() ;
+     else nbSrvPools = 0 ;
+     CContextClient* contextClientTmp ;
      for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (hasServer) ? clientPrimServer[i] : client;
+       if (serviceType_==CServicesManager::CLIENT) contextClientTmp = client ;
+       else if (serviceType_==CServicesManager::GATHERER ) contextClientTmp = clientPrimServer[i] ;
        CEventClient event(getType(),EVENT_ID_CREATE_FILE_HEADER);
 …
+       {
          CMessage msg;
-         if (hasServer)
-           msg<<this->getIdServer(i);
-         else
-           msg<<this->getIdServer();
          const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
 …
+   {
       CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->recvCreateFileHeader(*buffer);
+      getCurrent()->recvCreateFileHeader(*buffer);
+   }
    CATCH
 …
    TRY
+   {
       if (!hasClient && hasServer)
+      if (serviceType_==CServicesManager::IO_SERVER || serviceType_==CServicesManager::OUT_SERVER)
         createFileHeader();
+   }
    CATCH_DUMP_ATTR
+   //! Client side: Send a message to do some post processing on server
+   void CContext::sendProcessingGridOfEnabledFields()
+   TRY
+   {
+      // Use correct context client to send message
+     int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (0 != clientPrimServer.size()) ? clientPrimServer[i] : client;
+       CEventClient event(getType(),EVENT_ID_PROCESS_GRID_ENABLED_FIELDS);
+       if (contextClientTmp->isServerLeader())
+       {
+         CMessage msg;
+         if (hasServer)
+           msg<<this->getIdServer(i);
+         else
+           msg<<this->getIdServer();
+         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+           event.push(*itRank,1,msg);
+         contextClientTmp->sendEvent(event);
+       }
+       else contextClientTmp->sendEvent(event);
+     }
+   }
+   CATCH_DUMP_ATTR
+   //! Server side: Receive a message to do some post processing
+   void CContext::recvProcessingGridOfEnabledFields(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+   }
+   CATCH
+   //! Client side: Send a message to do some post processing on server
+   void CContext::sendPostProcessing()
+   TRY
+   {
+      // Use correct context client to send message
+     // int nbSrvPools = (hasServer) ? clientPrimServer.size() : 1;
+     int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+     for (int i = 0; i < nbSrvPools; ++i)
+     {
+       CContextClient* contextClientTmp = (hasServer) ? clientPrimServer[i] : client;
+       CEventClient event(getType(),EVENT_ID_POST_PROCESS);
+       if (contextClientTmp->isServerLeader())
+       {
+         CMessage msg;
+         if (hasServer)
+           msg<<this->getIdServer(i);
+         else
+           msg<<this->getIdServer();
+         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+         event.push(*itRank,1,msg);
+         contextClientTmp->sendEvent(event);
+       }
+       else contextClientTmp->sendEvent(event);
+     }
+   }
+   CATCH_DUMP_ATTR
+   //! Server side: Receive a message to do some post processing
+   void CContext::recvPostProcessing(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->recvPostProcessing(*buffer);
+   }
+   CATCH
+   //! Server side: Receive a message to do some post processing
+   void CContext::recvPostProcessing(CBufferIn& buffer)
+   TRY
+   {
+      CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar();
+      postProcessing();
+   }
+   CATCH_DUMP_ATTR
+   const StdString& CContext::getIdServer()
+   TRY
+   {
+      if (hasClient)
+      {
+        idServer_ = this->getId();
+        idServer_ += "_server";
+        return idServer_;
+      }
+      if (hasServer) return (this->getId());
+   }
+   CATCH_DUMP_ATTR
+   const StdString& CContext::getIdServer(const int i)
+   TRY
+   {
+     idServer_ = this->getId();
+     idServer_ += "_server_";
+     idServer_ += std::to_string(static_cast<unsigned long long>(i));
+     return idServer_;
+   }
+   CATCH_DUMP_ATTR
+   /*!
+   \brief Do some simple post processings after parsing xml file
+      After the xml file (iodef.xml) is parsed, it is necessary to build all relations among
+   created object, e.g: inhertance among fields, domain, axis. After that, all fiels as well as their parents (reference fields),
+   which will be written out into netcdf files, are processed
+   */
+   void CContext::postProcessing()
+   TRY
+   {
+     if (isPostProcessed) return;
+      // Make sure the calendar was correctly created
+      if (!calendar)
+        ERROR("CContext::postProcessing()", << "A calendar must be defined for the context \"" << getId() << "!\"")
+      else if (calendar->getTimeStep() == NoneDu)
+        ERROR("CContext::postProcessing()", << "A timestep must be defined for the context \"" << getId() << "!\"")
+      // Calendar first update to set the current date equals to the start date
+      calendar->update(0);
+      // Find all inheritance in xml structure
+      this->solveAllInheritance();
+//      ShowTree(info(10));
+      // Check if some axis, domains or grids are eligible to for compressed indexed output.
+      // Warning: This must be done after solving the inheritance and before the rest of post-processing
+      checkAxisDomainsGridsEligibilityForCompressedOutput();
+      // Check if some automatic time series should be generated
+      // Warning: This must be done after solving the inheritance and before the rest of post-processing
+      // The timeseries should only be prepared in client
+      if (hasClient && !hasServer) prepareTimeseries();
+      //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers Ã  sortir.
+      findEnabledFiles();
+      findEnabledWriteModeFiles();
+      findEnabledReadModeFiles();
+      // For now, only read files with client and only one level server
+      // if (hasClient && !hasServer) findEnabledReadModeFiles();
+      // Find all enabled fields of each file
+      findAllEnabledFieldsInFiles(this->enabledWriteModeFiles);
+      findAllEnabledFieldsInFiles(this->enabledReadModeFiles);
+      // For now, only read files with client and only one level server
+      // if (hasClient && !hasServer)
+      //   findAllEnabledFieldsInFiles(this->enabledReadModeFiles);
+      if (hasClient && !hasServer)
+      {
+        initReadFiles();
+        // Try to read attributes of fields in file then fill in corresponding grid (or domain, axis)
+        this->readAttributesOfEnabledFieldsInReadModeFiles();
+      }
+      // Only search and rebuild all reference objects of enable fields, don't transform
+      this->solveOnlyRefOfEnabledFields(false);
+      // Search and rebuild all reference object of enabled fields, and transform
+      this->solveAllRefOfEnabledFieldsAndTransform(false);
+      // Find all fields with read access from the public API
+      if (hasClient && !hasServer) findFieldsWithReadAccess();
+      // and solve the all reference for them
+      if (hasClient && !hasServer) solveAllRefOfFieldsWithReadAccess();
+      isPostProcessed = true;
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Compute the required buffer size to send the attributes (mostly those grid related).
+    * \param maxEventSize [in/out] the size of the bigger event for each connected server
+    * \param [in] contextClient
+    * \param [in] bufferForWriting True if buffers are used for sending data for writing
+      This flag is only true for client and server-1 for communication with server-2
+    */
+   std::map<int, StdSize> CContext::getAttributesBufferSize(std::map<int, StdSize>& maxEventSize,
+                                                           CContextClient* contextClient, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+         // As calendar attributes are sent even if there are no active files or fields, maps are initialized according the size of calendar attributes
+     std::map<int, StdSize> attributesSize = CCalendarWrapper::get(CCalendarWrapper::GetDefName())->getMinimumBufferSizeForAttributes(contextClient);
+     maxEventSize = CCalendarWrapper::get(CCalendarWrapper::GetDefName())->getMinimumBufferSizeForAttributes(contextClient);
+     std::vector<CFile*>& fileList = this->enabledFiles;
+     size_t numEnabledFiles = fileList.size();
+     for (size_t i = 0; i < numEnabledFiles; ++i)
+     {
+//         CFile* file = this->enabledWriteModeFiles[i];
+        CFile* file = fileList[i];
+        std::vector<CField*> enabledFields = file->getEnabledFields();
+        size_t numEnabledFields = enabledFields.size();
+        for (size_t j = 0; j < numEnabledFields; ++j)
+   void CContext::createCouplerInterCommunicator(void)
+   TRY
+   {
+      int rank=this->getIntraCommRank() ;
+      map<string,list<CCouplerOut*>> listCouplerOut ;
+      map<string,list<CCouplerIn*>> listCouplerIn ;
+      for(auto couplerOut : enabledCouplerOut) listCouplerOut[couplerOut->getCouplingContextId()].push_back(couplerOut) ;
+      for(auto couplerIn : enabledCouplerIn) listCouplerIn[couplerIn->getCouplingContextId()].push_back(couplerIn) ;
+      CCouplerManager* couplerManager = CXios::getCouplerManager() ;
+      if (rank==0)
+      {
+        for(auto couplerOut : listCouplerOut) couplerManager->registerCoupling(this->getContextId(),couplerOut.first) ;
+        for(auto couplerIn : listCouplerIn) couplerManager->registerCoupling(couplerIn.first,this->getContextId()) ;
+      }
+      do
+      {
+        for(auto couplerOut : listCouplerOut)
+        {
+          const std::map<int, StdSize> mapSize = enabledFields[j]->getGridAttributesBufferSize(contextClient, bufferForWriting);
+          std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+          for (; it != itE; ++it)
+          bool isNextCoupling ;
+          if (rank==0) isNextCoupling = couplerManager->isNextCoupling(this->getContextId(),couplerOut.first) ;
+          MPI_Bcast(&isNextCoupling,1,MPI_C_BOOL, 0, getIntraComm()) ;
+          if (isNextCoupling)
+          {
+                     // If attributesSize[it->first] does not exist, it will be zero-initialized
+                     // so we can use it safely without checking for its existence
+             if (attributesSize[it->first] < it->second)
+                           attributesSize[it->first] = it->second;
+                     if (maxEventSize[it->first] < it->second)
+                           maxEventSize[it->first] = it->second;
+          }
+            addCouplingChanel(couplerOut.first, true) ;
+            listCouplerOut.erase(couplerOut.first) ;
+            break ;
+          }
+        }
+     }
+     return attributesSize;
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Compute the required buffer size to send the fields data.
+    * \param maxEventSize [in/out] the size of the bigger event for each connected server
+    * \param [in] contextClient
+    * \param [in] bufferForWriting True if buffers are used for sending data for writing
+      This flag is only true for client and server-1 for communication with server-2
+    */
+   std::map<int, StdSize> CContext::getDataBufferSize(std::map<int, StdSize>& maxEventSize,
+                                                      CContextClient* contextClient, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+     std::map<int, StdSize> dataSize;
+     // Find all reference domain and axis of all active fields
+     std::vector<CFile*>& fileList = bufferForWriting ? this->enabledWriteModeFiles : this->enabledReadModeFiles;
+     size_t numEnabledFiles = fileList.size();
+     for (size_t i = 0; i < numEnabledFiles; ++i)
+     {
+       CFile* file = fileList[i];
+       if (file->getContextClient() == contextClient)
+       {
+         std::vector<CField*> enabledFields = file->getEnabledFields();
+         size_t numEnabledFields = enabledFields.size();
+         for (size_t j = 0; j < numEnabledFields; ++j)
+         {
+           // const std::vector<std::map<int, StdSize> > mapSize = enabledFields[j]->getGridDataBufferSize(contextClient);
+           const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataBufferSize(contextClient,bufferForWriting);
+           std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+           for (; it != itE; ++it)
+           {
+             // If dataSize[it->first] does not exist, it will be zero-initialized
+             // so we can use it safely without checking for its existance
+                 if (CXios::isOptPerformance)
+               dataSize[it->first] += it->second;
+             else if (dataSize[it->first] < it->second)
+               dataSize[it->first] = it->second;
+                 if (maxEventSize[it->first] < it->second)
+               maxEventSize[it->first] = it->second;
+           }
+         }
+       }
+     }
+     return dataSize;
+   }
+   CATCH_DUMP_ATTR
+   //! Client side: Send infomation of active files (files are enabled to write out)
+        for(auto couplerIn : listCouplerIn)
+        {
+          bool isNextCoupling ;
+          if (rank==0) isNextCoupling = couplerManager->isNextCoupling(couplerIn.first,this->getContextId());
+          MPI_Bcast(&isNextCoupling,1,MPI_C_BOOL, 0, getIntraComm()) ;
+          if (isNextCoupling)
+          {
+            addCouplingChanel(couplerIn.first, false) ;
+            listCouplerIn.erase(couplerIn.first) ;
+            break ;
+          }
+        }
+      } while (!listCouplerOut.empty() || !listCouplerIn.empty()) ;
+   }
+   CATCH_DUMP_ATTR
+     //! Client side: Send infomation of active files (files are enabled to write out)
    void CContext::sendEnabledFiles(const std::vector<CFile*>& activeFiles)
    TRY
 …
    CATCH_DUMP_ATTR
+   //! Client side: Check if the defined axis, domains and grids are eligible for compressed indexed output
+   void CContext::checkAxisDomainsGridsEligibilityForCompressedOutput()
+   TRY
+   {
+     if (!hasClient) return;
+     const vector<CAxis*> allAxis = CAxis::getAll();
+     for (vector<CAxis*>::const_iterator it = allAxis.begin(); it != allAxis.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+     const vector<CDomain*> allDomains = CDomain::getAll();
+     for (vector<CDomain*>::const_iterator it = allDomains.begin(); it != allDomains.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+     const vector<CGrid*> allGrids = CGrid::getAll();
+     for (vector<CGrid*>::const_iterator it = allGrids.begin(); it != allGrids.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+   }
+   CATCH_DUMP_ATTR
    //! Client side: Prepare the timeseries by adding the necessary files
    void CContext::prepareTimeseries()
    TRY
+   {
-     if (!hasClient) return;
      const std::vector<CFile*> allFiles = CFile::getAll();
      for (size_t i = 0; i < allFiles.size(); i++)
 …
    CATCH_DUMP_ATTR
+   //! Client side: Send information of reference grid of active fields
+   void CContext::sendRefGrid(const std::vector<CFile*>& activeFiles)
+   TRY
+   {
+     std::set<StdString> gridIds;
+     int sizeFile = activeFiles.size();
+     CFile* filePtr(NULL);
+     // Firstly, find all reference grids of all active fields
+     for (int i = 0; i < sizeFile; ++i)
+     {
+       filePtr = activeFiles[i];
+       std::vector<CField*> enabledFields = filePtr->getEnabledFields();
+       int sizeField = enabledFields.size();
+       for (int numField = 0; numField < sizeField; ++numField)
+       {
+         if (0 != enabledFields[numField]->getRelGrid())
+           gridIds.insert(CGrid::get(enabledFields[numField]->getRelGrid())->getId());
+       }
+     }
+     // Create all reference grids on server side
+     StdString gridDefRoot("grid_definition");
+     CGridGroup* gridPtr = CGridGroup::get(gridDefRoot);
+     std::set<StdString>::const_iterator it, itE = gridIds.end();
+     for (it = gridIds.begin(); it != itE; ++it)
+     {
+       gridPtr->sendCreateChild(*it);
+       CGrid::get(*it)->sendAllAttributesToServer();
+       CGrid::get(*it)->sendAllDomains();
+       CGrid::get(*it)->sendAllAxis();
+       CGrid::get(*it)->sendAllScalars();
+     }
+   }
+   CATCH_DUMP_ATTR
    //! Client side: Send information of reference domain, axis and scalar of active fields
    void CContext::sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles)
    TRY
+   {
      std::set<StdString> domainIds, axisIds, scalarIds;
+     std::set<pair<StdString,CContextClient*>> domainIds, axisIds, scalarIds;
      // Find all reference domain and axis of all active fields
 …
        for (int j = 0; j < numEnabledFields; ++j)
+       {
+         CContextClient* contextClient=enabledFields[j]->getContextClient() ;
          const std::vector<StdString>& prDomAxisScalarId = enabledFields[j]->getRefDomainAxisIds();
          if ("" != prDomAxisScalarId[0]) domainIds.insert(prDomAxisScalarId[0]);
          if ("" != prDomAxisScalarId[1]) axisIds.insert(prDomAxisScalarId[1]);
          if ("" != prDomAxisScalarId[2]) scalarIds.insert(prDomAxisScalarId[2]);
+         if ("" != prDomAxisScalarId[0]) domainIds.insert(make_pair(prDomAxisScalarId[0],contextClient));
+         if ("" != prDomAxisScalarId[1]) axisIds.insert(make_pair(prDomAxisScalarId[1],contextClient));
+         if ("" != prDomAxisScalarId[2]) scalarIds.insert(make_pair(prDomAxisScalarId[2],contextClient));
+       }
+     }
 …
      StdString scalarDefRoot("scalar_definition");
      CScalarGroup* scalarPtr = CScalarGroup::get(scalarDefRoot);
      itE = scalarIds.end();
      for (itScalar = scalarIds.begin(); itScalar != itE; ++itScalar)
+     {
        if (!itScalar->empty())
+     for (auto itScalar = scalarIds.begin(); itScalar != scalarIds.end(); ++itScalar)
+     {
+       if (!itScalar->first.empty())
+       {
          scalarPtr->sendCreateChild(*itScalar);
          CScalar::get(*itScalar)->sendAllAttributesToServer();
+         scalarPtr->sendCreateChild(itScalar->first,itScalar->second);
+         CScalar::get(itScalar->first)->sendAllAttributesToServer(itScalar->second);
+       }
+     }
 …
      StdString axiDefRoot("axis_definition");
      CAxisGroup* axisPtr = CAxisGroup::get(axiDefRoot);
      itE = axisIds.end();
      for (itAxis = axisIds.begin(); itAxis != itE; ++itAxis)
+     {
        if (!itAxis->empty())
+     for (auto itAxis = axisIds.begin(); itAxis != axisIds.end(); ++itAxis)
+     {
+       if (!itAxis->first.empty())
+       {
          axisPtr->sendCreateChild(*itAxis);
          CAxis::get(*itAxis)->sendAllAttributesToServer();
+         axisPtr->sendCreateChild(itAxis->first, itAxis->second);
+         CAxis::get(itAxis->first)->sendAllAttributesToServer(itAxis->second);
+       }
+     }
 …
      StdString domDefRoot("domain_definition");
      CDomainGroup* domPtr = CDomainGroup::get(domDefRoot);
      itE = domainIds.end();
      for (itDom = domainIds.begin(); itDom != itE; ++itDom)
+     {
        if (!itDom->empty()) {
           domPtr->sendCreateChild(*itDom);
           CDomain::get(*itDom)->sendAllAttributesToServer();
+     for (auto itDom = domainIds.begin(); itDom != domainIds.end(); ++itDom)
+     {
+       if (!itDom->first.empty()) {
+          domPtr->sendCreateChild(itDom->first, itDom->second);
+          CDomain::get(itDom->first)->sendAllAttributesToServer(itDom->second);
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CContext::triggerLateFields(void)
+   TRY
+   {
+    for(auto& field : fileInFields_) field->triggerLateField() ;
+    for(auto& field : couplerInFields_) field->triggerLateField() ;
+   }
    CATCH_DUMP_ATTR
 …
       if (prevStep < step)
+      {
         if (hasClient && !hasServer) // For now we only use server level 1 to read data
+        if (serviceType_==CServicesManager::CLIENT) // For now we only use server level 1 to read data
+        {
           doPreTimestepOperationsForEnabledReadModeFiles();
+          triggerLateFields();
+        }
 …
   #endif
         if (hasClient && !hasServer) // For now we only use server level 1 to read data
+        if (serviceType_==CServicesManager::CLIENT) // For now we only use server level 1 to read data
+        {
           doPostTimestepOperationsForEnabledReadModeFiles();
 …
       vector<CFile*>::const_iterator it;
       for (it=enabledFiles.begin(); it != enabledFiles.end(); it++)
       // for (it=enabledWriteModeFiles.begin(); it != enabledWriteModeFiles.end(); it++)
+      //for (it=enabledFiles.begin(); it != enabledFiles.end(); it++)
+      for (it=enabledWriteModeFiles.begin(); it != enabledWriteModeFiles.end(); it++)
+      {
          (*it)->initWrite();
 …
+  {
     CBufferIn* buffer=event.subEvents.begin()->buffer;
+    string id;
+    *buffer>>id;
+    get(id)->recvRegistry(*buffer);
+    getCurrent()->recvRegistry(*buffer);
+  }
   CATCH
 …
     registryOut->hierarchicalGatherRegistry() ;
+    // Use correct context client to send message
+    int nbSrvPools = (this->hasServer) ? (this->hasClient ? this->clientPrimServer.size() : 0) : 1;
+    int nbSrvPools ;
+    if (serviceType_==CServicesManager::CLIENT) nbSrvPools = 1 ;
+    else if (serviceType_==CServicesManager::GATHERER) nbSrvPools = this->clientPrimServer.size() ;
+    else nbSrvPools = 0 ;
+    CContextClient* contextClientTmp ;
     for (int i = 0; i < nbSrvPools; ++i)
+    {
+      CContextClient* contextClientTmp = (hasServer) ? clientPrimServer[i] : client;
+      if (serviceType_==CServicesManager::CLIENT) contextClientTmp = client ;
+      else if (serviceType_==CServicesManager::GATHERER ) contextClientTmp = clientPrimServer[i] ;
       CEventClient event(CContext::GetType(), CContext::EVENT_ID_SEND_REGISTRY);
+        if (contextClientTmp->isServerLeader())
+        {
+           CMessage msg ;
+           if (hasServer)
+             msg<<this->getIdServer(i);
+           else
+             msg<<this->getIdServer();
+           if (contextClientTmp->clientRank==0) msg<<*registryOut ;
+           const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+           for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+      if (contextClientTmp->isServerLeader())
+      {
+        CMessage msg ;
+        if (contextClientTmp->clientRank==0) msg<<*registryOut ;
+        const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
              event.push(*itRank,1,msg);
            contextClientTmp->sendEvent(event);
+         }
          else contextClientTmp->sendEvent(event);
+        contextClientTmp->sendEvent(event);
+      }
+      else contextClientTmp->sendEvent(event);
+    }
+  }
   CATCH_DUMP_ATTR
+  void CContext::sendFinalizeClient(CContextClient* contextClient, const string& contextClientId)
+  TRY
+  {
+    CEventClient event(getType(),EVENT_ID_CONTEXT_FINALIZE_CLIENT);
+    if (contextClient->isServerLeader())
+    {
+      CMessage msg;
+      msg<<contextClientId ;
+      const std::list<int>& ranks = contextClient->getRanksServerLeader();
+      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+           event.push(*itRank,1,msg);
+      contextClient->sendEvent(event);
+    }
+    else contextClient->sendEvent(event);
+  }
+  CATCH_DUMP_ATTR
+  void CContext::recvFinalizeClient(CEventServer& event)
+  TRY
+  {
+    CBufferIn* buffer=event.subEvents.begin()->buffer;
+    string id;
+    *buffer>>id;
+    get(id)->recvFinalizeClient(*buffer);
+  }
+  CATCH
+  void CContext::recvFinalizeClient(CBufferIn& buffer)
+  TRY
+  {
+    countChildContextFinalized_++ ;
+  }
+  CATCH_DUMP_ATTR
+ //! Client side: Send a message  announcing that context can receive grid definition from coupling
+   void CContext::sendCouplerInReady(CContextClient* client)
+   TRY
+   {
+      if (sendCouplerInReady_done_.count(client)!=0) return ;
+      else sendCouplerInReady_done_.insert(client) ;
+      CEventClient event(getType(),EVENT_ID_COUPLER_IN_READY);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg<<this->getId();
+        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+   }
+   CATCH_DUMP_ATTR
+   //! Server side: Receive a message announcing that context can send grid definition for context coupling
+   void CContext::recvCouplerInReady(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      getCurrent()->recvCouplerInReady(*buffer);
+   }
+   CATCH
+   //! Server side: Receive a message announcing that context can send grid definition for context coupling
+   void CContext::recvCouplerInReady(CBufferIn& buffer)
+   TRY
+   {
+      string contextId ;
+      buffer>>contextId;
+      couplerInReady_.insert(getCouplerOutClient(contextId)) ;
+   }
+   CATCH_DUMP_ATTR
+ //! Client side: Send a message  announcing that a coupling context have done it closeDefinition, so data can be sent now.
+   void CContext::sendCouplerInCloseDefinition(CContextClient* client)
+   TRY
+   {
+      if (sendCouplerInCloseDefinition_done_.count(client)!=0) return ;
+      else sendCouplerInCloseDefinition_done_.insert(client) ;
+      CEventClient event(getType(),EVENT_ID_COUPLER_IN_CLOSE_DEFINITION);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg<<this->getId();
+        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+   }
+   CATCH_DUMP_ATTR
+   //! Server side: Receive a message announcing that a coupling context have done it closeDefinition, so data can be sent now.
+   void CContext::recvCouplerInCloseDefinition(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      getCurrent()->recvCouplerInCloseDefinition(*buffer);
+   }
+   CATCH
+   //! Server side: Receive a message announcing that a coupling context have done it closeDefinition, so data can be sent now.
+   void CContext::recvCouplerInCloseDefinition(CBufferIn& buffer)
+   TRY
+   {
+      string contextId ;
+      buffer>>contextId;
+      couplerInCloseDefinition_.insert(getCouplerOutClient(contextId)) ;
+   }
+   CATCH_DUMP_ATTR
+//! Client side: Send a message  announcing that a coupling context have done it contextFinalize, so it can also close it own context.
+   void CContext::sendCouplerInContextFinalized(CContextClient* client)
+   TRY
+   {
+      if (sendCouplerInContextFinalized_done_.count(client)!=0) return ;
+      else sendCouplerInContextFinalized_done_.insert(client) ;
+      CEventClient event(getType(),EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg<<this->getId();
+        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+   }
+   CATCH_DUMP_ATTR
+   //! Server side: Receive a message announcing that a coupling context have done it contextFinalize, so it can also close it own context.
+   void CContext::recvCouplerInContextFinalized(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      getCurrent()->recvCouplerInContextFinalized(*buffer);
+   }
+   CATCH
+   //! Server side: Receive a message announcing that a coupling context have done it contextFinalize, so it can also close it own context.
+   void CContext::recvCouplerInContextFinalized(CBufferIn& buffer)
+   TRY
+   {
+      string contextId ;
+      buffer>>contextId;
+      couplerInContextFinalized_.insert(getCouplerOutClient(contextId)) ;
+   }
+   CATCH_DUMP_ATTR
   /*!

XIOS/dev/dev_trunk_graph/src/node/context.hpp

-                      r1612
+                      r2019
 #include "registry.hpp"
 #include "mpi.hpp"
+#include "services_manager.hpp"
+#include "server_context.hpp"
 …
    class CContext;
    class CFile;
+   class CCouplerIn ;
+   class CCouplerOut ;
    ///--------------------------------------------------------------
 …
            EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
            EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
+           EVENT_ID_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
+           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
+           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS
+           EVENT_ID_SEND_REGISTRY,
+           EVENT_ID_CONTEXT_FINALIZE_CLIENT,
+           EVENT_ID_COUPLER_IN_READY,
+           EVENT_ID_COUPLER_IN_CLOSE_DEFINITION,
+           EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED,
          };
 …
       public :
          // Initialize server or client
+         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
+         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
+         void init(CServerContext* parentServerContext, MPI_Comm intraComm, int serviceType);
+         void initClient(MPI_Comm intraComm, int serviceType);
+         void initServer(MPI_Comm intraComm, int serviceType );
+         void createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer)  ;
+         void createServerInterComm(void)  ;
          bool isInitialized(void);
 …
          // Put sever or client into loop state
+         bool checkBuffersAndListen(bool enableEventsProcessing=true);
+         bool eventLoop(bool enableEventsProcessing=true);
+         void globalEventLoop(void);
          // Finalize a context
          void finalize(void);
          bool isFinalized(void);
          void closeDefinition(void);
+         // to be removed
+         std::vector<CField*> findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
          // Some functions to process context
+         void findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
+         std::vector<CField*> findAllEnabledFieldsInFileOut(const std::vector<CFile*>& activeFiles);
+         std::vector<CField*> findAllEnabledFieldsInFileIn(const std::vector<CFile*>& activeFiles);
+         std::vector<CField*> findAllEnabledFieldsCouplerOut(const std::vector<CCouplerOut*>& activeCouplerOut);
+         std::vector<CField*> findAllEnabledFieldsCouplerIn(const std::vector<CCouplerIn*>& activeCouplerIn);
          // void findAllEnabledFields(void);
          // void findAllEnabledFieldsInReadModeFiles(void);
 …
          void solveAllInheritance(bool apply=true);
          void findEnabledFiles(void);
+         void findEnabledCouplerIn(void);
+         void findEnabledCouplerOut(void);
+         void createCouplerInterCommunicator(void) ;
          void findEnabledWriteModeFiles(void);
          void findEnabledReadModeFiles(void);
 …
          void createFileHeader(void);
          void initReadFiles(void);
-         void checkAxisDomainsGridsEligibilityForCompressedOutput();
          void prepareTimeseries(void);
-         void solveOnlyRefOfEnabledFields(bool sendToServer);
-         void buildFilterGraphOfEnabledFields();
          void postProcessFilterGraph();
          void startPrefetchingOfEnabledReadModeFiles();
 …
          void doPostTimestepOperationsForEnabledReadModeFiles();
          void findFieldsWithReadAccess(void);
+         void solveAllRefOfFieldsWithReadAccess();
+         void buildFilterGraphOfFieldsWithReadAccess();
+         void postProcessing();
+         void postProcessingGlobalAttributes();
+         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
+         void checkGridEnabledFields();
+         void checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
+         void sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
+         void sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)       ;
+         void triggerLateFields(void) ;
          std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
          std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
+         void setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting = false);
+         void setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting = false); // old interface to be removed
+         void setClientServerBuffer(vector<CField*>& fields, bool bufferForWriting) ;
          // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
          void distributeFiles(void);
          void distributeFileOverBandwith() ;
          void distributeFileOverMemoryBandwith() ;
+         void distributeFiles(const std::vector<CFile*>& files);
+         void distributeFileOverBandwith(const std::vector<CFile*>& files) ;
+         void distributeFileOverMemoryBandwith(const std::vector<CFile*>& files) ;
          // Send context close definition
          void sendCloseDefinition(void);
+       public:
+         void sendCloseDefinition(CContextClient* client) ;
+       private:
+         set<CContextClient*> sendCloseDefinition_done_ ;
+       public:
          // There are something to send on closing context defintion
          void sendUpdateCalendar(int step);
 …
          void sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
          void sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles);
-         void sendRefGrid(const std::vector<CFile*>& activeFiles);
-         void sendPostProcessing();
-         void sendPostProcessingGlobalAttributes();
-         void sendProcessingGridOfEnabledFields();
          //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
          void sendRegistry(void) ;
+         const StdString& getIdServer();
+         const StdString& getIdServer(const int srvPoolNb);
+         void sendFinalizeClient(CContextClient* contextClient, const string& contextClientId);
+         public:
+         void sendContextToFileServer(CContextClient* client) ;
+         private:
+         std::set<CContextClient*> sendToFileServer_done_ ;
+         public:
+         std::string getContextId() {return contextId_;}
          // Client side: Receive and process messages
 …
          static void recvSolveInheritanceContext(CEventServer& event);
          void recvSolveInheritanceContext(CBufferIn& buffer);
-         static void recvPostProcessing(CEventServer& event);
-         void recvPostProcessing(CBufferIn& buffer);
-         static void recvProcessingGridOfEnabledFields(CEventServer& event);
-         static void recvPostProcessingGlobalAttributes(CEventServer& event);
-         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
          static void recvRegistry(CEventServer& event) ;
          void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
+         void freeComms(void);                  //!< Free internally allcoated communicators
+         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
+         static void recvFinalizeClient(CEventServer& event) ;
+         void recvFinalizeClient(CBufferIn& buffer);
+       public:
+         void sendCouplerInReady(CContextClient* client);
+       private:
+         set<CContextClient*> sendCouplerInReady_done_;
+       public:
+         static void recvCouplerInReady(CEventServer& event) ;
+         void recvCouplerInReady(CBufferIn& buffer) ; //!< coupler is ready to receive grid definition.
+         set<CContextClient*> couplerInReady_;
+         bool isCouplerInReady(CContextClient* client) { return couplerInReady_.count(client)!=0 ;}
+       public:
+        void sendCouplerInCloseDefinition(CContextClient* client) ;
+        set<CContextClient*> sendCouplerInCloseDefinition_done_;
+        static void recvCouplerInCloseDefinition(CEventServer& event) ;
+        void recvCouplerInCloseDefinition(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent
+        set<CContextClient*> couplerInCloseDefinition_ ;
+        bool isCouplerInCloseDefinition(CContextClient* client) { return couplerInCloseDefinition_.count(client)!=0 ;}
+       public:
+        void sendCouplerInContextFinalized(CContextClient* client) ;
+        set<CContextClient*> sendCouplerInContextFinalized_done_;
+        static void recvCouplerInContextFinalized(CEventServer& event) ;
+        void recvCouplerInContextFinalized(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent
+        set<CContextClient*> couplerInContextFinalized_ ;
+        bool isCouplerInContextFinalized(CContextClient* client) { return couplerInContextFinalized_.count(client)!=0 ;}
+       public:
+        void freeComms(void);                  //!< Free internally allcoated communicators
+        void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
          // dispatch event
 …
         static void ShowTree(StdOStream & out = std::clog);
         static void CleanTree(void);
+        int getServiceType(void) {return serviceType_;}
       public :
 …
          virtual bool hasChild(void) const;
+         bool isProcessingEvent(void) {return isProcessingEvent_;}
+         bool setProcessingEvent(void) {isProcessingEvent_=true ;}
+         bool unsetProcessingEvent(void) {isProcessingEvent_=false ;}
+         MPI_Comm getIntraComm(void) {return intraComm_ ;}
+         int getIntraCommRank(void) {return intraCommRank_;}
+         int getIntraCommSize(void) {return intraCommSize_;}
+         void addCouplingChanel(const std::string& contextId, bool out) ;
       public :
 …
          std::vector<CFile*> enabledWriteModeFiles;
+         std::vector<CCouplerIn*> enabledCouplerIn;
+         std::vector<CCouplerOut*> enabledCouplerOut;
          // List of all enabled fields whose instant data is accessible from the public API
          // but which are not part of a file
+         std::vector<CField*> fieldsWithReadAccess;
+         std::vector<CField*> fieldsWithReadAccess_;
+         std::vector<CField*> couplerInFields_;
+         std::vector<CField*> fileInFields_;
          // Context root
 …
          std::vector<CContextClient*> clientPrimServer;
+         // list of slave servers (IO server or others)
+         set<CContextClient*> slaveServers_ ;
+      private:
+         // the map containing context client associated to it string id for coupling out ;
+         std::map<std::string, CContextClient*> couplerOutClient_ ;
+         // the map containing context server associated to it string id for coupling out ;
+         std::map<std::string, CContextServer*> couplerOutServer_ ;
+         // the map containing context client associated to it string id for coupling in ;
+         std::map<std::string, CContextClient*> couplerInClient_ ;
+         // the map containing context server associated to it string id for coupling in ;
+         std::map<std::string, CContextServer*> couplerInServer_ ;
+      public:
+         CContextClient* getCouplerInClient(const string& contextId) { return couplerInClient_[contextId] ;}
+         CContextServer* getCouplerInServer(const string& contextId) { return couplerInServer_[contextId] ;}
+         CContextClient* getCouplerOutClient(const string& contextId) { return couplerOutClient_[contextId] ;}
+         CContextServer* getCouplerOutServer(const string& contextId) { return couplerOutServer_[contextId] ;}
+         std::vector<std::string> primServerId_;
          CRegistry* registryIn ;    //!< input registry which is read from file
          CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
+        MPI_Comm intraComm_ ; //! context intra communicator
+        int intraCommRank_ ; //! context intra communicator rank
+        int intraCommSize_ ; //! context intra communicator size
       private:
          bool isPostProcessed;
          bool allProcessed;
          bool finalized;
+         int countChildCtx_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
+         StdString idServer_;
+         int countChildContextFinalized_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
          CGarbageCollector garbageCollector;
          std::list<MPI_Comm> comms; //!< Communicators allocated internally
+         int serviceType_;  //!< service associated to the context
+         string contextId_ ; //!< context client id for the servers. For clients this is same as getId()
+         bool isProcessingEvent_ ;
+         CServerContext* parentServerContext_ ;
       public: // Some function maybe removed in the near future

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

-                      r1686
+                      r2019
 #include "domain.hpp"
 #include "attribute_template.hpp"
 #include "object_template.hpp"
 …
 #include "server_distribution_description.hpp"
 #include "client_server_mapping_distributed.hpp"
+#include "local_connector.hpp"
+#include "grid_local_connector.hpp"
+#include "remote_connector.hpp"
+#include "gatherer_connector.hpp"
+#include "scatterer_connector.hpp"
+#include "grid_scatterer_connector.hpp"
+#include "grid_gatherer_connector.hpp"
+#include "transformation_path.hpp"
 #include <algorithm>
 …
    CDomain::CDomain(void)
       : CObjectTemplate<CDomain>(), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbSenders(), indSrv_(), connectedServerRank_()
+      , isChecked(false), relFiles(),  indSrv_(), connectedServerRank_()
       , hasBounds(false), hasArea(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
+      , hasLonLat(false)
       , isRedistributed_(false), hasPole(false)
       , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue()
-      , globalLocalIndexMap_(), computedWrittenIndex_(false)
       , clients(), hasLatInReadFile_(false), hasBoundsLatInReadFile_(false)
       , hasLonInReadFile_(false), hasBoundsLonInReadFile_(false)
 …
    CDomain::CDomain(const StdString & id)
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbSenders(), indSrv_(), connectedServerRank_()
+      , isChecked(false), relFiles(), indSrv_(), connectedServerRank_()
       , hasBounds(false), hasArea(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
+      , hasLonLat(false)
       , isRedistributed_(false), hasPole(false)
       , lonvalue(), latvalue(), bounds_lonvalue(), bounds_latvalue()
-      , globalLocalIndexMap_(), computedWrittenIndex_(false)
       , clients(), hasLatInReadFile_(false), hasBoundsLatInReadFile_(false)
       , hasLonInReadFile_(false), hasBoundsLonInReadFile_(false)
 …
    CATCH
+   std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>();
+   bool CDomain::_dummyTransformationMapList = CDomain::initializeTransformationMap(CDomain::transformationMapList_);
+   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+   TRY
+   {
+     m["zoom_domain"] = TRANS_ZOOM_DOMAIN;
+     m["interpolate_domain"] = TRANS_INTERPOLATE_DOMAIN;
+     m["generate_rectilinear_domain"] = TRANS_GENERATE_RECTILINEAR_DOMAIN;
+     m["compute_connectivity_domain"] = TRANS_COMPUTE_CONNECTIVITY_DOMAIN;
+     m["expand_domain"] = TRANS_EXPAND_DOMAIN;
+     m["reorder_domain"] = TRANS_REORDER_DOMAIN;
+     m["extract_domain"] = TRANS_EXTRACT_DOMAIN;
+   const std::set<StdString> & CDomain::getRelFiles(void) const
+   TRY
+   {
+      return (this->relFiles);
+   }
    CATCH
+   const std::set<StdString> & CDomain::getRelFiles(void) const
+   TRY
+   {
+      return (this->relFiles);
+   }
+   CATCH
+   /*!
+     Returns the number of indexes written by each server.
+     \return the number of indexes written by each server
+   */
+   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return numberWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Returns the total number of indexes written by the servers.
+     \return the total number of indexes written by the servers
+   */
+   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return totalNumberWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Returns the offset of indexes written by each server.
+     \return the offset of indexes written by each server
+   */
+   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return offsetWrittenIndexes_[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom)
+   TRY
+   {
+     int writtenSize;
+     MPI_Comm_size(writtenCom, &writtenSize);
+     return compressedIndexToWriteOnServer[writtenSize];
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+     //----------------------------------------------------------------
    /*!
 …
               (!i_index.isEmpty() && i_index.numElements() == ni_glo*nj_glo));
       bool distributed_glo ;
       distributed |= (1 == CContext::getCurrent()->client->clientSize);
+      distributed |= (1 == CContext::getCurrent()->intraCommSize_);
       return distributed;
 …
    /*!
+    * Test whether the data defined on the domain can be outputted in a compressed way.
+    *
+    * \return true if and only if a mask was defined for this domain
+    * Compute if the domain can be ouput in a compressed way.
+    * In this case the workflow view on server side must be the same
+    * than the full view for all context rank. The result is stored on
+    * internal isCompressible_ attribute.
     */
+   bool CDomain::isCompressible(void) const
+   TRY
+   {
+      return isCompressible_;
+   void CDomain::computeIsCompressible(void)
+   TRY
+   {
+     // mesh is compressible contains some masked or indexed value, ie if full view is different of workflow view.
+     // But now assume that the size of the 2 view must be equal for everybody. True on server side
+     int isSameView = getLocalView(CElementView::FULL)->getSize() ==  getLocalView(CElementView::WORKFLOW)->getSize();
+     MPI_Allreduce(MPI_IN_PLACE, &isSameView, 1, MPI_INT, MPI_LAND, CContext::getCurrent()->getIntraComm()) ;
+     if (isSameView) isCompressible_ = false ;
+     else isCompressible_ = true ;
+     isCompressibleComputed_=true ;
+   }
    CATCH
 …
      // For now the assumption is that secondary server pools consist of the same number of procs.
      // CHANGE the line below if the assumption changes.
+     CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[0] : context->client;
      int rankClient = client->clientRank;
+     int rankClient = context->intraCommRank_;
      int rankOnDomain = rankClient%nbLocalDomain;
 …
     // For now the assumption is that secondary server pools consist of the same number of procs.
     // CHANGE the line below if the assumption changes.
     CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[0] : context->client;
+     int clientSize = context->intraCommSize_ ;
      lon_g.resize(ni_glo) ;
      lat_g.resize(nj_glo) ;
      int* ibegin_g = new int[client->clientSize] ;
      int* jbegin_g = new int[client->clientSize] ;
      int* ni_g = new int[client->clientSize] ;
      int* nj_g = new int[client->clientSize] ;
+     int* ibegin_g = new int[clientSize] ;
+     int* jbegin_g = new int[clientSize] ;
+     int* ni_g = new int[clientSize] ;
+     int* nj_g = new int[clientSize] ;
      int v ;
      v=ibegin ;
      MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ibegin_g,1,MPI_INT,context->intraComm_) ;
      v=jbegin ;
      MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,jbegin_g,1,MPI_INT,context->intraComm_) ;
      v=ni ;
      MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,ni_g,1,MPI_INT,context->intraComm_) ;
      v=nj ;
      MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,client->intraComm) ;
      MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,client->intraComm) ;
      MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,client->intraComm) ;
+     MPI_Allgather(&v,1,MPI_INT,nj_g,1,MPI_INT,context->intraComm_) ;
+     MPI_Allgatherv(lon.dataFirst(),ni,MPI_DOUBLE,lon_g.dataFirst(),ni_g, ibegin_g,MPI_DOUBLE,context->intraComm_) ;
+     MPI_Allgatherv(lat.dataFirst(),nj,MPI_DOUBLE,lat_g.dataFirst(),nj_g, jbegin_g,MPI_DOUBLE,context->intraComm_) ;
       delete[] ibegin_g ;
 …
    CATCH_DUMP_ATTR
-   void CDomain::checkEligibilityForCompressedOutput(void)
-   TRY
+   {
-     // We don't check if the mask or the indexes are valid here, just if they have been defined at this point.
-     isCompressible_ = !mask_1d.isEmpty() || !mask_2d.isEmpty() || !data_i_index.isEmpty();
+   }
-   CATCH_DUMP_ATTR
    //----------------------------------------------------------------
 …
    CATCH_DUMP_ATTR
-   void CDomain::checkAttributesOnClientAfterTransformation()
-   TRY
+   {
-     CContext* context=CContext::getCurrent() ;
-     if (this->isClientAfterTransformationChecked) return;
-     if (context->hasClient)
+     {
-      this->computeConnectedClients();
-       if (hasLonLat)
-         if (!context->hasServer)
-           this->completeLonLatClient();
+     }
-     this->isClientAfterTransformationChecked = true;
+   }
-   CATCH_DUMP_ATTR
-   //----------------------------------------------------------------
-   // Divide function checkAttributes into 2 seperate ones
-   // This function only checks all attributes of current domain
-   void CDomain::checkAttributesOnClient()
-   TRY
+   {
-     if (this->isClientChecked) return;
-     CContext* context=CContext::getCurrent();
-      if (context->hasClient && !context->hasServer)
+      {
-        this->checkDomain();
-        this->checkBounds();
-        this->checkArea();
-        this->checkLonLat();
+      }
-      if (context->hasClient && !context->hasServer)
-      { // Ct client uniquement
-         this->checkMask();
-         this->checkDomainData();
-         this->checkCompression();
-         this->computeLocalMask() ;
+      }
-      else
-      { // Ct serveur uniquement
+      }
-      this->isClientChecked = true;
+   }
-   CATCH_DUMP_ATTR
-   // Send all checked attributes to server
-   void CDomain::sendCheckedAttributes()
-   TRY
+   {
-     if (!this->isClientChecked) checkAttributesOnClient();
-     if (!this->isClientAfterTransformationChecked) checkAttributesOnClientAfterTransformation();
-     CContext* context=CContext::getCurrent() ;
-     if (this->isChecked) return;
-     if (context->hasClient)
+     {
-       sendAttributes();
+     }
-     this->isChecked = true;
+   }
-   CATCH_DUMP_ATTR
    void CDomain::checkAttributes(void)
    TRY
+   {
+      if (this->isChecked) return;
+      CContext* context=CContext::getCurrent() ;
+      if (this->checkAttributes_done_) return;
       this->checkDomain();
       this->checkLonLat();
       this->checkBounds();
       this->checkArea();
+      if (context->hasClient)
+      { // Ct client uniquement
+         this->checkMask();
+         this->checkDomainData();
+         this->checkCompression();
+         this->computeLocalMask() ;
+      }
+      else
+      { // Ct serveur uniquement
+      }
+      if (context->hasClient)
+      {
+        this->computeConnectedClients();
+        this->completeLonLatClient();
+      }
+      this->isChecked = true;
+      this->checkMask();
+      this->checkDomainData();
+      this->checkCompression();
+      this->computeLocalMask() ;
+      this->completeLonLatClient();
+      this->initializeLocalElement() ;
+      this->addFullView() ; // probably do not automatically add View, but only if requested
+      this->addWorkflowView() ; // probably do not automatically add View, but only if requested
+      this->addModelView() ; // probably do not automatically add View, but only if requested
+      // testing ?
+     /*
+      CLocalView* local = localElement_->getView(CElementView::WORKFLOW) ;
+      CLocalView* model = localElement_->getView(CElementView::MODEL) ;
+      CLocalConnector test1(model, local) ;
+      test1.computeConnector() ;
+      CLocalConnector test2(local, model) ;
+      test2.computeConnector() ;
+      CGridLocalConnector gridTest1(vector<CLocalConnector*>{&test1}) ;
+      CGridLocalConnector gridTest2(vector<CLocalConnector*>{&test2}) ;
+      CArray<int,1> out1 ;
+      CArray<int,1> out2 ;
+      test1.transfer(data_i_index,out1,-111) ;
+      test2.transfer(out1,out2,-111) ;
+      out1 = 0 ;
+      out2 = 0 ;
+      gridTest1.transfer(data_i_index,out1,-111) ;
+      gridTest2.transfer(out1, out2,-111) ;
+    */
+      this->checkAttributes_done_ = true;
+   }
    CATCH_DUMP_ATTR
+  /*!
+     Compute the connection of a client to other clients to determine which clients to send attributes to.
+     The sending clients are supposed to already know the distribution of receiving clients (In simple cases, it's band)
+     The connection among clients is calculated by using global index.
+     A client connects to other clients which holds the same global index as it.
+  */
+  void CDomain::computeConnectedClients()
+   void CDomain::initializeLocalElement(void)
+   {
+      // after checkDomain i_index and j_index of size (ni*nj)
+      int nij = ni*nj ;
+      CArray<size_t, 1> ij_index(ni*nj) ;
+      for(int ij=0; ij<nij ; ij++) ij_index(ij) = i_index(ij)+j_index(ij)*ni_glo ;
+      int rank = CContext::getCurrent()->getIntraCommRank() ;
+      localElement_ = new CLocalElement(rank, ni_glo*nj_glo, ij_index) ;
+   }
+   void CDomain::addFullView(void)
+   {
+      CArray<int,1> index(ni*nj) ;
+      int nij=ni*nj ;
+      for(int ij=0; ij<nij ; ij++) index(ij)=ij ;
+      localElement_ -> addView(CElementView::FULL, index) ;
+   }
+   void CDomain::addWorkflowView(void)
+   {
+     // information for workflow view is stored in localMask
+     int nij=ni*nj ;
+     int nMask=0 ;
+     for(int ij=0; ij<nij ; ij++) if (localMask(ij)) nMask++ ;
+     CArray<int,1> index(nMask) ;
+     nMask=0 ;
+     for(int ij=0; ij<nij ; ij++)
+      if (localMask(ij))
+      {
+        index(nMask)=ij ;
+        nMask++ ;
+      }
+      localElement_ -> addView(CElementView::WORKFLOW, index) ;
+   }
+   void CDomain::addModelView(void)
+   {
+     // information for model view is stored in data_i_index/data_j_index
+     // very weird, do not mix data_i_index and data_i_begin => in future only keep data_i_index
+     int dataSize = data_i_index.numElements() ;
+     CArray<int,1> index(dataSize) ;
+     int i,j ;
+     for(int k=0;k<dataSize;k++)
+     {
+        if (data_dim==2)
+        {
+          i=data_i_index(k)+data_ibegin ; // bad
+          j=data_j_index(k)+data_jbegin ; // bad
+          if (i>=0 && i<ni && j>=0 && j<nj) index(k)=i+j*ni ;
+          else index(k)=-1 ;
+        }
+        else if (data_dim==1)
+        {
+          i=data_i_index(k)+data_ibegin ; // bad
+          if (i>=0 && i<ni*nj) index(k)=i ;
+          else index(k)=-1 ;
+        }
+     }
+     localElement_->addView(CElementView::MODEL, index) ;
+   }
+   void CDomain::computeModelToWorkflowConnector(void)
+   {
+     CLocalView* srcView=getLocalView(CElementView::MODEL) ;
+     CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ;
+     modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);
+     modelToWorkflowConnector_->computeConnector() ;
+   }
+  /* to be removed later when coupling will be reimplemented, just to  not forget */
+  void CDomain::sendDomainToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid)
+  {
+    if (sendDomainToFileServer_done_.count(client)!=0) return ;
+    else sendDomainToFileServer_done_.insert(client) ;
+    const string domainId = "_domain["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    if (!domain_ref.isEmpty())
+    {
+      auto domain_ref_tmp=domain_ref.getValue() ;
+      domain_ref.reset() ; // remove the reference, find an other way to do that more cleanly
+      this->sendAllAttributesToServer(client, domainId)  ;
+      domain_ref = domain_ref_tmp ;
+    }
+    else this->sendAllAttributesToServer(client, domainId)  ;
+  }
+  void CDomain::makeAliasForCoupling(const string& fieldId, int posInGrid)
+  {
+    const string domainId = "_domain["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    this->createAlias(domainId) ;
+  }
+  void CDomain::computeRemoteElement(CContextClient* client, EDistributionType type)
   TRY
+  {
+    CContext* context=CContext::getCurrent() ;
+    // This line should be changed soon.
+    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 0) : 1;
+    nbSenders.clear();
+    connectedServerRank_.clear();
+    for (int p = 0; p < nbSrvPools; ++p)
+    CContext* context = CContext::getCurrent();
+    map<int, CArray<size_t,1>> globalIndex ;
+    if (type==EDistributionType::BANDS) // Bands distribution to send to file server
+    {
-      CContextClient* client = (0 != context->clientPrimServer.size()) ? context->clientPrimServer[p] : context->client;
-      int nbServer = client->serverSize;
-      int nbClient = client->clientSize;
-      int rank     = client->clientRank;
-      bool doComputeGlobalIndexServer = true;
-      if (connectedServerRank_.find(nbServer) == connectedServerRank_.end())
+      {
-        if (indSrv_.find(nbServer) == indSrv_.end())
+        {
-          int i,j,i_ind,j_ind, nbIndex=i_index.numElements();
-          int globalIndexCount = i_index.numElements();
-          // Fill in index
-          CArray<size_t,1> globalIndexDomain(nbIndex);
-          size_t globalIndex;
-          for (i = 0; i < nbIndex; ++i)
+          {
-            i_ind=i_index(i);
-            j_ind=j_index(i);
-            globalIndex = i_ind + j_ind * ni_glo;
-            globalIndexDomain(i) = globalIndex;
+          }
-          if (globalLocalIndexMap_.empty())
+          {
-            for (i = 0; i < nbIndex; ++i)
-              globalLocalIndexMap_[globalIndexDomain(i)] = i;
+          }
-          size_t globalSizeIndex = 1, indexBegin, indexEnd;
-          int range, clientSize = client->clientSize;
-          std::vector<int> nGlobDomain(2);
-          nGlobDomain[0] = this->ni_glo;
-          nGlobDomain[1] = this->nj_glo;
-          for (int i = 0; i < nGlobDomain.size(); ++i) globalSizeIndex *= nGlobDomain[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;
+          }
-          // Even if servers have no index, they must received something from client
-          // We only use several client to send "empty" message to these servers
-          CServerDistributionDescription serverDescription(nGlobDomain, nbServer);
-          std::vector<int> serverZeroIndex;
-          if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0);
-          else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 1);
-          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];
-          CClientServerMapping* clientServerMap = new CClientServerMappingDistributed(serverDescription.getGlobalIndexRange(), client->intraComm);
-          clientServerMap->computeServerIndexMapping(globalIndexDomain, nbServer);
-          CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer();
-          CClientServerMapping::GlobalIndexMap::const_iterator it  = globalIndexDomainOnServer.begin(),
-                 ite = globalIndexDomainOnServer.end();
-          indSrv_[nbServer].swap(globalIndexDomainOnServer);
-          connectedServerRank_[nbServer].clear();
-          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);
-          // Now check if all servers have data to receive. If not, master client will send empty data.
-          // This ensures that all servers will participate in collective calls upon receiving even if they have no date to receive.
-          std::vector<int> counts (clientSize);
-          std::vector<int> displs (clientSize);
-          displs[0] = 0;
-          int localCount = connectedServerRank_[nbServer].size() ;
-          MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
-          for (int i = 0; i < clientSize-1; ++i)
+          {
-            displs[i+1] = displs[i] + counts[i];
+          }
-          std::vector<int> allConnectedServers(displs[clientSize-1]+counts[clientSize-1]);
-          MPI_Gatherv(&(connectedServerRank_[nbServer])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
-          if ((allConnectedServers.size() != nbServer) && (rank == 0))
+          {
-            std::vector<bool> isSrvConnected (nbServer, false);
-            for (int i = 0; i < allConnectedServers.size(); ++i) isSrvConnected[allConnectedServers[i]] = true;
-            for (int i = 0; i < nbServer; ++i)
+            {
-              if (!isSrvConnected[i]) connectedServerRank_[nbServer].push_back(i);
+            }
+          }
-          nbSenders[nbServer] = clientServerMap->computeConnectedClients(client->serverSize, client->clientSize, client->intraComm, connectedServerRank_[nbServer]);
-          delete clientServerMap;
+        }
+      }
+    }
+  }
-  CATCH_DUMP_ATTR
-   /*!
-     Compute index to write data. We only write data on the zoomed region, therefore, there should
-     be a map between the complete grid and the reduced grid where we write data.
-     By using global index we can easily create this kind of mapping.
-   */
-   void CDomain::computeWrittenIndex()
-   TRY
+   {
-      if (computedWrittenIndex_) return;
-      computedWrittenIndex_ = true;
-      CContext* context=CContext::getCurrent();
-      CContextServer* server = context->server;
-      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2);
-      nBegin[0]       = ibegin;  nBegin[1] = jbegin;
-      nSize[0]        = ni;      nSize[1]  = nj;
-      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0;
-      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo;
-      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);
-      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
-      size_t nbWritten = 0, indGlo;
-      std::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;
-      localIndexToWriteOnServer.resize(writtenGlobalIndex.numElements());
-      nbWritten = 0;
-      for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+      {
-        indGlo = *itSrv;
-        if (ite != globalLocalIndexMap_.find(indGlo))
+        {
-          localIndexToWriteOnServer(nbWritten) = globalLocalIndexMap_[indGlo];
+        }
-        else
+        {
-          localIndexToWriteOnServer(nbWritten) = -1;
+        }
-        ++nbWritten;
+      }
+   }
-   CATCH_DUMP_ATTR
-  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm)
-  TRY
+  {
-    int writtenCommSize;
-    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;
-      std::vector<int> nBegin(2), nSize(2), nBeginGlobal(2), nGlob(2);
-      nBegin[0]       = ibegin;  nBegin[1] = jbegin;
-      nSize[0]        = ni;      nSize[1]  = nj;
-      nBeginGlobal[0] = 0; nBeginGlobal[1] = 0;
-      nGlob[0]        = ni_glo;   nGlob[1] = nj_glo;
-      CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);
-      const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
-      std::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;
-      std::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_i_index.numElements(); ++idx)
+      {
-        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx)))
+        {
-          ++nbWritten;
+        }
+      }
-      compressedIndexToWriteOnServer[writtenCommSize].resize(nbWritten);
-      nbWritten = 0;
-      for (int idx = 0; idx < data_i_index.numElements(); ++idx)
+      {
-        if (localGlobalIndexMap.end() != localGlobalIndexMap.find(data_i_index(idx)))
+        {
-          compressedIndexToWriteOnServer[writtenCommSize](nbWritten) = localGlobalIndexMap[data_i_index(idx)];
-          ++nbWritten;
+        }
+      }
-      numberWrittenIndexes_[writtenCommSize] = nbWritten;
-      bool distributed_glo, distributed=isDistributed() ;
-      MPI_Allreduce(&distributed,&distributed_glo, 1, MPI_INT, MPI_LOR, writtenComm) ;
-      if (distributed_glo)
+      {
-        MPI_Allreduce(&numberWrittenIndexes_[writtenCommSize], &totalNumberWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
-        MPI_Scan(&numberWrittenIndexes_[writtenCommSize], &offsetWrittenIndexes_[writtenCommSize], 1, MPI_INT, MPI_SUM, writtenComm);
-        offsetWrittenIndexes_[writtenCommSize] -= numberWrittenIndexes_[writtenCommSize];
+      }
-      else
-        totalNumberWrittenIndexes_[writtenCommSize] = numberWrittenIndexes_[writtenCommSize];
+      }
+  }
-  CATCH_DUMP_ATTR
-  /*!
-    Send all attributes from client to connected clients
-    The attributes will be rebuilt on receiving side
-  */
-  void CDomain::sendAttributes()
-  TRY
+  {
-    sendDistributionAttributes();
-    sendIndex();
-    sendLonLat();
-    sendArea();
-    sendDataIndex();
+  }
-  CATCH
-  /*!
-    Send global index from client to connected client(s)
-  */
-  void CDomain::sendIndex()
-  TRY
+  {
-    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 serverSize = client->serverSize;
-      CEventClient eventIndex(getType(), EVENT_ID_INDEX);
-      list<CMessage> list_msgsIndex;
-      list<CArray<int,1> > list_indGlob;
-      std::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex;
-      iteIndex = indSrv_[serverSize].end();
-      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
+      {
-        int nbIndGlob = 0;
-        int rank = connectedServerRank_[serverSize][k];
-        itIndex = indSrv_[serverSize].find(rank);
-        if (iteIndex != itIndex)
-          nbIndGlob = itIndex->second.size();
-        list_indGlob.push_back(CArray<int,1>(nbIndGlob));
-        CArray<int,1>& indGlob = list_indGlob.back();
-        for (n = 0; n < nbIndGlob; ++n)
+        {
-          indGlob(n) = static_cast<int>(itIndex->second[n]);
+        }
-        list_msgsIndex.push_back(CMessage());
-        list_msgsIndex.back() << this->getId() << (int)type; // enum ne fonctionne pour les message => ToFix
-        list_msgsIndex.back() << isCurvilinear;
-        list_msgsIndex.back() << list_indGlob.back(); //list_indi.back() << list_indj.back();
-        eventIndex.push(rank, nbSenders[serverSize][rank], list_msgsIndex.back());
+      }
-      client->sendEvent(eventIndex);
+    }
+  }
-  CATCH_DUMP_ATTR
-  /*!
-    Send distribution from client to other clients
-    Because a client in a level knows correctly the grid distribution of client on the next level
-    it calculates this distribution then sends it to the corresponding clients on the next level
-  */
-  void CDomain::sendDistributionAttributes(void)
-  TRY
+  {
-    std::list<CContextClient*>::iterator it;
-    for (it=clients.begin(); it!=clients.end(); ++it)
+    {
-      CContextClient* client = *it;
       int nbServer = client->serverSize;
       std::vector<int> nGlobDomain(2);
 …
       nGlobDomain[1] = this->nj_glo;
+      // to be changed in future, need to rewrite more simply domain distribution
       CServerDistributionDescription serverDescription(nGlobDomain, nbServer);
+      if (isUnstructed_) serverDescription.computeServerDistribution(false, 0);
+      else serverDescription.computeServerDistribution(false, 1);
+      int distributedPosition ;
+      if (isUnstructed_) distributedPosition = 0 ;
+      else distributedPosition = 1 ;
       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 ibegin_srv = serverIndexBegin[*itRank][0];
+          const int jbegin_srv = serverIndexBegin[*itRank][1];
+          const int ni_srv = serverDimensionSizes[*itRank][0];
+          const int nj_srv = serverDimensionSizes[*itRank][1];
+          msgs.push_back(CMessage());
+          CMessage& msg = msgs.back();
+          msg << this->getId() ;
+          msg << isUnstructed_;
+          msg << ni_srv << ibegin_srv << nj_srv << jbegin_srv;
+          msg << ni_glo.getValue() << nj_glo.getValue();
+          msg << isCompressible_;
+          event.push(*itRank,1,msg);
+        }
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+      vector<unordered_map<size_t,vector<int>>> indexServerOnElement ;
+      CArray<int,1> axisDomainOrder(1) ; axisDomainOrder(0)=2 ;
+      auto zeroIndex=serverDescription.computeServerGlobalByElement(indexServerOnElement, context->getIntraCommRank(), context->getIntraCommSize(),
+                                                                  axisDomainOrder,distributedPosition) ;
+      // distribution is very bad => to redo
+      // convert indexServerOnElement => map<int,CArray<size_t,1>> - need to be changed later
+      map<int, vector<size_t>> vectGlobalIndex ;
+      for(auto& indexRanks : indexServerOnElement[0])
+      {
+        size_t index=indexRanks.first ;
+        auto& ranks=indexRanks.second ;
+        for(int rank : ranks) vectGlobalIndex[rank].push_back(index) ;
+      }
+      for(auto& vect : vectGlobalIndex ) globalIndex.emplace(vect.first, CArray<size_t,1>(vect.second.data(), shape(vect.second.size()),duplicateData)) ;
+    // some servers receves no index (zeroIndex array) => root process take them into account.
+      if (context->getIntraCommRank()==0)
+        for(auto& rank : zeroIndex) globalIndex[rank] = CArray<size_t,1>() ;
+    }
+    else if (type==EDistributionType::NONE) // domain is not distributed ie all servers get the same local domain
+    {
+      int nbServer = client->serverSize;
+      int nglo=ni_glo*nj_glo ;
+      CArray<size_t,1> indGlo ;
+      for(size_t i=0;i<nglo;i++) indGlo(i) = i ;
+      for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer] = indGlo ;
+    }
+    remoteElement_[client] = new CDistributedElement(ni_glo*nj_glo, globalIndex) ;
+    remoteElement_[client]->addFullView() ;
+  }
   CATCH_DUMP_ATTR
   /*!
+    Send area from client to connected client(s)
   */
   void CDomain::sendArea()
+  CATCH
+  void CDomain::distributeToServer(CContextClient* client, map<int, CArray<size_t,1>>& globalIndex,
+                                   CScattererConnector* &scattererConnector, const string& domainId)
   TRY
+  {
+    if (!hasArea) return;
+    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 serverSize = client->serverSize;
+      // send area for each connected server
+      CEventClient eventArea(getType(), EVENT_ID_AREA);
+      list<CMessage> list_msgsArea;
+      list<CArray<double,1> > list_area;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      iteMap = indSrv_[serverSize].end();
+      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
+      {
+        int nbData = 0;
+        int rank = connectedServerRank_[serverSize][k];
+        it = indSrv_[serverSize].find(rank);
+        if (iteMap != it)
+          nbData = it->second.size();
+        list_area.push_back(CArray<double,1>(nbData));
+        const std::vector<size_t>& temp = it->second;
+        for (n = 0; n < nbData; ++n)
+        {
+          idx = static_cast<int>(it->second[n]);
+          list_area.back()(n) = areavalue(globalLocalIndexMap_[idx]);
+        }
+        list_msgsArea.push_back(CMessage());
+        list_msgsArea.back() << this->getId() << hasArea;
+        list_msgsArea.back() << list_area.back();
+        eventArea.push(rank, nbSenders[serverSize][rank], list_msgsArea.back());
+      }
+      client->sendEvent(eventArea);
+    }
+    string serverDomainId = domainId.empty() ? this->getId() : domainId ;
+    CContext* context = CContext::getCurrent();
+    this->sendAllAttributesToServer(client, serverDomainId)  ;
+    CDistributedElement scatteredElement(ni_glo*nj_glo, globalIndex) ;
+    scatteredElement.addFullView() ;
+    scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),
+                                           context->getIntraComm(), client->getRemoteSize()) ;
+    scattererConnector->computeConnector() ;
+    // phase 0
+    // send remote element to construct the full view on server, ie without hole
+    CEventClient event0(getType(), EVENT_ID_DOMAIN_DISTRIBUTION);
+    CMessage message0 ;
+    message0<<serverDomainId<<0 ;
+    remoteElement_[client]->sendToServer(client,event0,message0) ;
+    // phase 1
+    // send the full view of element to construct the connector which connect distributed data coming from client to the full local view
+    CEventClient event1(getType(), EVENT_ID_DOMAIN_DISTRIBUTION);
+    CMessage message1 ;
+    message1<<serverDomainId<<1<<localElement_->getView(CElementView::FULL)->getGlobalSize() ;
+    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ;
+    sendDistributedAttributes(client, *scattererConnector, domainId) ;
+    // phase 2 send the mask : data index + mask2D
+    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize());
+    CArray<bool,1> maskOut ;
+    CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ;
+    workflowToFull.computeConnector() ;
+    maskIn=true ;
+    workflowToFull.transfer(maskIn,maskOut,false) ;
+    // phase 3 : prepare grid scatterer connector to send data from client to server
+    map<int,CArray<size_t,1>> workflowGlobalIndex ;
+    map<int,CArray<bool,1>> maskOut2 ;
+    scattererConnector->transfer(maskOut, maskOut2, false) ;
+    scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ;
+    scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ;
+    // create new workflow view for scattered element
+    CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ;
+    clientToServerElement.addFullView() ;
+    CEventClient event2(getType(), EVENT_ID_DOMAIN_DISTRIBUTION);
+    CMessage message2 ;
+    message2<<serverDomainId<<2 ;
+    clientToServerElement.sendToServer(client, event2, message2) ;
+    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL),
+                                                               context->getIntraComm(), client->getRemoteSize()) ;
+    clientToServerConnector_[client]->computeConnector() ;
+    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW));
+    clientFromServerConnector_[client]->computeConnector() ;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Send longitude and latitude from client to servers
+    Each client send long and lat information to corresponding connected clients(s).
+    Because longitude and latitude are optional, this function only called if latitude and longitude exist
+  */
+  void CDomain::sendLonLat()
+  CATCH
+  void CDomain::recvDomainDistribution(CEventServer& event)
   TRY
+  {
+    if (!hasLonLat) return;
+    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 serverSize = client->serverSize;
+      // send lon lat for each connected server
+      CEventClient eventLon(getType(), EVENT_ID_LON);
+      CEventClient eventLat(getType(), EVENT_ID_LAT);
+      list<CMessage> list_msgsLon, list_msgsLat;
+      list<CArray<double,1> > list_lon, list_lat;
+      list<CArray<double,2> > list_boundslon, list_boundslat;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      iteMap = indSrv_[serverSize].end();
+      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
+      {
+        int nbData = 0;
+        int rank = connectedServerRank_[serverSize][k];
+        it = indSrv_[serverSize].find(rank);
+        if (iteMap != it)
+          nbData = it->second.size();
+        list_lon.push_back(CArray<double,1>(nbData));
+        list_lat.push_back(CArray<double,1>(nbData));
+        if (hasBounds)
+        {
+          list_boundslon.push_back(CArray<double,2>(nvertex, nbData));
+          list_boundslat.push_back(CArray<double,2>(nvertex, nbData));
+        }
+        CArray<double,1>& lon = list_lon.back();
+        CArray<double,1>& lat = list_lat.back();
+        const std::vector<size_t>& temp = it->second;
+        for (n = 0; n < nbData; ++n)
+        {
+          idx = static_cast<int>(it->second[n]);
+          int localInd = globalLocalIndexMap_[idx];
+          lon(n) = lonvalue(localInd);
+          lat(n) = latvalue(localInd);
+          if (hasBounds)
+          {
+            CArray<double,2>& boundslon = list_boundslon.back();
+            CArray<double,2>& boundslat = list_boundslat.back();
+            for (nv = 0; nv < nvertex; ++nv)
+            {
+              boundslon(nv, n) = bounds_lonvalue(nv, localInd);
+              boundslat(nv, n) = bounds_latvalue(nv, localInd);
+            }
+          }
+        }
+        list_msgsLon.push_back(CMessage());
+        list_msgsLat.push_back(CMessage());
+        list_msgsLon.back() << this->getId() << hasLonLat;
+        if (hasLonLat)
+          list_msgsLon.back() << list_lon.back();
+        list_msgsLon.back()  << hasBounds;
+        if (hasBounds)
+        {
+          list_msgsLon.back() << list_boundslon.back();
+        }
+        list_msgsLat.back() << this->getId() << hasLonLat;
+        if (hasLonLat)
+          list_msgsLat.back() << list_lat.back();
+        list_msgsLat.back() << hasBounds;
+        if (hasBounds)
+        {
+          list_msgsLat.back() << list_boundslat.back();
+        }
+        eventLon.push(rank, nbSenders[serverSize][rank], list_msgsLon.back());
+        eventLat.push(rank, nbSenders[serverSize][rank], list_msgsLat.back());
+      }
+      client->sendEvent(eventLon);
+      client->sendEvent(eventLat);
+    }
+    string domainId;
+    int phasis ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> domainId >> phasis ;
+    get(domainId)->receivedDomainDistribution(event, phasis);
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Send data index to corresponding connected clients.
+    Data index can be compressed however, we always send decompressed data index
+    and they will be compressed on receiving.
+    The compressed index are represented with 1 and others are represented with -1
+  */
+  void CDomain::sendDataIndex()
+  CATCH
+  void CDomain::receivedDomainDistribution(CEventServer& event, int phasis)
   TRY
+  {
+    int ns, n, i, j, ind, nv, idx;
+    std::list<CContextClient*>::iterator it;
+    for (it=clients.begin(); it!=clients.end(); ++it)
+    CContext* context = CContext::getCurrent();
+    if (phasis==0) // receive the remote element to construct the full view
+    {
+      CContextClient* client = *it;
+      int serverSize = client->serverSize;
+      // send area for each connected server
+      CEventClient eventDataIndex(getType(), EVENT_ID_DATA_INDEX);
+      list<CMessage> list_msgsDataIndex;
+      list<CArray<int,1> > list_data_i_index, list_data_j_index;
+      int nbIndex = i_index.numElements();
+      int niByIndex = max(i_index) - min(i_index) + 1;
+      int njByIndex = max(j_index) - min(j_index) + 1;
+      int dataIindexBound = (1 == data_dim) ? (niByIndex * njByIndex) : niByIndex;
+      int dataJindexBound = (1 == data_dim) ? (niByIndex * njByIndex) : njByIndex;
+      CArray<int,1> dataIIndex(nbIndex), dataJIndex(nbIndex);
+      dataIIndex = -1;
+      dataJIndex = -1;
+      ind = 0;
+      for (idx = 0; idx < data_i_index.numElements(); ++idx)
+      {
+        int dataIidx = data_i_index(idx) + data_ibegin;
+        int dataJidx = data_j_index(idx) + data_jbegin;
+        if ((0 <= dataIidx) && (dataIidx < dataIindexBound) &&
+            (0 <= dataJidx) && (dataJidx < dataJindexBound))
+        {
+          dataIIndex((1 == data_dim) ? dataIidx : dataJidx * ni + dataIidx) = 1; //i_index(dataIidx);//dataIidx;
+          dataJIndex((1 == data_dim) ? dataIidx : dataJidx * ni + dataIidx) = 1; //j_index(dataJidx);//
+        }
+      }
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      iteMap = indSrv_[serverSize].end();
+      for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
+      {
+        int nbData = 0;
+        int rank = connectedServerRank_[serverSize][k];
+        it = indSrv_[serverSize].find(rank);
+        if (iteMap != it)
+          nbData = it->second.size();
+        list_data_i_index.push_back(CArray<int,1>(nbData));
+        list_data_j_index.push_back(CArray<int,1>(nbData));
+        const std::vector<size_t>& temp = it->second;
+        for (n = 0; n < nbData; ++n)
+        {
+          idx = static_cast<int>(it->second[n]);
+          i = globalLocalIndexMap_[idx];
+          list_data_i_index.back()(n) = dataIIndex(i);
+          list_data_j_index.back()(n) = dataJIndex(i);
+        }
+        list_msgsDataIndex.push_back(CMessage());
+        list_msgsDataIndex.back() << this->getId();
+        list_msgsDataIndex.back() << list_data_i_index.back() << list_data_j_index.back();
+        eventDataIndex.push(rank, nbSenders[serverSize][rank], list_msgsDataIndex.back());
+      }
+      client->sendEvent(eventDataIndex);
+      localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ;
+      localElement_->addFullView() ;
+      // construct the local dimension and indexes
+      auto& globalIndex=localElement_->getGlobalIndex() ;
+      int nij=globalIndex.numElements() ;
+      int minI=ni_glo,maxI=-1,minJ=nj_glo,maxJ=-1 ;
+      int i,j ;
+      int niGlo=ni_glo, njGlo=njGlo ;
+      for(int ij=0;ij<nij;ij++)
+      {
+        j=globalIndex(ij)/niGlo ;
+        i=globalIndex(ij)%niGlo ;
+        if (i<minI) minI=i ;
+        if (i>maxI) maxI=i ;
+        if (j<minJ) minJ=j ;
+        if (j>maxJ) maxJ=j ;
+      }
+      if (maxI>=minI) { ibegin=minI ; ni=maxI-minI+1 ; }
+      else {ibegin=0; ni=0 ;}
+      if (maxJ>=minJ) { jbegin=minJ ; nj=maxJ-minJ+1 ; }
+      else {jbegin=0; nj=0 ;}
+    }
+    else if (phasis==1) // receive the sent view from client to construct the full distributed full view on server
+    {
+      CContext* context = CContext::getCurrent();
+      CDistributedElement* elementFrom = new  CDistributedElement(event) ;
+      elementFrom->addFullView() ;
+      gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+      gathererConnector_->computeConnector() ;
+    }
+    else if (phasis==2)
+    {
+//      delete gathererConnector_ ;
+      elementFrom_ = new  CDistributedElement(event) ;
+      elementFrom_->addFullView() ;
+//      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+//      gathererConnector_ -> computeConnector() ;
+    }
+  }
   CATCH
+  void CDomain::setServerMask(CArray<bool,1>& serverMask, CContextClient* client)
+  TRY
+  {
+    // nota : the client is needed to get the remote size for the scatterer connector. Maybe it is not the good place for this
+    // Later, server to client connector can be computed on demand, with "client" as argument
+    CContext* context = CContext::getCurrent();
+    localElement_->addView(CElementView::WORKFLOW, serverMask) ;
+    mask_1d.reference(serverMask.copy()) ;
+    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
+    serverFromClientConnector_->computeConnector() ;
+    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL),
+                                                       context->getIntraComm(), client->getRemoteSize()) ;
+    serverToClientConnector_->computeConnector() ;
+  }
+  CATCH_DUMP_ATTR
+  void CDomain::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector,  const string& domainId)
+  {
+    string serverDomainId = domainId.empty() ? this->getId() : domainId ;
+    CContext* context = CContext::getCurrent();
+    if (hasLonLat)
+    {
+      { // send longitude
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverDomainId<<string("lon") ;
+        scattererConnector.transfer(lonvalue, client, event,message) ;
+      }
+      { // send latitude
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverDomainId<<string("lat") ;
+        scattererConnector.transfer(latvalue, client, event, message) ;
+      }
+    }
+    if (hasBounds)
+    {
+      { // send longitude boudaries
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverDomainId<<string("boundslon") ;
+        scattererConnector.transfer(nvertex, bounds_lonvalue, client, event, message ) ;
+      }
+      { // send latitude boudaries
+        CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+        CMessage message ;
+        message<<serverDomainId<<string("boundslat") ;
+        scattererConnector.transfer(nvertex, bounds_latvalue, client, event, message ) ;
+      }
+    }
+    if (hasArea)
+    {  // send area
+      CEventClient event(getType(), EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE);
+      CMessage message ;
+      message<<serverDomainId<<string("area") ;
+      scattererConnector.transfer(areavalue, client, event,message) ;
+    }
+  }
+  void CDomain::recvDistributedAttributes(CEventServer& event)
+  TRY
+  {
+    string domainId;
+    string type ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> domainId >> type ;
+    get(domainId)->recvDistributedAttributes(event, type);
+  }
+  CATCH
+  void CDomain::recvDistributedAttributes(CEventServer& event, const string& type)
+  TRY
+  {
+    if (type=="lon")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, value, 0.);
+      lonvalue_2d.resize(ni,nj) ;
+      if (lonvalue_2d.numElements()>0) lonvalue_2d=CArray<double,2>(value.dataFirst(),shape(ni,nj),neverDeleteData) ;
+    }
+    else if (type=="lat")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, value, 0.);
+      latvalue_2d.resize(ni,nj) ;
+      if (latvalue_2d.numElements()>0) latvalue_2d=CArray<double,2>(value.dataFirst(),shape(ni,nj),neverDeleteData) ;
+    }
+    else if (type=="boundslon")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, nvertex, value, 0.);
+      bounds_lon_2d.resize(nvertex,ni,nj) ;
+      if (bounds_lon_2d.numElements()>0) bounds_lon_2d=CArray<double,3>(value.dataFirst(),shape(nvertex,ni,nj),neverDeleteData) ;
+    }
+    else if (type=="boundslat")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, nvertex, value, 0.);
+      bounds_lat_2d.resize(nvertex,ni,nj) ;
+      if (bounds_lat_2d.numElements()>0) bounds_lat_2d=CArray<double,3>(value.dataFirst(),shape(nvertex,ni,nj),neverDeleteData) ;
+    }
+    else if (type=="area")
+    {
+      CArray<double,1> value ;
+      gathererConnector_->transfer(event, value, 0.);
+      area.resize(ni,nj) ;
+      if (area.numElements()>0) area=CArray<double,2>(value.dataFirst(),shape(ni,nj),neverDeleteData) ;
+    }
+  }
+  CATCH
   bool CDomain::dispatchEvent(CEventServer& event)
   TRY
 …
       switch(event.type)
+      {
         case EVENT_ID_SERVER_ATTRIBUT:
           recvDistributionAttributes(event);
+        case EVENT_ID_DOMAIN_DISTRIBUTION:
+          recvDomainDistribution(event);
           return true;
           break;
+        case EVENT_ID_INDEX:
+          recvIndex(event);
+          return true;
+          break;
+        case EVENT_ID_LON:
+          recvLon(event);
+          return true;
+          break;
+        case EVENT_ID_LAT:
+          recvLat(event);
+          return true;
+          break;
+        case EVENT_ID_AREA:
+          recvArea(event);
+        case EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE:
+          recvDistributedAttributes(event);
           return true;
           break;
-        case EVENT_ID_DATA_INDEX:
-          recvDataIndex(event);
-          return true;
-          break;
         default:
           ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
 …
   CATCH
+  /*!
+    Receive index event from clients(s)
+    \param[in] event event contain info about rank and associated index
+  */
+  void CDomain::recvIndex(CEventServer& event)
+  TRY
+  {
+    string domainId;
+    std::map<int, CBufferIn*> rankBuffers;
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      *buffer >> domainId;
+      rankBuffers[it->rank] = buffer;
+    }
+    get(domainId)->recvIndex(rankBuffers);
+  }
+  CATCH
+  /*!
+    Receive index information from client(s). We use the global index for mapping index between
+    sending clients and receiving clients.
+    \param[in] rankBuffers rank of sending client and the corresponding receive buffer
+  */
+  void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers)
+  TRY
+  {
+    int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex;
+    recvClientRanks_.resize(nbReceived);
+    std::map<int, CBufferIn*>::iterator it = rankBuffers.begin(), ite = rankBuffers.end();
+    ind = 0;
+    for (ind = 0; it != ite; ++it, ++ind)
+    {
+       recvClientRanks_[ind] = it->first;
+       CBufferIn& buffer = *(it->second);
+       buffer >> type_int >> isCurvilinear >> indGlob_[it->first];
+       type.setValue((type_attr::t_enum)type_int); // probleme des type enum avec les buffers : ToFix
+    }
+    int nbIndGlob = 0;
+    for (i = 0; i < nbReceived; ++i)
+    {
+      nbIndGlob += indGlob_[recvClientRanks_[i]].numElements();
+    }
+    globalLocalIndexMap_.rehash(std::ceil(nbIndGlob/globalLocalIndexMap_.max_load_factor()));
+    i_index.resize(nbIndGlob);
+    j_index.resize(nbIndGlob);
+    int nbIndexGlobMax = nbIndGlob, nbIndLoc;
+    nbIndGlob = 0;
+    for (i = 0; i < nbReceived; ++i)
+    {
+      CArray<int,1>& tmp = indGlob_[recvClientRanks_[i]];
+      for (ind = 0; ind < tmp.numElements(); ++ind)
+      {
+         index = tmp(ind);
+         if (0 == globalLocalIndexMap_.count(index))
+         {
+           iIndex = (index%ni_glo)-ibegin;
+           iIndex = (iIndex < 0) ? 0 : iIndex;
+           jIndex = (index/ni_glo)-jbegin;
+           jIndex = (jIndex < 0) ? 0 : jIndex;
+           nbIndLoc = iIndex + ni * jIndex;
+           i_index(nbIndGlob) = index % ni_glo;
+           j_index(nbIndGlob) = index / ni_glo;
+           globalLocalIndexMap_[index] = nbIndGlob;
+           ++nbIndGlob;
+         }
+      }
+    }
+    if (nbIndGlob==0)
+    {
+      i_index.resize(nbIndGlob);
+      j_index.resize(nbIndGlob);
+    }
+    else
+    {
+      i_index.resizeAndPreserve(nbIndGlob);
+      j_index.resizeAndPreserve(nbIndGlob);
+    }
+    domainMask.resize(0); // Mask is not defined anymore on servers
+  }
+  CATCH
+  /*!
+    Receive attributes event from clients(s)
+    \param[in] event event contain info about rank and associated attributes
+  */
+  void CDomain::recvDistributionAttributes(CEventServer& event)
+  TRY
+  {
+    CBufferIn* buffer=event.subEvents.begin()->buffer;
+    string domainId ;
+    *buffer>>domainId ;
+    get(domainId)->recvDistributionAttributes(*buffer);
+  }
+  CATCH
+  /*!
+    Receive attributes from client(s)
+    \param[in] rank rank of client source
+    \param[in] buffer message containing attributes info
+  */
+  void CDomain::recvDistributionAttributes(CBufferIn& buffer)
+  TRY
+  {
+    int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp;
+    int ni_glo_tmp, nj_glo_tmp;
+    buffer >> isUnstructed_ >> ni_tmp >> ibegin_tmp >> nj_tmp >> jbegin_tmp
+           >> ni_glo_tmp >> nj_glo_tmp
+           >> isCompressible_;
+    ni.setValue(ni_tmp);
+    ibegin.setValue(ibegin_tmp);
+    nj.setValue(nj_tmp);
+    jbegin.setValue(jbegin_tmp);
+    ni_glo.setValue(ni_glo_tmp);
+    nj_glo.setValue(nj_glo_tmp);
+  }
+ CATCH_DUMP_ATTR
+  /*!
+    Receive longitude event from clients(s)
+    \param[in] event event contain info about rank and associated longitude
+  */
+  void CDomain::recvLon(CEventServer& event)
+  TRY
+  {
+    string domainId;
+    std::map<int, CBufferIn*> rankBuffers;
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      *buffer >> domainId;
+      rankBuffers[it->rank] = buffer;
+    }
+    get(domainId)->recvLon(rankBuffers);
+  }
+  CATCH
+  /*!
+    Receive longitude information from client(s)
+    \param[in] rankBuffers rank of sending client and the corresponding receive buffer
+  */
+  void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)
+  TRY
+  {
+    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
+    if (nbReceived != recvClientRanks_.size())
+      ERROR("void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers)",
+           << "The number of sending clients is not correct."
+           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived);
+    vector<CArray<double,1> > recvLonValue(nbReceived);
+    vector<CArray<double,2> > recvBoundsLonValue(nbReceived);
+    for (i = 0; i < recvClientRanks_.size(); ++i)
+    {
+      int rank = recvClientRanks_[i];
+      CBufferIn& buffer = *(rankBuffers[rank]);
+      buffer >> hasLonLat;
+      if (hasLonLat)
+        buffer >> recvLonValue[i];
+      buffer >> hasBounds;
+      if (hasBounds)
+        buffer >> recvBoundsLonValue[i];
+    }
+    if (hasLonLat)
+    {
+      int nbLonInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        nbLonInd += recvLonValue[i].numElements();
+      }
+      if (nbLonInd != globalLocalIndexMap_.size())
+        info (0) << "If domain " << this->getDomainOutputName() <<" does not have overlapped regions between processes "
+                 << "something must be wrong with longitude index "<< std::endl;
+      nbLonInd = globalLocalIndexMap_.size();
+      lonvalue.resize(nbLonInd);
+      if (hasBounds)
+      {
+        bounds_lonvalue.resize(nvertex,nbLonInd);
+        bounds_lonvalue = 0.;
+      }
+      nbLonInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]];
+        CArray<double,1>& tmp = recvLonValue[i];
+        for (ind = 0; ind < tmp.numElements(); ++ind)
+        {
+          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
+          lonvalue(lInd) = tmp(ind);
+           if (hasBounds)
+           {
+            for (int nv = 0; nv < nvertex; ++nv)
+              bounds_lonvalue(nv, lInd) = recvBoundsLonValue[i](nv, ind);
+           }
+        }
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Receive latitude event from clients(s)
+    \param[in] event event contain info about rank and associated latitude
+  */
+  void CDomain::recvLat(CEventServer& event)
+  TRY
+  {
+    string domainId;
+    std::map<int, CBufferIn*> rankBuffers;
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      *buffer >> domainId;
+      rankBuffers[it->rank] = buffer;
+    }
+    get(domainId)->recvLat(rankBuffers);
+  }
+  CATCH
+  /*!
+    Receive latitude information from client(s)
+    \param[in] rankBuffers rank of sending client and the corresponding receive buffer
+  */
+  void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)
+  TRY
+  {
+    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd;
+    if (nbReceived != recvClientRanks_.size())
+      ERROR("void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers)",
+           << "The number of sending clients is not correct."
+           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived);
+    vector<CArray<double,1> > recvLatValue(nbReceived);
+    vector<CArray<double,2> > recvBoundsLatValue(nbReceived);
+    for (i = 0; i < recvClientRanks_.size(); ++i)
+    {
+      int rank = recvClientRanks_[i];
+      CBufferIn& buffer = *(rankBuffers[rank]);
+      buffer >> hasLonLat;
+      if (hasLonLat)
+        buffer >> recvLatValue[i];
+      buffer >> hasBounds;
+      if (hasBounds)
+        buffer >> recvBoundsLatValue[i];
+    }
+    if (hasLonLat)
+    {
+      int nbLatInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        nbLatInd += recvLatValue[i].numElements();
+      }
+      if (nbLatInd != globalLocalIndexMap_.size())
+        info (0) << "If domain " << this->getDomainOutputName() <<" does not have overlapped regions between processes "
+                << "something must be wrong with latitude index "<< std::endl;
+      nbLatInd = globalLocalIndexMap_.size();
+      latvalue.resize(nbLatInd);
+      if (hasBounds)
+      {
+        bounds_latvalue.resize(nvertex,nbLatInd);
+        bounds_latvalue = 0. ;
+      }
+      nbLatInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]];
+        CArray<double,1>& tmp = recvLatValue[i];
+        for (ind = 0; ind < tmp.numElements(); ++ind)
+        {
+          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
+          latvalue(lInd) = tmp(ind);
+           if (hasBounds)
+           {
+            CArray<double,2>& boundslat = recvBoundsLatValue[i];
+            for (int nv = 0; nv < nvertex; ++nv)
+              bounds_latvalue(nv, lInd) = boundslat(nv, ind);
+           }
+          ++nbLatInd;
+        }
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Receive area event from clients(s)
+    \param[in] event event contain info about rank and associated area
+  */
+  void CDomain::recvArea(CEventServer& event)
+  TRY
+  {
+    string domainId;
+    std::map<int, CBufferIn*> rankBuffers;
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      *buffer >> domainId;
+      rankBuffers[it->rank] = buffer;
+    }
+    get(domainId)->recvArea(rankBuffers);
+  }
+  CATCH
+  /*!
+    Receive area information from client(s)
+    \param[in] rankBuffers rank of sending client and the corresponding receive buffer
+  */
+  void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)
+  TRY
+  {
+    int nbReceived = rankBuffers.size(), i, ind, index, lInd;
+    if (nbReceived != recvClientRanks_.size())
+      ERROR("void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers)",
+           << "The number of sending clients is not correct."
+           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived);
+    vector<CArray<double,1> > recvAreaValue(nbReceived);
+    for (i = 0; i < recvClientRanks_.size(); ++i)
+    {
+      int rank = recvClientRanks_[i];
+      CBufferIn& buffer = *(rankBuffers[rank]);
+      buffer >> hasArea;
+      if (hasArea)
+        buffer >> recvAreaValue[i];
+    }
+    if (hasArea)
+    {
+      int nbAreaInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        nbAreaInd += recvAreaValue[i].numElements();
+      }
+      if (nbAreaInd != globalLocalIndexMap_.size())
+        info (0) << "If domain " << this->getDomainOutputName() <<" does not have overlapped regions between processes "
+                 << "something must be wrong with area index "<< std::endl;
+      nbAreaInd = globalLocalIndexMap_.size();
+      areavalue.resize(nbAreaInd);
+      nbAreaInd = 0;
+      for (i = 0; i < nbReceived; ++i)
+      {
+        CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]];
+        CArray<double,1>& tmp = recvAreaValue[i];
+        for (ind = 0; ind < tmp.numElements(); ++ind)
+        {
+          lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
+          areavalue(lInd) = tmp(ind);
+        }
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
   /*!
     Compare two domain objects.
 …
   CATCH_DUMP_ATTR
+  /*!
+    Receive data index event from clients(s)
+    \param[in] event event contain info about rank and associated index
+  */
+  void CDomain::recvDataIndex(CEventServer& event)
+/////////////////////////////////////////////////////////////////////////
+///////////////             TRANSFORMATIONS                    //////////
+/////////////////////////////////////////////////////////////////////////
+  std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>();
+  bool CDomain::dummyTransformationMapList_ = CDomain::initializeTransformationMap(CDomain::transformationMapList_);
+  bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
   TRY
+  {
+    string domainId;
+    std::map<int, CBufferIn*> rankBuffers;
+    list<CEventServer::SSubEvent>::iterator it;
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      CBufferIn* buffer = it->buffer;
+      *buffer >> domainId;
+      rankBuffers[it->rank] = buffer;
+    }
+    get(domainId)->recvDataIndex(rankBuffers);
+    m["zoom_domain"] = TRANS_ZOOM_DOMAIN;
+    m["interpolate_domain"] = TRANS_INTERPOLATE_DOMAIN;
+    m["generate_rectilinear_domain"] = TRANS_GENERATE_RECTILINEAR_DOMAIN;
+    m["compute_connectivity_domain"] = TRANS_COMPUTE_CONNECTIVITY_DOMAIN;
+    m["expand_domain"] = TRANS_EXPAND_DOMAIN;
+    m["reorder_domain"] = TRANS_REORDER_DOMAIN;
+    m["extract_domain"] = TRANS_EXTRACT_DOMAIN;
+  }
   CATCH
-  /*!
-    Receive data index information from client(s)
-    A client receives data index from different clients to rebuild its own data index.
-    Because we use global index + mask info to calculate the sending data to client(s),
-    this data index must be updated with mask info (maybe it will change in the future)
-    Because the data index is local, to rebuild data index of received client, we should use global index along with.
-    \param[in] rankBuffers rank of sending client and the corresponding receive buffer
-  */
-  void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)
-  TRY
+  {
-    int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;
-    if (nbReceived != recvClientRanks_.size())
-      ERROR("void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)",
-           << "The number of sending clients is not correct."
-           << "Expected number: " << recvClientRanks_.size() << " but received " << nbReceived);
-    vector<CArray<int,1> > recvDataIIndex(nbReceived),recvDataJIndex(nbReceived);
-    for (i = 0; i < recvClientRanks_.size(); ++i)
+    {
-      int rank = recvClientRanks_[i];
-      CBufferIn& buffer = *(rankBuffers[rank]);
-      buffer >> recvDataIIndex[i];
-      buffer >> recvDataJIndex[i];
+    }
-    int nbIndex = i_index.numElements();
-    CArray<int,1> dataIIndex(nbIndex), dataJIndex(nbIndex);
-    dataIIndex = -1; dataJIndex = -1;
-    nbIndex = 0;
-    for (i = 0; i < nbReceived; ++i)
+    {
-      CArray<int,1>& tmpInd = indGlob_[recvClientRanks_[i]];
-      CArray<int,1>& tmpI = recvDataIIndex[i];
-      CArray<int,1>& tmpJ = recvDataJIndex[i];
-      if ((tmpI.numElements() != tmpInd.numElements()) || (tmpJ.numElements() != tmpInd.numElements()))
-          ERROR("void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers)",
-             << "The number of global received index is not coherent with the number of received data index."
-             << "Expected number of global index: " << tmpI.numElements() << " but received " << tmpInd.numElements());
-      for (ind = 0; ind < tmpI.numElements(); ++ind)
+      {
-         lInd = globalLocalIndexMap_[size_t(tmpInd(ind))];
-         dataIIndex(lInd) = (-1 == dataIIndex(lInd)) ? tmpI(ind) : dataIIndex(lInd); // Only fill in dataIndex if there is no data
-         dataJIndex(lInd) = (-1 == dataJIndex(lInd)) ? tmpJ(ind) : dataJIndex(lInd);
+      }
+    }
-    int nbCompressedData = 0;
-    for (ind = 0; ind < dataIIndex.numElements(); ++ind)
+    {
-       indexI = dataIIndex(ind); indexJ = dataJIndex(ind);
-       if ((0 <= indexI) && (0 <= indexJ))
-         ++nbCompressedData;
+    }
-    data_i_index.resize(nbCompressedData);
-    data_j_index.resize(nbCompressedData);
-    nbCompressedData = 0;
-    for (ind = 0; ind < dataIIndex.numElements(); ++ind)
+    {
-       indexI = dataIIndex(ind); indexJ = dataJIndex(ind);
-       if ((0 <= indexI) && (0 <= indexJ))
+       {
-          data_i_index(nbCompressedData) = (1 == data_dim) ? ind : ind % ni;
-          data_j_index(nbCompressedData) = (1 == data_dim) ? 0   : ind / ni;
-         ++nbCompressedData;
+       }
+    }
-    // Reset data_ibegin, data_jbegin
-    data_ibegin.setValue(0);
-    data_jbegin.setValue(0);
+  }
-  CATCH_DUMP_ATTR
   CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id)
 …
   CATCH_DUMP_ATTR
+  CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, CTransformation<CDomain>* transformation)
+  TRY
+  {
+    transformationMap_.push_back(std::make_pair(transType, transformation));
+    return transformationMap_.back().second;
+  }
+  CATCH_DUMP_ATTR
   /*!
     Check whether a domain has transformation
 …
+  }
   CATCH_DUMP_ATTR
   /*!
    * Go through the hierarchy to find the domain from which the transformations must be inherited
    */
   void CDomain::solveInheritanceTransformation()
+  void CDomain::solveInheritanceTransformation_old()
   TRY
+  {
 …
+  }
   CATCH_DUMP_ATTR
+  void CDomain::solveInheritanceTransformation()
+  TRY
+  {
+    if (solveInheritanceTransformation_done_) return;
+    else solveInheritanceTransformation_done_=true ;
+    CDomain* domain = this;
+    CDomain* Lastdomain ;
+    std::list<CDomain*> refDomains;
+    bool out=false ;
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("domain_ref");
+    refDomains.push_front(domain) ;
+    while (domain->hasDirectDomainReference() && !out)
+    {
+      CDomain* lastDomain=domain ;
+      domain = domain->getDirectDomainReference();
+      domain->solveRefInheritance() ;
+      if (!domain->SuperClass::isEqual(lastDomain,excludedAttr)) out=true ;
+      refDomains.push_front(domain) ;
+    }
+    CTransformationPaths::TPath path ;
+    auto& pathList = std::get<2>(path) ;
+    std::get<0>(path) = EElement::DOMAIN ;
+    std::get<1>(path) = refDomains.front()->getId() ;
+    for (auto& domain : refDomains)
+    {
+      CDomain::TransMapTypes transformations = domain->getAllTransformations();
+      for(auto& transformation : transformations) pathList.push_back({transformation.second->getTransformationType(),
+                                                                      transformation.second->getId()}) ;
+    }
+    transformationPaths_.addPath(path) ;
+  }
+  CATCH_DUMP_ATTR
+/////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////
   void CDomain::setContextClient(CContextClient* contextClient)

XIOS/dev/dev_trunk_graph/src/node/domain.hpp

-                      r1600
+                      r2019
 #include "transformation.hpp"
 #include "transformation_enum.hpp"
+#include "transformation_path.hpp"
 #include "server_distribution_description.hpp"
 #include "mesh.hpp"
+namespace xios {
+#include "element.hpp"
+#include "local_connector.hpp"
+#include "scatterer_connector.hpp"
+#include "gatherer_connector.hpp"
+#include "distribution_type.hpp"
+#include "generic_algorithm_transformation.hpp"
+namespace xios
+{
    /// ////////////////////// DÃ©clarations ////////////////////// ///
 …
          enum EEventId
+         {
+           EVENT_ID_INDEX, EVENT_ID_LON, EVENT_ID_LAT,
+           EVENT_ID_AREA,
+           EVENT_ID_DATA_INDEX, EVENT_ID_SERVER_ATTRIBUT
+           EVENT_ID_DOMAIN_DISTRIBUTION, EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE
          } ;
 …
          typedef CDomainAttributes RelAttributes;
          typedef CDomainGroup      RelGroup;
+         typedef CTransformation<CDomain>::TransformationMapTypes TransMapTypes;
          /// Constructeurs ///
          CDomain(void);
 …
          /// VÃ©rifications ///
          void checkAttributes(void);
+         void checkAttributesOnClient();
+         void checkAttributesOnClientAfterTransformation();
+         void checkEligibilityForCompressedOutput(void);
+         void sendCheckedAttributes();
+         bool hasTransformation();
+         void solveInheritanceTransformation();
+         TransMapTypes getAllTransformations();
+         bool checkAttributes_done_ = false ;
+      //////////////////////////
+      ///// transformations ////
+      //////////////////////////
+      public:
+        typedef CTransformation<CDomain>::TransformationMapTypes TransMapTypes;
+      private:
+        static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+        static std::map<StdString, ETranformationType> transformationMapList_;
+        static bool dummyTransformationMapList_;
+        TransMapTypes transformationMap_;
+      public:
+        CTransformation<CDomain>* addTransformation(ETranformationType transType, const StdString& id="");
+        CTransformation<CDomain>* addTransformation(ETranformationType transType, CTransformation<CDomain>* transformation) ;
+        void setTransformations(const TransMapTypes&);
+        void duplicateTransformation(CDomain*);
+        TransMapTypes getAllTransformations();
+        bool hasTransformation();
+        void solveInheritanceTransformation_old(); // to remove later
+        void solveInheritanceTransformation();
+      private:
+        bool solveInheritanceTransformation_done_= false ;
+      private:
+        CGenericAlgorithmTransformation* transformationAlgorithm_ = nullptr ;
+      public:
+        void setTransformationAlgorithm(CGenericAlgorithmTransformation* transformationAlgorithm) { transformationAlgorithm_=transformationAlgorithm ;}
+        CGenericAlgorithmTransformation* getTransformationAlgorithm(void) { return transformationAlgorithm_ ;}
+      private:
+        CTransformationPaths transformationPaths_ ;
+      public:
+        CTransformationPaths getTransformationPaths(void) {return transformationPaths_;}
+        void setTransformationPaths(const CTransformationPaths& transformationPaths) { transformationPaths_=transformationPaths ;}
+      ////////////////////////////
          void redistribute(int nbLocalDomain);
-         void duplicateTransformation(CDomain*);
-         CTransformation<CDomain>* addTransformation(ETranformationType transType, const StdString& id="");
       public:
 …
          bool isWrittenCompressed(const StdString& filename) const;
-         int getNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getTotalNumberWrittenIndexes(MPI_Comm writtenCom);
-         int getOffsetWrittenIndexes(MPI_Comm writtenCom);
-         CArray<int,1>& getCompressedIndexToWriteOnServer(MPI_Comm writtenCom);
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
          bool isEmpty(void) const;
          bool isDistributed(void) const;
+         bool isCompressible(void) const;
+         std::vector<int> getNbGlob();
+        public :
+         /*!
+            \brief return if the domain can be written or not in a compressed way.
+            ie if there are some masked or indexed point on the domain. Valid only on server side.
+            \return true if domain can be writtedn in a compressed way
+         */
+         bool isCompressible(void) { if (!isCompressibleComputed_) computeIsCompressible() ; return isCompressible_ ;}
+        private :
+         bool isCompressible_ ; /** specify if the domain can be written in a compressed way */
+         bool isCompressibleComputed_=false ; /** Indicate if compressability has been computed*/
+         void computeIsCompressible() ;
+      public :
          bool isEqual(CDomain* domain);
          static bool dispatchEvent(CEventServer& event);
+      private:
+         /** define if the domain is completed or not ie all attributes have been received before in case
+             of grid reading from file or coupling */
+         bool isCompleted_=true ;
+      public:
+        /*!
+           \brief Check if a domain is completed
+           Before make any domain processing, we must be sure that all domain informations have
+           been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+           other context (coupling). So all direct reference of the domain (domain_ref) must be also completed
+           \return true if domain and domain reference are completed
+          */
+         bool isCompleted(void)
+         {
+           if (hasDirectDomainReference()) if (!getDirectDomainReference()->isCompleted()) return false;
+           else return isCompleted_ ;
+         }
+         void setCompleted(void) { isCompleted_=true ; }
+         void unsetCompleted(void) { isCompleted_=false ; }
       public:
 …
          void addRelFileCompressed(const StdString& filename);
-         void computeWrittenIndex();
-         void computeWrittenCompressedIndex(MPI_Comm);
          void AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat,
                                          CArray<double,1>& lon_g, CArray<double,1>& lat_g);
 …
          CArray<double, 1> areavalue;
-         CArray<int,1> localIndexToWriteOnServer;
          CArray<bool, 1> domainMask; // mask_1d, mask_2d -> domainMask
 …
          void computeLocalMask(void) ;
+         /** The number of server of a context client. Avoid to re-compute indice computed in a previous computeConnectedClient */
+         private: std::set<int> listNbServer_ ;
       private:
          void checkDomain(void);
 …
          void checkArea(void);
          void checkLonLat();
+         void setTransformations(const TransMapTypes&);
+         void computeNGlobDomain();
+         void sendAttributes();
+         void sendIndex();
+         void sendDistributionAttributes();
+         void sendArea();
+         void sendLonLat();
+         void sendDataIndex();
+       public:
+         void sendDomainToFileServer(CContextClient* client) ;
+       private:
+         std::set<CContextClient*> sendDomainToFileServer_done_ ;
+       public:
+         void sendDomainToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) ;
+       private:
+         std::set<CContextClient*> sendDomainToCouplerOut_done_ ;
+       public:
+        void makeAliasForCoupling(const string& fieldId, int posInGrid) ;
+       private:
          void convertLonLatValue();
          void fillInRectilinearLonLat();
          void fillInCurvilinearLonLat();
          void fillInUnstructuredLonLat();
-         static void recvDistributionAttributes(CEventServer& event);
-         static void recvIndex(CEventServer& event);
-         static void recvLon(CEventServer& event);
-         static void recvLat(CEventServer& event);
-         static void recvArea(CEventServer& event);
-         static void recvDataIndex(CEventServer& event);
-         void recvDistributionAttributes(CBufferIn& buffer);
-         void recvIndex(std::map<int, CBufferIn*>& rankBuffers);
-         void recvLon(std::map<int, CBufferIn*>& rankBuffers);
-         void recvLat(std::map<int, CBufferIn*>& rankBuffers);
-         void recvArea(std::map<int, CBufferIn*>& rankBuffers);
-         void recvDataIndex(std::map<int, CBufferIn*>& rankBuffers);
          void completeLonLatClient(void);
          void computeConnectedClients();
        private:
 …
          std::set<CContextClient*> clientsSet;
          bool isChecked, computedWrittenIndex_;
+         bool isChecked ;
          std::set<StdString> relFiles, relFilesCompressed;
+         bool isClientChecked; // Verify whether all attributes of domain on the client side are good
+         bool isClientAfterTransformationChecked;
          std::map<int, CArray<int,1> > indGlob_;
          std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server
 /** Global index of each client sent to server: map<serverSize, map<serverRank, indexes>> */
+/** only on client side : Global index of each client sent to server: map<serverSize, map<serverRank, indexes>>
+    indSrv_[nbServers] -->  first map is related to the server distribution (ie associated with the contextClient)
+    indSrv_[nbServers][server_rank] -> array of global index sent to the server of rank "server_rank"
+    indSrv_[nbServers][server_rank](ind) --> global index on server of the local element "ind" sent (for lon, lat, mask, etc...)
+*/
          std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_;
+         // std::map<CContextClient*, std::map<int, vector<int> > > indWrittenSrv_; // Global written index of each client sent to server
+         std::vector<int> indexesToWrite;
+         std::vector<int> recvClientRanks_;
+         std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
+         std::map<int, CArray<int, 1> > compressedIndexToWriteOnServer;
+         std::map<int, std::map<int,size_t> > connectedDataSize_;
          std::map<int, std::vector<int> > connectedServerRank_;
-         //! True if and only if the data defined on the domain can be outputted in a compressed way
-         bool isCompressible_;
          bool isRedistributed_;
-         TransMapTypes transformationMap_;
          bool isUnstructed_;
+         std::unordered_map<size_t,size_t> globalLocalIndexMap_;
+       private:
+         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+         static std::map<StdString, ETranformationType> transformationMapList_;
+         static bool _dummyTransformationMapList;
+       //////////////////////////////////////////////////////////////////////////////////////
+       //  this part is related to distribution, element definition, views and connectors  //
+       //////////////////////////////////////////////////////////////////////////////////////
+       private:
+         CLocalElement* localElement_ = nullptr ;
+         void initializeLocalElement(void) ;
+       public:
+         CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; }
+         CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;}
+       private:
+         void addFullView(void) ;
+         void addWorkflowView(void) ;
+         void addModelView(void) ;
+       private:
+         CLocalConnector* modelToWorkflowConnector_ ;
+         void computeModelToWorkflowConnector(void)  ;
+       public:
+         CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;}
+       public:
+         void computeRemoteElement(CContextClient* client, EDistributionType) ;
+         void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector,
+                                 const string& domainId="") ;
+         static void recvDomainDistribution(CEventServer& event) ;
+         void receivedDomainDistribution(CEventServer& event, int phasis) ;
+         void sendDistributedAttributes(CContextClient* client, CScattererConnector& scaterrerConnector, const string& domainId) ;
+         static void recvDistributedAttributes(CEventServer& event) ;
+         void recvDistributedAttributes(CEventServer& event, const string& type) ;
+         void setServerMask(CArray<bool,1>& serverMask, CContextClient* client) ;
+       private:
+         map<CContextClient*, CDistributedElement*> remoteElement_ ;
+       public:
+         CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;}
+       private:
+         map<CContextClient*, CScattererConnector*> clientToServerConnector_ ;
+       public:
+         CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;}
+       private:
+         CGathererConnector*  gathererConnector_ ;
+       public:
+         CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;}
+        private:
+         CGathererConnector* serverFromClientConnector_ ;
+         CDistributedElement* elementFrom_ ;
+       public:
+         CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;}
+       private:
+         CScattererConnector*  serverToClientConnector_ = nullptr ;
+       public:
+         CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}
+       private:
+         map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ;
+       public:
+         CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}
          DECLARE_REF_FUNC(Domain,domain)

XIOS/dev/dev_trunk_graph/src/node/duplicate_scalar_to_axis.cpp

-                      r1314
+                      r2019
 #include "duplicate_scalar_to_axis.hpp"
+#include "axis_algorithm_duplicate_scalar.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CDuplicateScalarToAxis::registerTrans()
+  {
     return registerTransformation(TRANS_DUPLICATE_SCALAR_TO_AXIS, CDuplicateScalarToAxis::create);
+    return registerTransformation(TRANS_DUPLICATE_SCALAR_TO_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CDuplicateScalarToAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                         std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmDuplicateScalar::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/duplicate_scalar_to_axis.hpp

-                      r1314
+                      r2019
   class CAxis;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CDuplicateScalarToAxis> SuperClass;
       typedef CDuplicateScalarToAxisAttributes SuperClassAttribute;
+      typedef CDuplicateScalarToAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_DUPLICATE_SCALAR_TO_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/expand_domain.cpp

-                      r1158
+                      r2019
 #include "expand_domain.hpp"
+#include "domain_algorithm_expand.hpp"
 #include "type.hpp"
 …
   bool CExpandDomain::registerTrans()
+  {
     registerTransformation(TRANS_EXPAND_DOMAIN, CExpandDomain::create);
+    registerTransformation(TRANS_EXPAND_DOMAIN, {create, getTransformation});
+  }
 …
     if (this->type.isEmpty()) this->type.setValue(CExpandDomain::type_attr::edge);
+  }
+  CGenericAlgorithmTransformation* CExpandDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmExpand::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/expand_domain.hpp

-                      r935
+                      r2019
   class CExpandDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CExpandDomain> SuperClass;
       typedef CExpandDomainAttributes SuperClassAttribute;
+      typedef CExpandDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_EXPAND_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/extract_axis.cpp

-                      r1558
+                      r2019
 #include "extract_axis.hpp"
+#include "axis_algorithm_extract.hpp"
 #include "type.hpp"
 …
   bool CExtractAxis::registerTrans()
+  {
     return registerTransformation(TRANS_EXTRACT_AXIS, CExtractAxis::create);
+    return registerTransformation(TRANS_EXTRACT_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CExtractAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmExtract::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/extract_axis.hpp

-                      r1558
+                      r2019
   class CExtractAxis;
   class CAxis;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CExtractAxis> SuperClass;
       typedef CExtractAxisAttributes SuperClassAttribute;
+      typedef CExtractAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_EXTRACT_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/extract_axis_to_scalar.cpp

-                      r960
+                      r2019
 #include "extract_axis_to_scalar.hpp"
+#include "scalar_algorithm_extract_axis.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CExtractAxisToScalar::registerTrans()
+  {
     return registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, CExtractAxisToScalar::create);
+    return registerTransformation(TRANS_EXTRACT_AXIS_TO_SCALAR, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CExtractAxisToScalar::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CScalarAlgorithmExtractAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/extract_axis_to_scalar.hpp

-                      r960
+                      r2019
   class CAxis;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CExtractAxisToScalar> SuperClass;
       typedef CExtractAxisToScalarAttributes SuperClassAttribute;
+      typedef CExtractAxisToScalar MyClass ;
+      typedef CTransformation<CScalar> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_EXTRACT_AXIS_TO_SCALAR ;}
+      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/extract_domain.cpp

-                      r1549
+                      r2019
 #include "extract_domain.hpp"
+#include "domain_algorithm_extract.hpp"
 #include "type.hpp"
 …
   bool CExtractDomain::registerTrans()
+  {
     registerTransformation(TRANS_EXTRACT_DOMAIN, CExtractDomain::create);
+    registerTransformation(TRANS_EXTRACT_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CExtractDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmExtract::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/extract_domain.hpp

-                      r1549
+                      r2019
   class CExtractDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CExtractDomain> SuperClass;
       typedef CExtractDomainAttributes SuperClassAttribute;
+      typedef CExtractDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+    private:
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_EXTRACT_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
+     private:
       static bool registerTrans();
       static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
       static bool _dummyRegistered;
+     static bool _dummyRegistered;
   }; // class CExtractDomain

XIOS/dev/dev_trunk_graph/src/node/extract_domain_to_axis.cpp

-                      r980
+                      r2019
 #include "extract_domain_to_axis.hpp"
+#include "axis_algorithm_extract_domain.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CExtractDomainToAxis::registerTrans()
+  {
     return registerTransformation(TRANS_EXTRACT_DOMAIN_TO_AXIS, CExtractDomainToAxis::create);
+    return registerTransformation(TRANS_EXTRACT_DOMAIN_TO_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CExtractDomainToAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmExtractDomain::create(isSource, gridDst, gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/extract_domain_to_axis.hpp

-                      r895
+                      r2019
   class CAxis;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CExtractDomainToAxis> SuperClass;
       typedef CExtractDomainToAxisAttributes SuperClassAttribute;
+      typedef CExtractDomainToAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
       /// Constructeurs ///
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_EXTRACT_DOMAIN_TO_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/field.cpp

-                      r1688
+                      r2019
 #include <set>
 #include "garbage_collector.hpp"
-#include "source_filter.hpp"
-#include "store_filter.hpp"
-#include "file_writer_filter.hpp"
 #include "pass_through_filter.hpp"
 #include "filter_expr_node.hpp"
 #include "lex_parser.hpp"
 #include "temporal_filter.hpp"
+#include "spatial_transform_filter.hpp"
+#include "file_server_writer_filter.hpp"
+#include "workflow_graph.hpp"
+namespace xios{
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+   CField::CField(void)
+      : CObjectTemplate<CField>(), CFieldAttributes()
+      , grid(), file()
+      , written(false)
+      , nstep(0), nstepMax(0)
+      , hasOutputFile(false)
+      , domAxisScalarIds_(vector<StdString>(3,""))
+      , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
+      , isGridChecked(false)
+      , useCompressedOutput(false)
+      , hasTimeInstant(false)
+      , hasTimeCentered(false)
+      , wasDataRequestedFromServer(false)
+      , wasDataAlreadyReceivedFromServer(false)
+      , mustAutoTrigger(false)
+      , isEOF(false), nstepMaxRead(false)
+   { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group"));
+     field_graph_start = -2;
+     field_graph_end = -2;
+   }
+   CField::CField(const StdString& id)
+      : CObjectTemplate<CField>(id), CFieldAttributes()
+      , grid(), file()
+      , written(false)
+      , nstep(0), nstepMax(0)
+      , hasOutputFile(false)
+      , domAxisScalarIds_(vector<StdString>(3,""))
+      , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
+      , isGridChecked(false)
+      , useCompressedOutput(false)
+      , hasTimeInstant(false)
+      , hasTimeCentered(false)
+      , wasDataRequestedFromServer(false)
+      , wasDataAlreadyReceivedFromServer(false)
+      , mustAutoTrigger(false)
+      , isEOF(false), nstepMaxRead(false)
+   { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group"));
+     field_graph_start = -2;
+     field_graph_end = -2;
+   }
+   CField::~CField(void)
+   {}
+#include "server_from_client_source_filter.hpp"
+#include "file_reader_source_filter.hpp"
+#include "tracer.hpp"
+#include "graph_package.hpp"
+namespace xios
+{
+  /// ////////////////////// DÃ©finitions ////////////////////// ///
+  CField::CField(void)
+    : CObjectTemplate<CField>(), CFieldAttributes()
+    , written(false)
+    , hasOutputFile(false)
+    , domAxisScalarIds_(vector<StdString>(3,""))
+    , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
+    , isGridChecked(false)
+    , useCompressedOutput(false)
+    , hasTimeInstant(false)
+    , hasTimeCentered(false)
+    , mustAutoTrigger(false)
+  { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
+  CField::CField(const StdString& id)
+    : CObjectTemplate<CField>(id), CFieldAttributes()
+    , written(false)
+    , hasOutputFile(false)
+    , domAxisScalarIds_(vector<StdString>(3,""))
+    , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
+    , isGridChecked(false)
+    , useCompressedOutput(false)
+    , hasTimeInstant(false)
+    , hasTimeCentered(false)
+    , mustAutoTrigger(false)
+    { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
+  CField::~CField(void)
+  {}
   //----------------------------------------------------------------
    void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
    TRY
+   {
       this->vVariableGroup = newVVariableGroup;
+   }
    CATCH
    CVariableGroup* CField::getVirtualVariableGroup(void) const
    TRY
+   {
       return this->vVariableGroup;
+   }
    CATCH
    std::vector<CVariable*> CField::getAllVariables(void) const
    TRY
+   {
       return this->vVariableGroup->getAllChildren();
+   }
    CATCH
    void CField::solveDescInheritance(bool apply, const CAttributeMap* const parent)
    TRY
+   {
       SuperClassAttribute::setAttributes(parent, apply);
       this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
+   }
    CATCH_DUMP_ATTR
+  void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
+  TRY
+  {
+    this->vVariableGroup = newVVariableGroup;
+  }
+  CATCH
+  CVariableGroup* CField::getVirtualVariableGroup(void) const
+  TRY
+  {
+     return this->vVariableGroup;
+  }
+  CATCH
+  std::vector<CVariable*> CField::getAllVariables(void) const
+  TRY
+  {
+    return this->vVariableGroup->getAllChildren();
+  }
+  CATCH
+  void CField::solveDescInheritance(bool apply, const CAttributeMap* const parent)
+  TRY
+  {
+    SuperClassAttribute::setAttributes(parent, apply);
+    this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
+  }
+  CATCH_DUMP_ATTR
   //----------------------------------------------------------------
 …
           return true;
           break;
+        case EVENT_ID_GRID_COMPLETED :
+          recvGridCompleted(event);
+          return true;
+          break;
         default :
           ERROR("bool CField::dispatchEvent(CEventServer& event)", << "Unknown Event");
 …
   CATCH
-  void CField::sendUpdateData(const CArray<double,1>& data)
-  TRY
+  {
-    CTimer::get("Field : send data").resume();
-    CContext* context = CContext::getCurrent();
-    CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient();
-    int receiverSize = client->serverSize;
-    CEventClient event(getType(), EVENT_ID_UPDATE_DATA);
-    map<int, CArray<int,1> >::iterator it;
-    list<CMessage> list_msg;
-    list<CArray<double,1> > list_data;
-    if (!grid->doGridHaveDataDistributed(client))
+    {
-       if (client->isServerLeader())
+       {
-          for (it = grid->storeIndex_toSrv[client].begin(); it != grid->storeIndex_toSrv[client].end(); it++)
+          {
-            int rank = it->first;
-            CArray<int,1>& index = it->second;
-            list_msg.push_back(CMessage());
-            list_data.push_back(CArray<double,1>(index.numElements()));
-            CArray<double,1>& data_tmp = list_data.back();
-            for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n));
-            list_msg.back() << getId() << data_tmp;
-            event.push(rank, 1, list_msg.back());
+          }
-          client->sendEvent(event);
+        }
-      else client->sendEvent(event);
+    }
-    else
+    {
-      for (it = grid->storeIndex_toSrv[client].begin(); it != grid->storeIndex_toSrv[client].end(); it++)
+      {
-        int rank = it->first;
-        CArray<int,1>& index = it->second;
-        list_msg.push_back(CMessage());
-        list_data.push_back(CArray<double,1>(index.numElements()));
-        CArray<double,1>& data_tmp = list_data.back();
-        for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n));
-        list_msg.back() << getId() << data_tmp;
-        event.push(rank, grid->nbSenders[receiverSize][rank], list_msg.back());
+      }
-      client->sendEvent(event);
+    }
-    CTimer::get("Field : send data").suspend();
+  }
-  CATCH_DUMP_ATTR
   void CField::recvUpdateData(CEventServer& event)
   TRY
+  {
-    std::map<int,CBufferIn*> rankBuffers;
-    list<CEventServer::SSubEvent>::iterator it;
     string fieldId;
+    CTimer::get("Field : recv data").resume();
+    for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
+    {
+      int rank = it->rank;
+      CBufferIn* buffer = it->buffer;
+      *buffer >> fieldId;
+      rankBuffers[rank] = buffer;
+    }
+    get(fieldId)->recvUpdateData(rankBuffers);
+    CTimer::get("Field : recv data").suspend();
+  }
+  CATCH
+  void  CField::recvUpdateData(std::map<int,CBufferIn*>& rankBuffers)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    size_t sizeData = 0;
+    if (0 == recvDataSrv.numElements())
+    {
+      CArray<int,1>& storeClient = grid->storeIndex_client;
+      // Gather all data from different clients
+      recvDataSrv.resize(storeClient.numElements());
+      recvFoperationSrv = std::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv));
+    }
+    CArray<double,1> recv_data_tmp(recvDataSrv.numElements());
+    const CDate& currDate = context->getCalendar()->getCurrentDate();
+    CDuration offsetAllButMonth (freq_offset.getValue().year, 0 , freq_offset.getValue().day,
+                                   freq_offset.getValue().hour, freq_offset.getValue().minute,
+                                   freq_offset.getValue().second, freq_offset.getValue().timestep);
+    const CDate opeDate   = (last_operation_srv - offsetAllButMonth + context->getCalendar()->getTimeStep())
+                              + freq_op + freq_operation_srv - freq_op - context->getCalendar()->getTimeStep() + offsetAllButMonth;
+    if (opeDate <= currDate)
+    {
+      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin(); it != grid->outLocalIndexStoreOnClient.end(); ++it)
+      {
+        CArray<double,1> tmp;
+        CArray<size_t,1>& indexTmp = it->second;
+        *(rankBuffers[it->first]) >> tmp;
+        for (int idx = 0; idx < indexTmp.numElements(); ++idx)
+        {
+          recv_data_tmp(indexTmp(idx)) = tmp(idx);
+        }
+      }
+    }
+    this->setData(recv_data_tmp);
+    // delete incomming flux for server only
+    recvFoperationSrv.reset() ;
+    recvDataSrv.reset() ;
+  }
+  CATCH_DUMP_ATTR
+  void CField::writeUpdateData(const CArray<double,1>& data)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    const CDate& currDate = context->getCalendar()->getCurrentDate();
+    CDuration offsetAllButMonth (freq_offset.getValue().year, 0 , freq_offset.getValue().day,
+                                   freq_offset.getValue().hour, freq_offset.getValue().minute,
+                                   freq_offset.getValue().second, freq_offset.getValue().timestep);
+    const CDate opeDate   = (last_operation_srv - offsetAllButMonth + context->getCalendar()->getTimeStep())
+                              + freq_op + freq_operation_srv - freq_op - context->getCalendar()->getTimeStep() + offsetAllButMonth;
+    const CDate writeDate = last_Write_srv + freq_write_srv;
+    if (opeDate <= currDate)
+    {
+      (*recvFoperationSrv)(data);
+      last_operation_srv = currDate;
+    }
+    if (writeDate < (currDate + freq_operation_srv))
+    {
+      recvFoperationSrv->final();
+      last_Write_srv = writeDate;
+      grid->computeWrittenIndex();
+      writeField();
+      lastlast_Write_srv = last_Write_srv;
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::writeField(void)
+  TRY
+  {
+    if (!getRelFile()->isEmptyZone())
+    {
+      if (grid->doGridHaveDataToWrite() || getRelFile()->type == CFile::type_attr::one_file)
+      {
+        getRelFile()->checkWriteFile();
+        this->incrementNStep();
+        getRelFile()->getDataOutput()->writeFieldData(CField::get(this));
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> fieldId  ;
+    get(fieldId)->receiveUpdateData(event);
+  }
+  CATCH
+  void  CField::receiveUpdateData(CEventServer& event)
+  TRY
+  {
+    if (hasCouplerIn()) clientFromClientSourceFilter_->streamData(event) ;
+    else serverFromClientSourceFilter_->streamData(event) ;
+  }
+  CATCH
   /*
 …
   TRY
+  {
+    CContext* context = CContext::getCurrent();
+    // CContextClient* client = context->client;
+    // This code is for future: If we want to read file with level-2 servers
+    CContextClient* client = (!context->hasServer) ? context->client : this->file->getContextClient();
+    lastDataRequestedFromServer = tsDataRequested;
+    // No need to send the request if we are sure that we are already at EOF
+    if (!isEOF || context->getCalendar()->getCurrentDate() <= dateEOF)
+    {
+      CEventClient event(getType(), EVENT_ID_READ_DATA);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg << getId();
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+          event.push(*itRank, 1, msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+    }
+    else
+      serverSourceFilter->signalEndOfStream(tsDataRequested);
+    wasDataRequestedFromServer = true;
+    return !isEOF;
+  }
+  CATCH_DUMP_ATTR
+    return clientFromServerSourceFilter_->sendReadDataRequest(tsDataRequested) ;
+  }
+  CATCH_DUMP_ATTR
   /*!
   Send request new data read from file if need be, that is the current data is out-of-date.
 …
   TRY
+  {
+    const CDate& currentDate = CContext::getCurrent()->getCalendar()->getCurrentDate();
+    bool dataRequested = false;
+    while (currentDate >= lastDataRequestedFromServer)
+    {
+      info(20) << "currentDate : " << currentDate << endl ;
+      info(20) << "lastDataRequestedFromServer : " << lastDataRequestedFromServer << endl ;
+      info(20) << "file->output_freq.getValue() : " << file->output_freq.getValue() << endl ;
+      info(20) << "lastDataRequestedFromServer + file->output_freq.getValue() : " << lastDataRequestedFromServer + file->output_freq << endl ;
+      dataRequested |= sendReadDataRequest(lastDataRequestedFromServer + file->output_freq);
+    }
+    return dataRequested;
+  }
+  CATCH_DUMP_ATTR
+    return clientFromServerSourceFilter_->sendReadDataRequestIfNeeded() ;
+  }
+  CATCH_DUMP_ATTR
   void CField::recvReadDataRequest(CEventServer& event)
 …
+  }
   CATCH
   /*!
     Receive data request sent from client and process it
 …
   TRY
+  {
+    CContext* context = CContext::getCurrent();
+    CContextClient* client = context->client;
+    CEventClient event(getType(), EVENT_ID_READ_DATA_READY);
+    std::list<CMessage> msgs;
+    EReadField hasData = readField();
+    map<int, CArray<double,1> >::iterator it;
+    if (!grid->doGridHaveDataDistributed(client))
+    {
+       if (client->isServerLeader())
+       {
+          if (0 != recvDataSrv.numElements())
+          {
+            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 << getId();
+              switch (hasData)
+              {
+                case RF_DATA:
+                  msg << getNStep() - 1 << recvDataSrv;
+                  break;
+                case RF_NODATA:
+                  msg << int(-2) << recvDataSrv;
+                  break;
+                case RF_EOF:
+                default:
+                  msg << int(-1);
+                  break;
+              }
+              event.push(*itRank, 1, msg);
+            }
+          }
+          client->sendEvent(event);
+       }
+       else
+       {
+          client->sendEvent(event);
+       }
+    }
+    else
+    {
+      for (map<int, CArray<size_t, 1> >::iterator it = grid->outLocalIndexStoreOnClient.begin();
+                                                  it != grid->outLocalIndexStoreOnClient.end(); ++it)
+      {
+        CArray<size_t,1>& indexTmp = it->second;
+        CArray<double,1> tmp(indexTmp.numElements());
+        for (int idx = 0; idx < indexTmp.numElements(); ++idx)
+        {
+          tmp(idx) = recvDataSrv(indexTmp(idx));
+        }
+        msgs.push_back(CMessage());
+        CMessage& msg = msgs.back();
+        msg << getId();
+        switch (hasData)
+        {
+          case RF_DATA:
+            msg << getNStep() - 1 << tmp;
+            break;
+          case RF_NODATA:
+            msg << int(-2) << tmp;
+            break;
+          case RF_EOF:
+          default:
+            msg << int(-1);
+            break;
+        }
+        event.push(it->first, grid->nbReadSenders[client][it->first], msg);
+      }
+      client->sendEvent(event);
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Read field from a file.
+    A field is read with the distribution of data on the server side
+    \return State of field can be read from a file
+  */
+  CField::EReadField CField::readField(void)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    grid->computeWrittenIndex();
+    getRelFile()->initRead();
+    EReadField readState = RF_DATA;
+    if (!getRelFile()->isEmptyZone())
+    {
+      if (grid->doGridHaveDataToWrite() || getRelFile()->type == CFile::type_attr::one_file)
+      {
+        if (0 == recvDataSrv.numElements())
+        {
+          CArray<int,1>& storeClient = grid->storeIndex_client;
+          recvDataSrv.resize(storeClient.numElements());
+        }
+        getRelFile()->checkReadFile();
+        if (!nstepMax)
+        {
+          nstepMax = getRelFile()->getDataInput()->getFieldNbRecords(CField::get(this));
+        }
+        this->incrementNStep();
+        if (getNStep() > nstepMax && (getRelFile()->cyclic.isEmpty() || !getRelFile()->cyclic) )
+          readState = RF_EOF;
+        if (RF_EOF != readState)
+          getRelFile()->getDataInput()->readFieldData(CField::get(this));
+      }
+    }
+    else
+    {
+      this->incrementNStep();
+      if (getNStep() > nstepMax && (getRelFile()->cyclic.isEmpty() || !getRelFile()->cyclic) )
+        readState = RF_EOF;
+      else
+        readState = RF_NODATA;
+      if (!nstepMaxRead) // This can be a bug if we try to read field from zero time record
+        readState = RF_NODATA;
+    }
+    if (!nstepMaxRead)
+    {
+       MPI_Allreduce(MPI_IN_PLACE, &nstepMax, 1, MPI_INT, MPI_MAX, context->server->intraComm);
+       nstepMaxRead = true;
+    }
+    return readState;
+  }
+  CATCH_DUMP_ATTR
+    fileReaderSourceFilter_->streamData() ;
+  }
+  CATCH_DUMP_ATTR
   /*
     Receive read data from server.
 …
+  {
     string fieldId;
+    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;
+      *buffer >> fieldId;
+      buffers.push_back(buffer);
+    }
+    get(fieldId)->recvReadDataReady(ranks, buffers);
+  }
+  CATCH
+  /*!
+    Receive read data from server
+    \param [in] ranks Ranks of sending processes
+    \param [in] buffers buffers containing read data
+  */
+  void CField::recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    std::map<int, CArray<double,1> > data;
+    const bool wasEOF = isEOF;
+    for (int i = 0; i < ranks.size(); i++)
+    {
+      int rank = ranks[i];
+      int record;
+      *buffers[i] >> record;
+      isEOF = (record == int(-1));
+      if (!isEOF)
+        *buffers[i] >> data[rank];
+      else
+        break;
+    }
+    if (wasDataAlreadyReceivedFromServer)
+      lastDataReceivedFromServer = lastDataReceivedFromServer + file->output_freq;
+    else
+    {
+      lastDataReceivedFromServer = context->getCalendar()->getInitDate();
+      wasDataAlreadyReceivedFromServer = true;
+    }
+    if (isEOF)
+    {
+      if (!wasEOF)
+        dateEOF = lastDataReceivedFromServer;
+      serverSourceFilter->signalEndOfStream(lastDataReceivedFromServer);
+    }
+    else
+      serverSourceFilter->streamDataFromServer(lastDataReceivedFromServer, data);
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkForLateDataFromServer(void)
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> fieldId  ;
+    get(fieldId)->receiveReadDataReady(event);
+  }
+  CATCH
+  void CField::receiveReadDataReady(CEventServer& event)
+  TRY
+  {
+    clientFromServerSourceFilter_->streamData(event) ;
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkForLateDataFromCoupler(void)
   TRY
+  {
 …
     const CDate& currentDate = context->getCalendar()->getCurrentDate();
+    // Check if data previously requested has been received as expected
+    if (wasDataRequestedFromServer && !isEOF)
+    {
+      CTimer timer("CField::checkForLateDataFromServer");
+      bool isDataLate;
+      do
+      {
+        const CDate nextDataDue = wasDataAlreadyReceivedFromServer ? (lastDataReceivedFromServer + file->output_freq) : context->getCalendar()->getInitDate();
+        isDataLate = (nextDataDue <= currentDate);
+        if (isDataLate)
+    CTimer timer("CField::checkForLateDataFromCoupler");
+    timer.resume();
+    traceOff() ;
+    timer.suspend();
+    bool isDataLate;
+    do
+    {
+      isDataLate=clientFromClientSourceFilter_->isDataLate() ;
+      if (isDataLate)
+      {
+        timer.resume();
+        context->globalEventLoop();
+        timer.suspend();
+      }
+    } while (isDataLate && timer.getCumulatedTime() < CXios::recvFieldTimeout);
+    timer.resume();
+    traceOn() ;
+    timer.suspend() ;
+    if (isDataLate) ERROR("void CField::checkForLateDataFromCoupler(void)",
+                            << "Late data at timestep = " << currentDate);
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkForLateDataFromServer(void)
+  TRY
+  {
+    clientFromServerSourceFilter_->checkForLateData() ;
+  }
+  CATCH_DUMP_ATTR
+  void CField::triggerLateField(void)
+  TRY
+  {
+    if (hasFileIn())
+    {
+      checkForLateDataFromServer() ;
+      clientFromServerSourceFilter_->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()) ;
+    }
+    else if (hasCouplerIn())
+    {
+      checkForLateDataFromCoupler() ;
+      clientFromClientSourceFilter_->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()) ;
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkIfMustAutoTrigger(void)
+  TRY
+  {
+    mustAutoTrigger = clientFromServerSourceFilter_ ? clientFromServerSourceFilter_->mustAutoTrigger() : false;
+  }
+  CATCH_DUMP_ATTR
+  void CField::autoTriggerIfNeeded(void)
+  TRY
+  {
+    if (mustAutoTrigger)
+      clientFromServerSourceFilter_->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate());
+  }
+  CATCH_DUMP_ATTR
+  //----------------------------------------------------------------
+  StdString CField::GetName(void)    { return StdString("field"); }
+  StdString CField::GetDefName(void) { return CField::GetName(); }
+  ENodeType CField::GetType(void)    { return eField; }
+  //----------------------------------------------------------------
+  CGrid* CField::getRelGrid(void) const
+  TRY
+  {
+    return this->grid_;
+  }
+  CATCH
+  //----------------------------------------------------------------
+  CFile* CField::getRelFile(void) const
+  TRY
+  {
+    if (hasFileIn()) return this->fileIn_;
+    else if (hasFileOut()) return this->fileOut_ ;
+    else return nullptr ;
+  }
+  CATCH
+  func::CFunctor::ETimeType CField::getOperationTimeType() const
+  TRY
+  {
+    return operationTimeType;
+  }
+  CATCH
+  //----------------------------------------------------------------
+  bool CField::isActive(bool atCurrentTimestep /*= false*/) const
+  TRY
+  {
+    if (modelToClientSourceFilter_)
+      return atCurrentTimestep ? modelToClientSourceFilter_->isDataExpected(CContext::getCurrent()->getCalendar()->getCurrentDate()) : true;
+    else if (clientToModelStoreFilter_)  return true;
+    else if (instantDataFilter)
+      ERROR("bool CField::isActive(bool atCurrentTimestep)",
+            << "Impossible to check if field [ id = " << getId() << " ] is active as it cannot be used to receive nor send data.");
+    return false;
+  }
+  CATCH
+  //----------------------------------------------------------------
+  bool CField::wasWritten() const
+  TRY
+  {
+    return written;
+  }
+  CATCH
+  void CField::setWritten()
+  TRY
+  {
+    written = true;
+  }
+  CATCH_DUMP_ATTR
+  //----------------------------------------------------------------
+  bool CField::getUseCompressedOutput() const
+  TRY
+  {
+    return useCompressedOutput;
+  }
+  CATCH
+  void CField::setUseCompressedOutput()
+  TRY
+  {
+    useCompressedOutput = true;
+  }
+  CATCH_DUMP_ATTR
+  //----------------------------------------------------------------
+  void CField::updateRef(CGrid* grid)
+  TRY
+  {
+    if (!grid_ref.isEmpty()) grid_ref.setValue(grid->getId());
+    else
+    {
+      std::vector<CAxis*> axisTmp = grid->getAxis();
+      std::vector<CDomain*> domainTmp = grid->getDomains();
+      if ((1<axisTmp.size()) || (1<domainTmp.size()))
+        ERROR("void CField::updateRef(CGrid* grid)",
+          << "More than one domain or axis is available for domain_ref/axis_ref of field " << this->getId());
+      if ((!domain_ref.isEmpty()) && (domainTmp.empty()))
+        ERROR("void CField::updateRef(CGrid* grid)",
+          << "Incoherent between available domain and domain_ref of field " << this->getId());
+      if ((!axis_ref.isEmpty()) && (axisTmp.empty()))
+        ERROR("void CField::updateRef(CGrid* grid)",
+          << "Incoherent between available axis and axis_ref of field " << this->getId());
+      if (!domain_ref.isEmpty()) domain_ref.setValue(domainTmp[0]->getId());
+      if (!axis_ref.isEmpty()) axis_ref.setValue(axisTmp[0]->getId());
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkGridOfEnabledFields()
+  TRY
+  {
+    if (!isGridChecked)
+    {
+      isGridChecked = true;
+      solveCheckMaskIndex(false);
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::sendGridComponentOfEnabledFields()
+  TRY
+  {
+    solveGridDomainAxisRef(true);
+    // solveCheckMaskIndex(true);
+  }
+  CATCH_DUMP_ATTR
+  void CField::sendGridOfEnabledFields()
+  TRY
+  {
+    // solveGridDomainAxisRef(true);
+    solveCheckMaskIndex(true);
+  }
+  CATCH_DUMP_ATTR
+  /*!
+   * Compute the required buffer size to send the fields data.
+   * \param [in/out] bufferSize Modifying the bufferSize for the client context
+   * \param [in/out] maxEventSize Modifying the maximum event size for the client context
+   * \param [in] bufferForWriting True if buffers are used for sending data for writing
+   */
+  void CField::setContextClientDataBufferSize(map<CContextClient*,map<int,size_t>>& bufferSize,
+                                              map<CContextClient*,map<int,size_t>>& maxEventSize,
+                                              bool bufferForWriting)
+  {
+    auto& contextBufferSize = bufferSize[client] ;
+    auto& contextMaxEventSize = maxEventSize[client] ;
+    const std::map<int, size_t> mapSize = grid_->getDataBufferSize(client, getId(), bufferForWriting);
+    for(auto& it : mapSize )
+    {
+      // If contextBufferSize[it.first] does not exist, it will be zero-initialized
+      // so we can use it safely without checking for its existance
+      if (CXios::isOptPerformance) contextBufferSize[it.first] += it.second;
+      else if (contextBufferSize[it.first] < it.second) contextBufferSize[it.first] = it.second;
+      if (contextMaxEventSize[it.first] < it.second) contextMaxEventSize[it.first] = it.second;
+    }
+  }
+  void CField::setContextClientAttributesBufferSize(map<CContextClient*,map<int,size_t>>& bufferSize,
+                                                   map<CContextClient*,map<int,size_t>>& maxEventSize,
+                                                   bool bufferForWriting)
+  {
+    auto& contextBufferSize = bufferSize[client] ;
+    auto& contextMaxEventSize = maxEventSize[client] ;
+    const std::map<int, size_t> mapSize = grid_->getAttributesBufferSize(client, bufferForWriting);
+    for(auto& it : mapSize )
+    {
+      // If contextBufferSize[it.first] does not exist, it will be zero-initialized
+      // so we can use it safely without checking for its existance
+      if (contextBufferSize[it.first] < it.second) contextBufferSize[it.first] = it.second;
+      if (contextMaxEventSize[it.first] < it.second) contextMaxEventSize[it.first] = it.second;
+    }
+  }
+// ym obsolete to be removed
+  std::map<int, StdSize> CField::getGridAttributesBufferSize(CContextClient* client, bool bufferForWriting /*= "false"*/)
+  TRY
+  {
+    return grid_->getAttributesBufferSize(client, bufferForWriting);
+  }
+  CATCH_DUMP_ATTR
+// ym obsolete to be removed
+  std::map<int, StdSize> CField::getGridDataBufferSize(CContextClient* client, bool bufferForWriting /*= "false"*/)
+  TRY
+  {
+    return grid_->getDataBufferSize(client, getId(), bufferForWriting);
+  }
+  CATCH_DUMP_ATTR
+  size_t CField::getGlobalWrittenSize()
+  TRY
+  {
+    return grid_->getGlobalWrittenSize();
+  }
+  CATCH_DUMP_ATTR
+  //----------------------------------------------------------------
+  void CField::solveServerOperation(void)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    if (freq_op.isEmpty()) freq_op.setValue(TimeStep);
+    if (freq_offset.isEmpty()) freq_offset.setValue(NoneDu);
+    if (operation.isEmpty())
+      ERROR("void CField::solveServerOperation(void)",
+            << "An operation must be defined for field \"" << getId() << "\".");
+    std::shared_ptr<func::CFunctor> functor;
+    CArray<double, 1> dummyData;
+#define DECLARE_FUNCTOR(MType, mtype) \
+    if (operation.getValue().compare(#mtype) == 0) \
+    { \
+      functor.reset(new func::C##MType(dummyData)); \
+    }
+#include "functor_type.conf"
+    if (!functor)
+      ERROR("void CField::solveServerOperation(void)",
+            << "\"" << operation << "\" is not a valid operation.");
+    operationTimeType = functor->timeType();
+  }
+  CATCH_DUMP_ATTR
+ //----------------------------------------------------------------
+  bool CField::buildWorkflowGraph(CGarbageCollector& gc)
+  {
+    if (buildWorkflowGraphDone_) return true ;
+    const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+    const double defaultValue = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+    bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    std::cout<<"field id="<<this->getId()<<" build_workflow_graph="<<buildGraph_<<std::endl;
+    if (!inputFilter)
+    {
+      inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc));
+      if(buildGraph_)
+      {
+        std::cout<<"============== field "<<this->getId()<<" calls a pass through filter ============== "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+        inputFilter->graphEnabled = true;
+        inputFilter->graphPackage = new CGraphPackage;
+        inputFilter->graphPackage->inFields.push_back(this);
+      }
+    }
+    if (hasDirectFieldReference())
+    {
+      CField* fieldRef = getDirectFieldReference();
+      if(buildGraph_)
+      {
+        (*fieldRef).build_workflow_graph.set(build_workflow_graph);
+      }
+      else
+      {
+        this->build_workflow_graph.set(fieldRef->build_workflow_graph);
+        buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+      }
+      if(buildGraph_) this->build_workflow_graph.set(build_workflow_graph);
+      bool ret=fieldRef->buildWorkflowGraph(gc);
+      if (!ret) return false ; // workflow graph cannot be built at this stage
+    }
+    // now construct grid and check if element are enabled
+    solveGridReference() ; // grid_ is now defined
+    if (!isGridCompleted()) return false;
+    // Check if we have an expression to parse
+    std::shared_ptr<COutputPin> filterExpr ;
+    if (hasExpression())
+    {
+      boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0'));
+      filterExpr = expr->reduce(gc, *this);
+      if (!filterExpr) return false ; // workflow graph cannot be built at this stage
+    }
+    // prepare transformation. Need to know before if workflow of auxillary field can be built
+    if (hasDirectFieldReference())
+    {
+      auto gridPath=getGridPath() ;
+      gridPath.push_back(grid_) ;
+      CGrid* gridSrc=getDirectFieldReference()->getGrid() ;
+      std::shared_ptr<COutputPin> lastFilter ;
+      if (filterExpr) lastFilter=filterExpr ;
+      else lastFilter = inputFilter ;
+      CGrid* newGrid ;
+      for(auto grid : gridPath)
+      {
+        grid->solveElementsRefInheritance() ;
+        // new
+        std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = grid->buildTransformationGraph(gc, false,  gridSrc, detectMissingValues, defaultValue, newGrid, buildGraph_) ;
+        lastFilter->connectOutput(filters.first, 0);
+        if(buildGraph_)
+        {
+          timer.resume();
+          context->checkBuffersAndListen();
+          timer.suspend();
+          std::cout<<"============== field "<<this->getId()<<" calls a transformation filter 1 ============== "<<lastFilter<<" _ "<<filters.first<<" ***** "<<CXios::isClient<<std::endl;
+          filters.first->graphEnabled=true;
+          filters.first->graphPackage = new CGraphPackage;
+          filters.first->graphPackage->inFields.push_back(this);
+        }
+      }
+      while (isDataLate && timer.getCumulatedTime() < CXios::recvFieldTimeout);
+      if (isDataLate)
+        ERROR("void CField::checkForLateDataFromServer(void)",
+              << "Late data at timestep = " << currentDate);
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::checkIfMustAutoTrigger(void)
+  TRY
+  {
+    mustAutoTrigger = serverSourceFilter ? serverSourceFilter->mustAutoTrigger() : false;
+  }
+  CATCH_DUMP_ATTR
+  void CField::autoTriggerIfNeeded(void)
+  TRY
+  {
+    if (mustAutoTrigger)
+      serverSourceFilter->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate());
+  }
+  CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   void CField::setRelFile(CFile* _file)
+   TRY
+   {
+      this->file = _file;
+      hasOutputFile = true;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   StdString CField::GetName(void)    { return StdString("field"); }
+   StdString CField::GetDefName(void) { return CField::GetName(); }
+   ENodeType CField::GetType(void)    { return eField; }
+   //----------------------------------------------------------------
+   CGrid* CField::getRelGrid(void) const
+   TRY
+   {
+      return this->grid;
+   }
+   CATCH
+   //----------------------------------------------------------------
+   CFile* CField::getRelFile(void) const
+   TRY
+   {
+      return this->file;
+   }
+   CATCH
+   int CField::getNStep(void) const
+   TRY
+   {
+      return this->nstep;
+   }
+   CATCH
+   func::CFunctor::ETimeType CField::getOperationTimeType() const
+   TRY
+   {
+     return operationTimeType;
+   }
+   CATCH
+   //----------------------------------------------------------------
+   void CField::incrementNStep(void)
+   TRY
+   {
+      this->nstep++;
+   }
+   CATCH_DUMP_ATTR
+   void CField::resetNStep(int nstep /*= 0*/)
+   TRY
+   {
+      this->nstep = nstep;
+   }
+   CATCH_DUMP_ATTR
+   void CField::resetNStepMax(void)
+   TRY
+   {
+      this->nstepMax = 0;
+      nstepMaxRead = false;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   bool CField::isActive(bool atCurrentTimestep /*= false*/) const
+   TRY
+   {
+      if (clientSourceFilter)
+        return atCurrentTimestep ? clientSourceFilter->isDataExpected(CContext::getCurrent()->getCalendar()->getCurrentDate()) : true;
+      else if (storeFilter)
+        return true;
+      else if (instantDataFilter)
+        ERROR("bool CField::isActive(bool atCurrentTimestep)",
+              << "Impossible to check if field [ id = " << getId() << " ] is active as it cannot be used to receive nor send data.");
+      return false;
+   }
+   CATCH
+   //----------------------------------------------------------------
+   bool CField::wasWritten() const
+   TRY
+   {
+     return written;
+   }
+   CATCH
+   void CField::setWritten()
+   TRY
+   {
+     written = true;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   bool CField::getUseCompressedOutput() const
+   TRY
+   {
+     return useCompressedOutput;
+   }
+   CATCH
+   void CField::setUseCompressedOutput()
+   TRY
+   {
+     useCompressedOutput = true;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   std::shared_ptr<COutputPin> CField::getInstantDataFilter()
+   TRY
+   {
+     return instantDataFilter;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   /*!
+     Build up graph of grids which plays role of destination and source in grid transformation
+     This function should be called before \func solveGridReference()
+        lastFilter = filters.second;
+        gridSrc = newGrid ;
+        // end new
+      }
+      grid_=newGrid ;
+      grid_ref=grid_->getId() ; // for server
+      instantDataFilter = lastFilter ;
+      // connect the input Filter to the reference
+      getDirectFieldReference()->getInstantDataFilter()->connectOutput(inputFilter,0);
+      if(buildGraph_)
+      {
+        std::cout<<"============== field "<<this->getId()<<" calls a transformation filter 2 ============== "<<getDirectFieldReference()->getInstantDataFilter()<<" _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+        inputFilter->graphEnabled=true;
+        inputFilter->graphPackage = new CGraphPackage;
+        inputFilter->graphPackage->inFields.push_back(this);
+      }
+    }
+    else
+    {
+      if (hasFileIn()) // input file, attemp to read the grid from file
+      {
+         // must be checked
+         fileIn_->initRead() ;
+         fileIn_->checkReadFile();
+         grid_->solveElementsRefInheritance() ;
+         if (fileIn_->isClientSide()) fileIn_->readFieldAttributesMetaData(this);
+         CGrid* newGrid ;
+         std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = grid_->buildTransformationGraph(gc, true, nullptr, detectMissingValues, defaultValue, newGrid, buildGraph_) ;
+         grid_ = newGrid ;
+         grid_ref=grid_->getId() ; // for server
+         if (fileIn_->isClientSide()) fileIn_->readFieldAttributesValues(this);
+         grid_->checkElementsAttributes() ;
+         // probably in future tag grid incomplete if coming from a reading
+         instantDataFilter=inputFilter ;
+      }
+      else if (hasCouplerIn())
+      {
+        grid_->checkElementsAttributes() ;
+        instantDataFilter=inputFilter ;
+      }
+      else
+      {
+        setModelIn() ; // no reference, the field is potentially a source field from model
+        grid_->solveElementsRefInheritance() ;
+        CGrid* newGrid ;
+        std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = grid_->buildTransformationGraph(gc, true, nullptr, detectMissingValues, defaultValue, newGrid, buildGraph_) ;
+        newGrid->duplicateAttributes(grid_) ; // for grid attributes (mask)
+        grid_ = newGrid ;
+        grid_ref=grid_->getId() ; // for server
+        grid_->checkElementsAttributes() ;
+        instantDataFilter=inputFilter ;
+      }
+    }
+    if (hasFileOut())
+    {
+      if (fileOut_->isServerSide())
+      {
+        this->solveServerOperation() ;
+      }
+    }
+    buildWorkflowGraphDone_ = true ;
+    workflowEnabled_ = true ;
+    return true ;
+  }
+  /*!
+   * Connect field to filter to send data to server. A temporal filter is inserted before accordingly to the
+   * output frequency of the file
+   * \param gc the garbage collector to use when building the filter graph
    */
+   void CField::buildGridTransformationGraph()
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     if (context->hasClient && !context->hasServer)
+     {
+       if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
+       {
+         grid->addTransGridSource(getDirectFieldReference()->grid);
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Generate a new grid destination if there are more than one grid source pointing to a same grid destination
+  void CField::connectToFileServer(CGarbageCollector& gc)
+  {
+    // insert temporal filter before sending to files
+    clientToServerStoreFilter_ = std::shared_ptr<CClientToServerStoreFilter>(new CClientToServerStoreFilter(gc, this, client));
+    // insert temporal filter before sending to files
+    getTemporalDataFilter(gc, fileOut_->output_freq)->connectOutput(clientToServerStoreFilter_, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToFileServer  ============== "<<getTemporalDataFilter(gc, fileOut_->output_freq)<<" _ "<<clientToServerStoreFilter_<<" ***** "<<CXios::isClient<<std::endl;
+      clientToServerStoreFilter_->graphPackage = new CGraphPackage;
+      clientToServerStoreFilter_->graphEnabled = true;
+      clientToServerStoreFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  void CField::connectToCouplerOut(CGarbageCollector& gc)
+  {
+    // insert temporal filter before sending to files
+    clientToServerStoreFilter_ = std::shared_ptr<CClientToServerStoreFilter>(new CClientToServerStoreFilter(gc, this, client));
+    instantDataFilter->connectOutput(clientToServerStoreFilter_, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToCouplerOut  ============== "<<instantDataFilter<<" _ "<<clientToServerStoreFilter_<<" ***** "<<CXios::isClient<<std::endl;
+      clientToServerStoreFilter_->graphPackage = new CGraphPackage;
+      clientToServerStoreFilter_->graphEnabled = true;
+      clientToServerStoreFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a source filter to receive data from model.
    */
+   void CField::generateNewTransformationGridDest()
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     if (context->hasClient && !context->hasServer)
+     {
+       std::map<CGrid*,std::pair<bool,StdString> >& gridSrcMap = grid->getTransGridSource();
+       if (1 < gridSrcMap.size())
+       {
+         // Search for grid source
+         CGrid* gridSrc = grid;
+         CField* currField = this;
+         std::vector<CField*> hieraField;
+         while (currField->hasDirectFieldReference() && (gridSrc == grid))
+         {
+           hieraField.push_back(currField);
+           CField* tmp = currField->getDirectFieldReference();
+           currField = tmp;
+           gridSrc = currField->grid;
+         }
+         if (gridSrcMap.end() != gridSrcMap.find(gridSrc))
+         {
+           CGrid* gridTmp;
+           std::pair<bool,StdString> newGridDest = gridSrcMap[gridSrc];
+           if (newGridDest.first)
+           {
+             StdString newIdGridDest = newGridDest.second;
+             if (!CGrid::has(newIdGridDest))
+             {
+                ERROR("CGrid* CGrid::generateNewTransformationGridDest()",
+                  << " Something wrong happened! Grid whose id " << newIdGridDest
+                  << "should exist ");
+             }
+             gridTmp = CGrid::get(newIdGridDest);
+           }
+           else
+           {
+             StdString newIdGridDest = CGrid::generateId(gridSrc, grid);
+             gridTmp = CGrid::cloneGrid(newIdGridDest, grid);
+             (gridSrcMap[gridSrc]).first = true;
+             (gridSrcMap[gridSrc]).second = newIdGridDest;
+           }
+           // Update all descendants
+           for (std::vector<CField*>::iterator it = hieraField.begin(); it != hieraField.end(); ++it)
+           {
+             (*it)->grid = gridTmp;
+             (*it)->updateRef((*it)->grid);
+           }
+         }
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CField::updateRef(CGrid* grid)
+   TRY
+   {
+     if (!grid_ref.isEmpty()) grid_ref.setValue(grid->getId());
+     else
+     {
+       std::vector<CAxis*> axisTmp = grid->getAxis();
+       std::vector<CDomain*> domainTmp = grid->getDomains();
+       if ((1<axisTmp.size()) || (1<domainTmp.size()))
+         ERROR("void CField::updateRef(CGrid* grid)",
+           << "More than one domain or axis is available for domain_ref/axis_ref of field " << this->getId());
+       if ((!domain_ref.isEmpty()) && (domainTmp.empty()))
+         ERROR("void CField::updateRef(CGrid* grid)",
+           << "Incoherent between available domain and domain_ref of field " << this->getId());
+       if ((!axis_ref.isEmpty()) && (axisTmp.empty()))
+         ERROR("void CField::updateRef(CGrid* grid)",
+           << "Incoherent between available axis and axis_ref of field " << this->getId());
+       if (!domain_ref.isEmpty()) domain_ref.setValue(domainTmp[0]->getId());
+       if (!axis_ref.isEmpty()) axis_ref.setValue(axisTmp[0]->getId());
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Solve reference of all enabled fields even the source fields .
+     In this step, we do transformations.
+  void CField::connectToModelInput(CGarbageCollector& gc)
+  {
+    const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+    const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+    if (check_if_active.isEmpty()) check_if_active = false;
+    modelToClientSourceFilter_ = std::shared_ptr<CModelToClientSourceFilter>(new CModelToClientSourceFilter(gc, grid_, detectMissingValues, defaultValue));
+    modelToClientSourceFilter_ -> connectOutput(inputFilter,0) ;
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_ )
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToModelInput  ============== "<<modelToClientSourceFilter_<<" _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+      modelToClientSourceFilter_->graphPackage = new CGraphPackage;
+      modelToClientSourceFilter_->graphEnabled = true;
+      modelToClientSourceFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a source filter to receive data from a client (on server side).
    */
+   void CField::solveAllEnabledFieldsAndTransform()
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     bool hasClient = context->hasClient;
+     bool hasServer = context->hasServer;
+     if (!isReferenceSolvedAndTransformed)
+     {
+        isReferenceSolvedAndTransformed = true;
+        if (hasClient && !hasServer)
+  void CField::connectToClientInput(CGarbageCollector& gc)
+  {
+    serverFromClientSourceFilter_ = std::shared_ptr<CServerFromClientSourceFilter>(new CServerFromClientSourceFilter(gc,  grid_));
+    serverFromClientSourceFilter_ -> connectOutput(inputFilter,0) ;
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToClientInput  ============== "<<serverFromClientSourceFilter_ << " _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+      serverFromClientSourceFilter_->graphPackage = new CGraphPackage;
+      serverFromClientSourceFilter_->graphEnabled = true;
+      serverFromClientSourceFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a source filter to receive data from a server (on client side).
+   */
+  void CField::connectToServerInput(CGarbageCollector& gc)
+  {
+    checkTimeAttributes();
+    clientFromServerSourceFilter_ = std::shared_ptr<CClientFromServerSourceFilter>(new CClientFromServerSourceFilter(gc,this)) ;
+    clientFromServerSourceFilter_ -> connectOutput(inputFilter,0) ;
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToServerInput  ============== "<<clientFromServerSourceFilter_ << " _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+      clientFromServerSourceFilter_->graphPackage = new CGraphPackage;
+      clientFromServerSourceFilter_->graphEnabled = true;
+      clientFromServerSourceFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a source filter to receive data from coupler (on client side).
+   */
+   void CField::connectToCouplerIn(CGarbageCollector& gc)
+  {
+    CContext* context = CContext::getCurrent();
+    if (freq_op.isEmpty()) freq_op.setValue(TimeStep);
+    if (freq_offset.isEmpty()) freq_offset.setValue(freq_op.getValue() - TimeStep);
+    clientFromClientSourceFilter_ = std::shared_ptr<CClientFromClientSourceFilter>(new CClientFromClientSourceFilter(gc, this)) ;
+    clientFromClientSourceFilter_ -> connectOutput(inputFilter,0) ;
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToCouplerIn  ============== "<<clientFromClientSourceFilter_ << " _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+      clientFromClientSourceFilter_->graphPackage = new CGraphPackage;
+      clientFromClientSourceFilter_->graphEnabled = true;
+      clientFromClientSourceFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a file writer filter to write data in file (on server side).
+   */
+  void CField::connectToFileWriter(CGarbageCollector& gc)
+  {
+    fileWriterStoreFilter_ = std::shared_ptr<CFileWriterStoreFilter>(new CFileWriterStoreFilter(gc, this));
+    instantDataFilter->connectOutput(fileWriterStoreFilter_, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToFileWriter  ============== "<<instantDataFilter << " _ "<<fileWriterStoreFilter_<<" ***** "<<CXios::isClient<<std::endl;
+      fileWriterStoreFilter_->graphPackage = new CGraphPackage;
+      fileWriterStoreFilter_->graphEnabled = true;
+      fileWriterStoreFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a file reader filter to read data from file (on server side).
+   */
+  void CField::connectToFileReader(CGarbageCollector& gc)
+  {
+    fileReaderSourceFilter_ = std::shared_ptr<CFileReaderSourceFilter>(new CFileReaderSourceFilter(gc, this));
+    fileReaderSourceFilter_->connectOutput(inputFilter, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToFileReader  ============== "<<fileReaderSourceFilter_ << " _ "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl;
+      fileReaderSourceFilter_->graphPackage = new CGraphPackage;
+      fileReaderSourceFilter_->graphEnabled = true;
+      fileReaderSourceFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Connect field to a store filter to output data to model on client Side
+   */
+  void CField::connectToModelOutput(CGarbageCollector& gc)
+  {
+    clientToModelStoreFilter_ = std::shared_ptr<CClientToModelStoreFilter>(new CClientToModelStoreFilter(gc, this));
+    instantDataFilter->connectOutput(clientToModelStoreFilter_, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToModelOutput  ============== "<<instantDataFilter << " _ "<<clientToModelStoreFilter_<<" ***** "<<CXios::isClient<<std::endl;
+      clientToModelStoreFilter_->graphPackage = new CGraphPackage;
+      clientToModelStoreFilter_->graphEnabled = true;
+      clientToModelStoreFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  void CField::connectToServerToClient(CGarbageCollector& gc)
+  {
+    serverToClientStoreFilter_ = std::shared_ptr<CServerToClientStoreFilter>(new CServerToClientStoreFilter(gc, this, client));
+    instantDataFilter->connectOutput(serverToClientStoreFilter_, 0);
+    const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+    if(buildGraph_)
+    {
+      std::cout<<"============== field "<<this->getId()<<" calls a connectToServerToClient  ============== "<<instantDataFilter << " _ "<<serverToClientStoreFilter_<<" ***** "<<CXios::isClient<<std::endl;
+      serverToClientStoreFilter_->graphPackage = new CGraphPackage;
+      serverToClientStoreFilter_->graphEnabled = true;
+      serverToClientStoreFilter_->graphPackage->inFields.push_back(this);
+    }
+  }
+  /*!
+   * Transform the grid_path attribut into vector of grid.
+   * \return the vector CGrid* containing the list of grid path for tranformation
+   */
+  vector<CGrid*> CField::getGridPath(void)
+  {
+    std::vector<CGrid*> gridPath;
+    if (hasDirectFieldReference() && grid_ != getDirectFieldReference()->grid_)
+    {
+      if (!grid_path.isEmpty())
+      {
+        std::string gridId;
+        size_t start = 0, end;
+        do
+        {
+          solveRefInheritance(true);
+          if (hasDirectFieldReference()) getDirectFieldReference()->solveAllEnabledFieldsAndTransform();
+          end = grid_path.getValue().find(',', start);
+          if (end != std::string::npos)
+          {
+            gridId = grid_path.getValue().substr(start, end - start);
+            start = end + 1;
+          }
+          else gridId = grid_path.getValue().substr(start);
+          if (!CGrid::has(gridId))
+            ERROR("void CField::solveTransformedGrid()",
+               << "Invalid grid_path, the grid '" << gridId << "' does not exist.");
+          gridPath.push_back(CGrid::get(gridId));
+        }
+        if (hasServer)
+          solveServerOperation();
+        solveGridReference();
+        if (hasClient && !hasServer)
+       {
+         solveGenerateGrid();
+         buildGridTransformationGraph();
+       }
+       solveGridDomainAxisRef(false);
+       if (hasClient && !hasServer)
+       {
+         solveTransformedGrid();
+       }
+       solveGridDomainAxisRef(false);
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CField::checkGridOfEnabledFields()
+   TRY
+   {
+     if (!isGridChecked)
+     {
+       isGridChecked = true;
+       solveCheckMaskIndex(false);
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CField::sendGridComponentOfEnabledFields()
+   TRY
+   {
+      solveGridDomainAxisRef(true);
+      // solveCheckMaskIndex(true);
+   }
+   CATCH_DUMP_ATTR
+   void CField::sendGridOfEnabledFields()
+   TRY
+   {
+      // solveGridDomainAxisRef(true);
+      solveCheckMaskIndex(true);
+   }
+   CATCH_DUMP_ATTR
+   void CField::solveOnlyReferenceEnabledField(bool doSending2Server)
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     if (!isReferenceSolved)
+     {
+        isReferenceSolved = true;
+        if (context->hasClient && !context->hasServer)
+        {
+          solveRefInheritance(true);
+          if (hasDirectFieldReference()) getDirectFieldReference()->solveOnlyReferenceEnabledField(false);
+        }
+        if (context->hasServer)
+          solveServerOperation();
+        solveGridReference();
+        grid->solveDomainAxisRefInheritance(true); // make it again to solve grid reading from file
+        if (context->hasClient && !context->hasServer)
+       {
+         solveGenerateGrid();
+         buildGridTransformationGraph();
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CField::solveAllReferenceEnabledField(bool doSending2Server)
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     solveOnlyReferenceEnabledField(doSending2Server);
+     if (!areAllReferenceSolved)
+     {
+        areAllReferenceSolved = true;
+        if (context->hasClient && !context->hasServer)
+        {
+          solveRefInheritance(true);
+          if (hasDirectFieldReference()) getDirectFieldReference()->solveAllReferenceEnabledField(false);
+        }
+        else if (context->hasServer)
+          solveServerOperation();
+        solveGridReference();
+     }
+     solveGridDomainAxisRef(doSending2Server);
+     if (context->hasClient && !context->hasServer)
+     {
+       solveTransformedGrid();
+     }
+     solveCheckMaskIndex(doSending2Server);
+   }
+   CATCH_DUMP_ATTR
+   std::map<int, StdSize> CField::getGridAttributesBufferSize(CContextClient* client, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+     return grid->getAttributesBufferSize(client, bufferForWriting);
+   }
+   CATCH_DUMP_ATTR
+   std::map<int, StdSize> CField::getGridDataBufferSize(CContextClient* client, bool bufferForWriting /*= "false"*/)
+   TRY
+   {
+     return grid->getDataBufferSize(client, getId(), bufferForWriting);
+   }
+   CATCH_DUMP_ATTR
+   size_t CField::getGlobalWrittenSize()
+   TRY
+   {
+     return grid->getGlobalWrittenSize();
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   void CField::solveServerOperation(void)
+   TRY
+   {
+      CContext* context = CContext::getCurrent();
+      if (!context->hasServer || !hasOutputFile) return;
+      if (freq_op.isEmpty())
+        freq_op.setValue(TimeStep);
+      if (freq_offset.isEmpty())
+        freq_offset.setValue(NoneDu);
+      freq_operation_srv = file->output_freq.getValue();
+      freq_write_srv     = file->output_freq.getValue();
+      lastlast_Write_srv = context->getCalendar()->getInitDate();
+      last_Write_srv     = context->getCalendar()->getInitDate();
+      last_operation_srv = context->getCalendar()->getInitDate();
+      const CDuration toffset = freq_operation_srv - freq_offset.getValue() - context->getCalendar()->getTimeStep();
+      last_operation_srv     = last_operation_srv - toffset;
+        while (end != std::string::npos);
+      }
+    }
+    return gridPath ;
+  }
+  /*!
+   * Returns the filter needed to handle a self reference in the field's expression.
+   * If the needed filter does not exist, it is created, otherwise it is reused.
+   * This method should only be called when building the filter graph corresponding
+   * to the field's expression.
+   *
+   * \param gc the garbage collector to use
+   * \return the output pin corresponding to a self reference
+   */
+  std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc)
+  TRY
+  {
+    return inputFilter ;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+   * Returns the temporal filter corresponding to the field's temporal operation
+   * for the specified operation frequency. The filter is created if it does not
+   * exist, otherwise it is reused.
+   *
+   * \param gc the garbage collector to use
+   * \param outFreq the operation frequency, i.e. the frequency at which the output data will be computed
+   * \return the output pin corresponding to the requested temporal filter
+   */
+  std::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+  TRY
+  {
+    std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+    if (it == temporalDataFilters.end())
+    {
       if (operation.isEmpty())
         ERROR("void CField::solveServerOperation(void)",
+        ERROR("void CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
               << "An operation must be defined for field \"" << getId() << "\".");
+      std::shared_ptr<func::CFunctor> functor;
+      CArray<double, 1> dummyData;
+#define DECLARE_FUNCTOR(MType, mtype) \
+      if (operation.getValue().compare(#mtype) == 0) \
+      { \
+        functor.reset(new func::C##MType(dummyData)); \
+      }
+#include "functor_type.conf"
+      if (!functor)
+        ERROR("void CField::solveServerOperation(void)",
+              << "\"" << operation << "\" is not a valid operation.");
+      operationTimeType = functor->timeType();
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   /*!
+    * Constructs the graph filter for the field, enabling or not the data output.
+    * This method should not be called more than once with enableOutput equal to true.
+    *
+    * \param gc the garbage collector to use when building the filter graph
+    * \param enableOutput must be true when the field data is to be
+    *                     read by the client or/and written to a file
+    */
+   void CField::buildFilterGraph(CGarbageCollector& gc, bool enableOutput, Time start_graph, Time end_graph)
+   TRY
+   {
+     if (!isReferenceSolvedAndTransformed) solveAllEnabledFieldsAndTransform();
+     if (!isGridChecked) checkGridOfEnabledFields();
+     const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
+     const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+     CContext* context = CContext::getCurrent();
+     Time filter_start;
+     if(!build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = context->calendar->getInitDate()+build_workflow_graph_start;
+     else if(build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = 0;
+     else filter_start = -1;
+     Time filter_end;
+     if(!build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = context->calendar->getInitDate()+build_workflow_graph_end;
+     else if(build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = 9223372036854775807;
+     else filter_end = -1;
+     if(this->field_graph_start==-2) this->field_graph_start = filter_start;
+     if(this->field_graph_end==-2) this->field_graph_end = filter_end;         // init
+     // if(CXios::isClient) std::cout<<"****************** buildFilterGraph : field_id = "<<this->getId()<<" BEFORE: this->field_graph_start = "<<this->field_graph_start<<" this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     if(start_graph == -1)
+     {
+       //nothing
+       // if(CXios::isClient) std::cout<<"buildFilterGraph field_id = "<<this->getId()<<" case1: this->field_graph_start = "<<this->field_graph_start<<std::endl;
+     }
+     else //if(start_graph != -1)
+     {
+       if(this->field_graph_start == -1) this->field_graph_start = start_graph;
+       else this->field_graph_start = min(this->field_graph_start, start_graph);
+       // if(CXios::isClient) std::cout<<"buildFilterGraph field_id = "<<this->getId()<<" case2: this->field_graph_start = "<<this->field_graph_start<<std::endl;
+     }
+     if(end_graph == -1)
+     {
+       //nothing
+       // if(CXios::isClient) std::cout<<"buildFilterGraph field_id = "<<this->getId()<<" case1: this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     }
+     else
+     {
+       if(this->field_graph_end == -1) this->field_graph_end = end_graph;
+       else this->field_graph_end = max(this->field_graph_end, end_graph);
+       // if(CXios::isClient) std::cout<<"buildFilterGraph field_id = "<<this->getId()<<" case2: this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     }
+     filter_start = this->field_graph_start;
+     filter_end = this->field_graph_end;
+     // if(CXios::isClient) std::cout<<"****************** buildFilterGraph : field_id = "<<this->getId()<<" AFTER: this->field_graph_start = "<<this->field_graph_start<<" this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     bool hasWriterServer = context->hasServer && !context->hasClient;
+     bool hasIntermediateServer = context->hasServer && context->hasClient;
+     if (hasWriterServer)
+     {
+        if (!instantDataFilter)
+          instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false));
+       // If the field data is to be read by the client or/and written to a file
+       if (enableOutput && !storeFilter && !fileWriterFilter)
+       {
+         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
+           fileServerWriterFilter = std::shared_ptr<CFileServerWriterFilter>(new CFileServerWriterFilter(gc, this));
+           instantDataFilter->connectOutput(fileServerWriterFilter, 0);
+         }
+       }
+     }
+     else if (hasIntermediateServer)
+     {
+       if (!instantDataFilter)
+         instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, false));
+             // If the field data is to be read by the client or/and written to a file
+       if (enableOutput && !storeFilter && !fileWriterFilter)
+       {
+         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
+           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+           instantDataFilter->connectOutput(fileWriterFilter, 0);
+         }
+       }
+     }
+     else
+     {
+       // Start by building a filter which can provide the field's instant data
+       if (!instantDataFilter)
+       {
+         // Check if we have an expression to parse
+         if (hasExpression())
+         {
+           boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0'));
+           std::shared_ptr<COutputPin> filter = expr->reduce(gc, *this, filter_start, filter_end);
+           // Check if a spatial transformation is needed
+           if (!field_ref.isEmpty())
+           {
+             CGrid* gridRef = CField::get(field_ref)->grid;
+             if (grid && grid != gridRef && grid->hasTransform())
+             {
+               std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);
+               filter->connectOutput(filters.first, 0);
+               filter = filters.second;
+             }
+           }
+           instantDataFilter = filter;
+           instantDataFilter->field = this;
+           filter->tag = buildWorkflowGraph;
+           filter->start_graph = filter_start;
+           filter->end_graph = filter_end;
+           for(int i=0; i<filter->parent_filters.size(); i++)
+           {
+             filter->tag = filter->tag || filter->parent_filters[i]->tag;
+           }
+         }
+         // Check if we have a reference on another field
+         else if (!field_ref.isEmpty())
+         {
+           instantDataFilter = getFieldReference(gc, filter_start, filter_end);
+           instantDataFilter->tag = buildWorkflowGraph;
+           instantDataFilter->start_graph = filter_start;
+           instantDataFilter->end_graph = filter_end;
+         }
+         // Check if the data is to be read from a file
+         else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
+         {
+           checkTimeAttributes();
+           instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false, freq_offset, true,
+                                                                                                       detectMissingValues, defaultValue));
+           instantDataFilter->tag = buildWorkflowGraph;
+           instantDataFilter->start_graph = filter_start;
+           instantDataFilter->end_graph = filter_end;
+           instantDataFilter->field = this;
+         }
+         else // The data might be passed from the model
+         {
+            if (check_if_active.isEmpty()) check_if_active = false;
+            instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, true, NoneDu, false,
+                                                                                                      detectMissingValues, defaultValue));
+            instantDataFilter->tag = buildWorkflowGraph;
+            instantDataFilter->start_graph = filter_start;
+            instantDataFilter->end_graph = filter_end;
+            instantDataFilter->field = this;
+            // if(CXios::isClient) std::cout<<"***********************buildFilterGraph init source filter : field_id = "<<this->getId()<<" sourcefilter->start_graph = "<<clientSourceFilter->start_graph<<" sourcefilter->end_graph = "<<clientSourceFilter->end_graph<<std::endl;
+         }
+       }
+       // If the field data is to be read by the client or/and written to a file
+       if (enableOutput && !storeFilter && !fileWriterFilter)
+       {
+         if (!read_access.isEmpty() && read_access)
+         {
+           storeFilter = std::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid,
+                                                                          detectMissingValues, defaultValue));
+           instantDataFilter->connectOutput(storeFilter, 0);
+           storeFilter->tag = (instantDataFilter->tag || buildWorkflowGraph);
+           instantDataFilter->start_graph = filter_start;
+           instantDataFilter->end_graph = filter_end;
+           instantDataFilter->setParentFiltersTag();
+           storeFilter->start_graph = filter_start;
+           storeFilter->end_graph = filter_end;
+           storeFilter->field = this;
+           storeFilter->distance = instantDataFilter->distance+1;
+         }
+         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
+           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+           getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
+           fileWriterFilter->tag = (getTemporalDataFilter(gc, file->output_freq)->tag || buildWorkflowGraph);
+           getTemporalDataFilter(gc, file->output_freq)->start_graph = filter_start;
+           getTemporalDataFilter(gc, file->output_freq)->end_graph = filter_end;
+           getTemporalDataFilter(gc, file->output_freq)->tag = buildWorkflowGraph;
+           getTemporalDataFilter(gc, file->output_freq)->setParentFiltersTag();
+           fileWriterFilter->start_graph = filter_start;
+           fileWriterFilter->end_graph = filter_end;
+           fileWriterFilter->distance = getTemporalDataFilter(gc, file->output_freq)->distance+1;
+           // std::cout<<"CFileWriterFilter filter start = "<<filter_start<<" end = "<<filter_end<<" field = "<<this->getId()<<std::endl;
+         }
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Returns the filter needed to handle the field reference.
+    * This method should only be called when building the filter graph corresponding to the field.
+    *
+    * \param gc the garbage collector to use
+    * \return the output pin corresponding to the field reference
+    */
+   std::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc, Time start_graph, Time end_graph)
+   TRY
+   {
+     if (instantDataFilter || field_ref.isEmpty())
+       ERROR("COutputPin* CField::getFieldReference(CGarbageCollector& gc)",
+             "Impossible to get the field reference for a field which has already been parsed or which does not have a field_ref.");
+     CField* fieldRef = CField::get(field_ref);
+     fieldRef->buildFilterGraph(gc, false, start_graph, end_graph);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
+     CContext* context = CContext::getCurrent();
+     Time filter_start;
+     if(!build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = context->calendar->getInitDate()+build_workflow_graph_start;
+     else if(build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = 0;
+     else filter_start = -1;
+     Time filter_end;
+     if(!build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = context->calendar->getInitDate()+build_workflow_graph_end;
+     else if(build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = 9223372036854775807;
+     else filter_end = -1;
+     if(this->field_graph_start==-2) this->field_graph_start = filter_start;
+     if(this->field_graph_end==-2) this->field_graph_end = filter_end;         // init
+     // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" BEFORE: this->field_graph_start = "<<this->field_graph_start<<" this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     if(start_graph == -1)
+     {
+       //nothing
+       // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" case1: this->field_graph_start = "<<this->field_graph_start<<std::endl;
+     }
+     else //if(start_graph != -1)
+     {
+       if(this->field_graph_start == -1) this->field_graph_start = start_graph;
+       else this->field_graph_start = min(this->field_graph_start, start_graph);
+       // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" case2: this->field_graph_start = "<<this->field_graph_start<<std::endl;
+     }
+     if(end_graph == -1)
+     {
+       //nothing
+       // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" case1: this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     }
+     else
+     {
+       if(this->field_graph_end == -1) this->field_graph_end = end_graph;
+       else this->field_graph_end = max(this->field_graph_end, end_graph);
+       // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" case2: this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     }
+     filter_start = this->field_graph_start;
+     filter_end = this->field_graph_end;
+     // if(CXios::isClient) std::cout<<"getFieldReference field_id = "<<this->getId()<<" AFTER: this->field_graph_start = "<<this->field_graph_start<<" this->field_graph_end = "<<this->field_graph_end<<std::endl;
+     std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters;
+     // Check if a spatial transformation is needed
+     if (grid && grid != fieldRef->grid && grid->hasTransform())
+     {
+       bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+       double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue);
+       fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
+       filters.second->parent_filters.resize(1);
+       filters.second->parent_filters[0]= fieldRef->getInstantDataFilter();
+       filters.second->tag = (buildWorkflowGraph || filters.second->parent_filters[0]->tag);
+       filters.second->start_graph = filter_start;
+       filters.second->end_graph = filter_end;
+       filters.second->field = this;
+     }
+     else
+     {
+       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc));
+       fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
+       filters.second->parent_filters.resize(1);
+       filters.second->parent_filters[0]= fieldRef->getInstantDataFilter();
+       filters.second->tag = (buildWorkflowGraph || filters.second->parent_filters[0]->tag);
+       filters.second->start_graph = filter_start;
+       filters.second->end_graph = filter_end;
+       filters.second->field = this;
+     }
+     return filters.second;
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Returns the filter needed to handle a self reference in the field's expression.
+    * If the needed filter does not exist, it is created, otherwise it is reused.
+    * This method should only be called when building the filter graph corresponding
+    * to the field's expression.
+    *
+    * \param gc the garbage collector to use
+    * \return the output pin corresponding to a self reference
+    */
+   std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc, Time start_graph, Time end_graph)
+   TRY
+   {
+     if(CXios::isClient) std::cout<<"getSelfReference field_id = "<<this->getId()<<" start_graph = "<<start_graph<<" end_graph = "<<end_graph<<std::endl;
+     if (instantDataFilter || !hasExpression())
+       ERROR("COutputPin* CField::getSelfReference(CGarbageCollector& gc)",
+             "Impossible to add a self reference to a field which has already been parsed or which does not have an expression.");
+     bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
+     if (!selfReferenceFilter)
+     {
+       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+       const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+       if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
+       {
+         if (!serverSourceFilter)
+         {
+           checkTimeAttributes();
+           serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false, freq_offset, true,
+                                                                                   detectMissingValues, defaultValue));
+         }
+         selfReferenceFilter = serverSourceFilter;
+       }
+       else if (!field_ref.isEmpty())
+       {
+         CField* fieldRef = CField::get(field_ref);
+         fieldRef->buildFilterGraph(gc, false);
+         selfReferenceFilter = fieldRef->getInstantDataFilter();
+       }
+       else
+       {
+         if (!clientSourceFilter)
+         {
+           if (check_if_active.isEmpty()) check_if_active = false;
+           clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, true, NoneDu, false,
+                                                                                   detectMissingValues, defaultValue));
+         }
+         selfReferenceFilter = clientSourceFilter;
+       }
+     }
+     selfReferenceFilter->tag = buildWorkflowGraph;
+     selfReferenceFilter->field = this;
+     return selfReferenceFilter;
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Returns the temporal filter corresponding to the field's temporal operation
+    * for the specified operation frequency. The filter is created if it does not
+    * exist, otherwise it is reused.
+    *
+    * \param gc the garbage collector to use
+    * \param outFreq the operation frequency, i.e. the frequency at which the output data will be computed
+    * \return the output pin corresponding to the requested temporal filter
+    */
+   std::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   TRY
+   {
+     std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
+     CContext* context = CContext::getCurrent();
+     if (it == temporalDataFilters.end())
+     {
+       if (operation.isEmpty())
+         ERROR("void CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
+               << "An operation must be defined for field \"" << getId() << "\".");
+       checkTimeAttributes(&outFreq);
+       const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true);
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+      checkTimeAttributes(&outFreq);
+      const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true);
+      std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
                                                                              CContext::getCurrent()->getCalendar()->getInitDate(),
                                                                              freq_op, freq_offset, outFreq, detectMissingValues));
+       instantDataFilter->connectOutput(temporalFilter, 0);
+       // temporalFilter->tag = buildWorkflowGraph;
+       temporalFilter->parent_filters.resize(1);
+       temporalFilter->parent_filters[0] = instantDataFilter;
+       if(temporalFilter->parent_filters[0]->tag) temporalFilter->tag=true;
+       // temporalFilter->start_graph = filter_start;
+       // temporalFilter->end_graph = filter_end;
+       temporalFilter->field = this;
+       it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
+     }
+     return it->second;
+   }
+   CATCH_DUMP_ATTR
+      instantDataFilter->connectOutput(temporalFilter, 0);
+      const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+      if(buildGraph_)
+      {
+        std::cout<<"============== field "<<this->getId()<<" calls a getTemporalDataFilter  ============== "<<instantDataFilter << " _ "<<temporalFilter<<" ***** "<<CXios::isClient<<std::endl;
+        temporalFilter->graphPackage = new CGraphPackage;
+        temporalFilter->graphEnabled = true;
+        temporalFilter->graphPackage->inFields.push_back(this);
+      }
+      it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
+    }
+    return it->second;
+  }
+  CATCH_DUMP_ATTR
   /*!
 …
     * \return the output pin corresponding to the requested temporal filter
     */
+   std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   TRY
+   {
+     if (instantDataFilter || !hasExpression())
+       ERROR("COutputPin* CField::getSelfTemporalDataFilter(CGarbageCollector& gc)",
+             "Impossible to add a self reference to a field which has already been parsed or which does not have an expression.");
+     if (!selfReferenceFilter) getSelfReference(gc) ;
+     if (serverSourceFilter || clientSourceFilter)
+     {
+       if (operation.isEmpty())
+         ERROR("void CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
+               << "An operation must be defined for field \"" << getId() << "\".");
+       checkTimeAttributes(&outFreq);
+       const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true);
+       bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+                                                                           CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                           freq_op, freq_offset, outFreq, detectMissingValues));
+       selfReferenceFilter->connectOutput(temporalFilter, 0);
+       temporalFilter->tag = buildWorkflowGraph;
+       temporalFilter->field = this;
+       return temporalFilter ;
+     }
+     else if (!field_ref.isEmpty())
+     {
+       CField* fieldRef = CField::get(field_ref);
+       fieldRef->buildFilterGraph(gc, false);
+       return fieldRef->getTemporalDataFilter(gc, outFreq) ;
+     }
+  }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+  std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+  TRY
+  {
+    if (instantDataFilter || !hasExpression())
+      ERROR("COutputPin* CField::getSelfTemporalDataFilter(CGarbageCollector& gc)",
+            "Impossible to add a self reference to a field which has already been parsed or which does not have an expression.");
+    if (selfTemporalDataFilter) return selfTemporalDataFilter;
+    if (hasDirectFieldReference())
+    {
+      CField* fieldRef=getDirectFieldReference();
+      return fieldRef->getTemporalDataFilter(gc, outFreq) ;
+    }
+    else
+    {
+      if (selfTemporalDataFilter) return selfTemporalDataFilter ;
+      if (operation.isEmpty())
+        ERROR("void CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
+              << "An operation must be defined for field \"" << getId() << "\".");
+      checkTimeAttributes(&outFreq); //bof
+      const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true);
+      selfTemporalDataFilter = std::shared_ptr<CTemporalFilter>(new CTemporalFilter(gc, operation,
+                                                                CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                freq_op, freq_offset, outFreq, detectMissingValues));
+      inputFilter->connectOutput(selfTemporalDataFilter, 0);
+      const bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ;
+      if(buildGraph_)
+      {
+        std::cout<<"============== field "<<this->getId()<<" calls a getSelfTemporalDataFilter  ============== "<<inputFilter << " _ "<<selfTemporalDataFilter<<" ***** "<<CXios::isClient<<std::endl;
+        selfTemporalDataFilter->graphPackage = new CGraphPackage;
+        selfTemporalDataFilter->graphEnabled = true;
+        selfTemporalDataFilter->graphPackage->inFields.push_back(this);
+      }
+      return selfTemporalDataFilter ;
+    }
+  }
+  CATCH_DUMP_ATTR
+  //----------------------------------------------------------------
 /*
    void CField::fromBinary(StdIStream& is)
 …
    //----------------------------------------------------------------
+   void CField::solveGridReference(void)
+  void CField::solveGridReference(void)
+  TRY
+  {
+    if (grid_!=nullptr) return ; // already done
+    if (grid_ref.isEmpty() && domain_ref.isEmpty() && axis_ref.isEmpty() && scalar_ref.isEmpty())
+    {
+      ERROR("CField::solveGridReference(void)",
+            << "A grid must be defined for field '" << getFieldOutputName() << "' .");
+    }
+    else if (!grid_ref.isEmpty() && (!domain_ref.isEmpty() || !axis_ref.isEmpty() || !scalar_ref.isEmpty()))
+    {
+      ERROR("CField::solveGridReference(void)",
+            << "Field '" << getFieldOutputName() << "' has both a grid and a domain/axis/scalar." << std::endl
+            << "Please define either 'grid_ref' or 'domain_ref'/'axis_ref'/'scalar_ref'.");
+    }
+    if (grid_ref.isEmpty())
+    {
+      std::vector<CDomain*> vecDom;
+      std::vector<CAxis*> vecAxis;
+      std::vector<CScalar*> vecScalar;
+      std::vector<int> axisDomainOrderTmp;
+      std::vector<CDomain*> vecDomRef;
+      std::vector<CAxis*> vecAxisRef;
+      std::vector<CScalar*> vecScalarRef;
+      if (!domain_ref.isEmpty())
+      {
+        StdString tmp = domain_ref.getValue();
+        if (CDomain::has(domain_ref))
+        {
+          vecDom.push_back(CDomain::get(domain_ref));
+          vecDomRef.push_back(CDomain::createDomain());
+          vecDomRef.back()->domain_ref=domain_ref;
+          axisDomainOrderTmp.push_back(2);
+        }
+        else  ERROR("CField::solveGridReference(void)",
+                    << "Invalid reference to domain '" << domain_ref.getValue() << "'.");
+      }
+      if (!axis_ref.isEmpty())
+      {
+        if (CAxis::has(axis_ref))
+        {
+          vecAxis.push_back(CAxis::get(axis_ref));
+          vecAxisRef.push_back(CAxis::createAxis());
+          vecAxisRef.back()->axis_ref=axis_ref;
+          axisDomainOrderTmp.push_back(1);
+        }
+        else  ERROR("CField::solveGridReference(void)",
+                    << "Invalid reference to axis '" << axis_ref.getValue() << "'.");
+      }
+      if (!scalar_ref.isEmpty())
+      {
+        if (CScalar::has(scalar_ref))
+        {
+          vecScalar.push_back(CScalar::get(scalar_ref));
+          vecScalarRef.push_back(CScalar::createScalar());
+          vecScalarRef.back()->scalar_ref=scalar_ref;
+          axisDomainOrderTmp.push_back(0);
+        }
+        else ERROR("CField::solveGridReference(void)",
+                   << "Invalid reference to scalar '" << scalar_ref.getValue() << "'.");
+      }
+      CArray<int,1> axisDomainOrder(axisDomainOrderTmp.size());
+      for (int idx = 0; idx < axisDomainOrderTmp.size(); ++idx)
+      {
+        axisDomainOrder(idx) = axisDomainOrderTmp[idx];
+      }
+      // Warning: the gridId shouldn't be set as the grid_ref since it could be inherited
+      StdString gridId = CGrid::generateId(vecDom, vecAxis, vecScalar,axisDomainOrder);
+      if (CGrid::has(gridId)) this->grid_ = CGrid::get(gridId);
+      else  this->grid_ = CGrid::createGrid(gridId, vecDomRef, vecAxisRef, vecScalarRef,axisDomainOrder);
+    }
+    else
+    {
+      if (CGrid::has(grid_ref)) this->grid_ = CGrid::get(grid_ref);
+      else  ERROR("CField::solveGridReference(void)",
+                   << "Invalid reference to grid '" << grid_ref.getValue() << "'.");
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CField::solveGridDomainAxisRef(bool checkAtt)
+  TRY
+  {
+    grid_->solveDomainAxisRef(checkAtt);
+  }
+  CATCH_DUMP_ATTR
+  void CField::solveCheckMaskIndex(bool doSendingIndex)
+  TRY
+  {
+    grid_->checkMaskIndex(doSendingIndex);
+  }
+  CATCH_DUMP_ATTR
+  void CField::solveGridDomainAxisBaseRef()
+  TRY
+  {
+    grid_->solveDomainAxisRef(false);
+    grid_->solveDomainAxisBaseRef();
+  }
+  CATCH_DUMP_ATTR
+  ///-------------------------------------------------------------------
+  template <>
+  void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
+  TRY
+  {
+    if (this->group_ref.isEmpty()) return;
+    StdString gref = this->group_ref.getValue();
+    if (!CFieldGroup::has(gref))
+      ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
+         << "[ gref = " << gref << "]"
+         << " invalid group name !");
+    CFieldGroup* group = CFieldGroup::get(gref);
+    CFieldGroup* owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this));
+    owner->setAttributes(group); // inherite of attributes of group reference
+    std::vector<CField*> allChildren  = group->getAllChildren();
+    std::vector<CField*>::iterator it = allChildren.begin(), end = allChildren.end();
+    for (; it != end; it++)
+    {
+      CField* child = *it;
+     if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId());
+    }
+  }
+  CATCH_DUMP_ATTR
+  ///-------------------------------------------------------------------
+  void CField::parse(xml::CXMLNode& node)
+  TRY
+  {
+    string newContent ;
+    SuperClass::parse(node);
+    if (node.goToChildElement())
+    {
+      do
+      {
+        if (node.getElementName() == "variable" || node.getElementName() == "variable_group") this->getVirtualVariableGroup()->parseChild(node);
+        else if (node.getElementName() == "expr") if (node.getContent(newContent)) content+=newContent ;
+      } while (node.goToNextElement());
+      node.goToParentElement();
+    }
+    if (node.getContent(newContent)) content=newContent ;
+  }
+  CATCH_DUMP_ATTR
+ /*!
+   This function retrieves Id of corresponding domain_ref and axis_ref (if any)
+   of a field. In some cases, only domain exists but axis doesn't
+   \return pair of Domain and Axis id
+  */
+  const std::vector<StdString>& CField::getRefDomainAxisIds()
+  TRY
+  {
+    CGrid* cgPtr = getRelGrid();
+    if (NULL != cgPtr)
+    {
+      std::vector<StdString>::iterator it;
+      if (!domain_ref.isEmpty())
+      {
+        std::vector<StdString> domainList = cgPtr->getDomainList();
+        it = std::find(domainList.begin(), domainList.end(), domain_ref.getValue());
+        if (domainList.end() != it) domAxisScalarIds_[0] = *it;
+      }
+      if (!axis_ref.isEmpty())
+      {
+        std::vector<StdString> axisList = cgPtr->getAxisList();
+        it = std::find(axisList.begin(), axisList.end(), axis_ref.getValue());
+        if (axisList.end() != it) domAxisScalarIds_[1] = *it;
+      }
+      if (!scalar_ref.isEmpty())
+      {
+        std::vector<StdString> scalarList = cgPtr->getScalarList();
+        it = std::find(scalarList.begin(), scalarList.end(), scalar_ref.getValue());
+        if (scalarList.end() != it) domAxisScalarIds_[2] = *it;
+      }
+    }
+    return (domAxisScalarIds_);
+  }
+  CATCH_DUMP_ATTR
+  CVariable* CField::addVariable(const string& id)
+  TRY
+  {
+    return vVariableGroup->createChild(id);
+  }
+  CATCH
+  CVariableGroup* CField::addVariableGroup(const string& id)
+  TRY
+  {
+    return vVariableGroup->createChildGroup(id);
+  }
+  CATCH
+  void CField::setContextClient(CContextClient* contextClient)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    client = contextClient;
+    // A grid is sent by a client (both for read or write) or by primary server (write only)
+    if (context->getServiceType()==CServicesManager::GATHERER)
+    {
+      if (getRelFile()->mode.isEmpty() || (!getRelFile()->mode.isEmpty() && getRelFile()->mode == CFile::mode_attr::write))
+        grid_->setContextClient(contextClient);
+    }
+    else if (context->getServiceType()==CServicesManager::CLIENT)
+      grid_->setContextClient(contextClient);
+  }
+  CATCH_DUMP_ATTR
+  void CField::sendCloseDefinition(void)
+  {
+    CContext::getCurrent()->sendCloseDefinition(client) ;
+  }
+  void CField::sendFieldToFileServer(void)
+  {
+    CContext::getCurrent()->sendContextToFileServer(client);
+    getRelFile()->sendFileToFileServer(client);
+    sentGrid_ = grid_-> duplicateSentGrid() ;
+    sentGrid_->sendGridToFileServer(client);
+    name = getFieldOutputName() ;
+    this->sendAllAttributesToServer(client);
+    this->sendAddAllVariables(client);
+  }
+  void CField::sendFieldToInputFileServer(void)
+  {
+    CContext::getCurrent()->sendContextToFileServer(client);
+    getRelFile()->sendFileToFileServer(client);
+    sentGrid_ = grid_-> duplicateSentGrid() ;
+    sentGrid_->sendGridToFileServer(client);
+    read_access=true ; // not the best solution, but on server side, the field must be a starting point of the workflow
+                       // must be replace by a better solution when implementing filters for reading and send to client
+                       // on server side
+    this->sendAllAttributesToServer(client);
+    this->sendAddAllVariables(client);
+  }
+  void CField::sendFieldToCouplerOut(void)
+  {
+    if (sendFieldToCouplerOut_done_) return ;
+    else sendFieldToCouplerOut_done_=true ;
+    grid_->sendGridToCouplerOut(client, this->getId());
+    this->sendGridCompleted();
+  }
+  void CField::makeGridAliasForCoupling(void)
+  {
+    grid_->makeAliasForCoupling(this->getId());
+  }
+ //! Client side: Send a message  announcing that the grid definition has been received from a coupling context
+   void CField::sendGridCompleted(void)
    TRY
+   {
+      if (grid_ref.isEmpty() && domain_ref.isEmpty() && axis_ref.isEmpty() && scalar_ref.isEmpty())
+      {
+        ERROR("CField::solveGridReference(void)",
+              << "A grid must be defined for field '" << getFieldOutputName() << "' .");
+      }
+      else if (!grid_ref.isEmpty() && (!domain_ref.isEmpty() || !axis_ref.isEmpty() || !scalar_ref.isEmpty()))
+      {
+        ERROR("CField::solveGridReference(void)",
+              << "Field '" << getFieldOutputName() << "' has both a grid and a domain/axis/scalar." << std::endl
+              << "Please define either 'grid_ref' or 'domain_ref'/'axis_ref'/'scalar_ref'.");
+      }
+      if (grid_ref.isEmpty())
+      {
+        std::vector<CDomain*> vecDom;
+        std::vector<CAxis*> vecAxis;
+        std::vector<CScalar*> vecScalar;
+        std::vector<int> axisDomainOrderTmp;
+        std::vector<CDomain*> vecDomRef;
+        std::vector<CAxis*> vecAxisRef;
+        std::vector<CScalar*> vecScalarRef;
+        if (!domain_ref.isEmpty())
+        {
+          StdString tmp = domain_ref.getValue();
+          if (CDomain::has(domain_ref))
+          {
+            vecDom.push_back(CDomain::get(domain_ref));
+            vecDomRef.push_back(CDomain::createDomain());
+            vecDomRef.back()->domain_ref=domain_ref;
+            axisDomainOrderTmp.push_back(2);
+          }
+          else  ERROR("CField::solveGridReference(void)",
+                      << "Invalid reference to domain '" << domain_ref.getValue() << "'.");
+        }
+        if (!axis_ref.isEmpty())
+        {
+          if (CAxis::has(axis_ref))
+          {
+            vecAxis.push_back(CAxis::get(axis_ref));
+            vecAxisRef.push_back(CAxis::createAxis());
+            vecAxisRef.back()->axis_ref=axis_ref;
+            axisDomainOrderTmp.push_back(1);
+          }
+          else  ERROR("CField::solveGridReference(void)",
+                      << "Invalid reference to axis '" << axis_ref.getValue() << "'.");
+        }
+        if (!scalar_ref.isEmpty())
+        {
+          if (CScalar::has(scalar_ref))
+          {
+            vecScalar.push_back(CScalar::get(scalar_ref));
+            vecScalarRef.push_back(CScalar::createScalar());
+            vecScalarRef.back()->scalar_ref=scalar_ref;
+            axisDomainOrderTmp.push_back(0);
+          }
+          else ERROR("CField::solveGridReference(void)",
+                     << "Invalid reference to scalar '" << scalar_ref.getValue() << "'.");
+        }
+        CArray<int,1> axisDomainOrder(axisDomainOrderTmp.size());
+        for (int idx = 0; idx < axisDomainOrderTmp.size(); ++idx)
+        {
+          axisDomainOrder(idx) = axisDomainOrderTmp[idx];
+        }
+        // Warning: the gridId shouldn't be set as the grid_ref since it could be inherited
+        StdString gridId = CGrid::generateId(vecDom, vecAxis, vecScalar,axisDomainOrder);
+        if (CGrid::has(gridId)) this->grid = CGrid::get(gridId);
+        else  this->grid = CGrid::createGrid(gridId, vecDomRef, vecAxisRef, vecScalarRef,axisDomainOrder);
+      }
+      else
+      {
+        if (CGrid::has(grid_ref)) this->grid = CGrid::get(grid_ref);
+        else  ERROR("CField::solveGridReference(void)",
+                     << "Invalid reference to grid '" << grid_ref.getValue() << "'.");
+      }
+      CEventClient event(getType(),EVENT_ID_GRID_COMPLETED);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg<<this->getId();
+        for (auto& rank : client->getRanksServerLeader()) event.push(rank,1,msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+   }
    CATCH_DUMP_ATTR
+   void CField::solveGridDomainAxisRef(bool checkAtt)
+   //! Server side: Receive a message announcing that the grid definition has been received from a coupling context
+   void CField::recvGridCompleted(CEventServer& event)
    TRY
+   {
+     grid->solveDomainAxisRef(checkAtt);
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id ;
+      get(id)->recvGridCompleted(*buffer);
+   }
+   CATCH
+   //! Server side: Receive a message  message  announcing that the grid definition has been received from a coupling context
+   void CField::recvGridCompleted(CBufferIn& buffer)
+   TRY
+   {
+      setGridCompleted() ;
+   }
    CATCH_DUMP_ATTR
+   void CField::solveCheckMaskIndex(bool doSendingIndex)
+   TRY
+   {
+     grid->checkMaskIndex(doSendingIndex);
+   }
+   CATCH_DUMP_ATTR
+   void CField::solveTransformedGrid()
+   TRY
+   {
+     if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
+     {
+       std::vector<CGrid*> grids;
+       // Source grid
+       grids.push_back(getDirectFieldReference()->grid);
+       // Intermediate grids
+       if (!grid_path.isEmpty())
+       {
+         std::string gridId;
+         size_t start = 0, end;
+         do
+         {
+           end = grid_path.getValue().find(',', start);
+           if (end != std::string::npos)
+           {
+             gridId = grid_path.getValue().substr(start, end - start);
+             start = end + 1;
+           }
+           else
+             gridId = grid_path.getValue().substr(start);
+           if (!CGrid::has(gridId))
+             ERROR("void CField::solveTransformedGrid()",
+                   << "Invalid grid_path, the grid '" << gridId << "' does not exist.");
+           grids.push_back(CGrid::get(gridId));
+         }
+         while (end != std::string::npos);
+       }
+       // Destination grid
+       grids.push_back(grid);
+       for (size_t i = 0, count = grids.size() - 1; i < count; ++i)
+       {
+         CGrid *gridSrc  = grids[i];
+         CGrid *gridDest = grids[i + 1];
+         if (!gridDest->isTransformed())
+           gridDest->transformGrid(gridSrc);
+       }
+     }
+     else if (grid && grid->hasTransform() && !grid->isTransformed())
+     {
+       // Temporarily deactivate the self-transformation of grid
+       // grid->transformGrid(grid);
+     }
+   }
+   CATCH_DUMP_ATTR
+   void CField::solveGenerateGrid()
+   TRY
+   {
+     if (grid && !grid->isTransformed() && hasDirectFieldReference() && grid != getDirectFieldReference()->grid)
+       grid->completeGrid(getDirectFieldReference()->grid);
+     else
+       grid->completeGrid();
+   }
+   CATCH_DUMP_ATTR
+   void CField::solveGridDomainAxisBaseRef()
+   TRY
+   {
+     grid->solveDomainAxisRef(false);
+     grid->solveDomainAxisBaseRef();
+   }
+   CATCH_DUMP_ATTR
+   ///-------------------------------------------------------------------
+   template <>
+   void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
+   TRY
+   {
+      if (this->group_ref.isEmpty()) return;
+      StdString gref = this->group_ref.getValue();
+      if (!CFieldGroup::has(gref))
+         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
+               << "[ gref = " << gref << "]"
+               << " invalid group name !");
+      CFieldGroup* group = CFieldGroup::get(gref);
+      CFieldGroup* owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this));
+      owner->setAttributes(group); // inherite of attributes of group reference
+      std::vector<CField*> allChildren  = group->getAllChildren();
+      std::vector<CField*>::iterator it = allChildren.begin(), end = allChildren.end();
+      for (; it != end; it++)
+      {
+         CField* child = *it;
+         if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId());
+      }
+   }
+   CATCH_DUMP_ATTR
+   void CField::scaleFactorAddOffset(double scaleFactor, double addOffset)
+   TRY
+   {
+     recvDataSrv = (recvDataSrv - addOffset) / scaleFactor;
+   }
+   CATCH_DUMP_ATTR
+   void CField::invertScaleFactorAddOffset(double scaleFactor, double addOffset)
+   TRY
+   {
+     recvDataSrv = recvDataSrv * scaleFactor + addOffset;
+   }
+   CATCH_DUMP_ATTR
+   void CField::outputField(CArray<double,1>& fieldOut)
+   TRY
+   {
+      CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
+      CArray<size_t,1>& outIndexServer = grid->localIndexToWriteOnServer;
+      for (size_t idx = 0; idx < outIndexServer.numElements(); ++idx)
+      {
+        fieldOut(outIndexServer(idx)) = recvDataSrv(outIndexClient(idx));
+      }
+   }
+   CATCH_DUMP_ATTR
+   void CField::inputField(CArray<double,1>& fieldIn)
+   TRY
+   {
+      CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
+      CArray<size_t,1>& outIndexServer = grid->localIndexToWriteOnServer;
+      for (size_t idx = 0; idx < outIndexServer.numElements(); ++idx)
+      {
+        recvDataSrv(outIndexClient(idx)) = fieldIn(outIndexServer(idx));
+      }
+   }
+   CATCH_DUMP_ATTR
+   void CField::outputCompressedField(CArray<double,1>& fieldOut)
+   TRY
+   {
+      CArray<size_t,1>& outIndexClient = grid->localIndexToWriteOnClient;
+      CArray<size_t,1>& outIndexServer = grid->localIndexToWriteOnServer;
+      for (size_t idx = 0; idx < outIndexServer.numElements(); ++idx)
+      {
+        fieldOut((idx)) = recvDataSrv(outIndexClient(idx));
+      }
+   }
+   CATCH_DUMP_ATTR
+   ///-------------------------------------------------------------------
+   void CField::parse(xml::CXMLNode& node)
+   TRY
+   {
+      string newContent ;
+      SuperClass::parse(node);
+      if (node.goToChildElement())
+      {
+        do
+        {
+          if (node.getElementName() == "variable" || node.getElementName() == "variable_group") this->getVirtualVariableGroup()->parseChild(node);
+          else if (node.getElementName() == "expr") if (node.getContent(newContent)) content+=newContent ;
+        } while (node.goToNextElement());
+        node.goToParentElement();
+      }
+      if (node.getContent(newContent)) content=newContent ;
+    }
+   CATCH_DUMP_ATTR
+   /*!
+     This function retrieves Id of corresponding domain_ref and axis_ref (if any)
+   of a field. In some cases, only domain exists but axis doesn't
+   \return pair of Domain and Axis id
+  void CField::sendAddAllVariables(CContextClient* client)
+  TRY
+  {
+    std::vector<CVariable*> allVar = getAllVariables();
+    std::vector<CVariable*>::const_iterator it = allVar.begin();
+    std::vector<CVariable*>::const_iterator itE = allVar.end();
+    for (; it != itE; ++it)
+    {
+      this->sendAddVariable((*it)->getId(), client);
+      (*it)->sendAllAttributesToServer(client);
+      (*it)->sendValue(client);
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+   * Send all Attributes to server. This method is overloaded, since only grid_ref attribute
+   * must be sent to server and not domain_ref/axis_ref/scalar_ref.
    */
-   const std::vector<StdString>& CField::getRefDomainAxisIds()
-   TRY
+   {
-     CGrid* cgPtr = getRelGrid();
-     if (NULL != cgPtr)
+     {
-       std::vector<StdString>::iterator it;
-       if (!domain_ref.isEmpty())
+       {
-         std::vector<StdString> domainList = cgPtr->getDomainList();
-         it = std::find(domainList.begin(), domainList.end(), domain_ref.getValue());
-         if (domainList.end() != it) domAxisScalarIds_[0] = *it;
+       }
-       if (!axis_ref.isEmpty())
+       {
-         std::vector<StdString> axisList = cgPtr->getAxisList();
-         it = std::find(axisList.begin(), axisList.end(), axis_ref.getValue());
-         if (axisList.end() != it) domAxisScalarIds_[1] = *it;
+       }
-       if (!scalar_ref.isEmpty())
+       {
-         std::vector<StdString> scalarList = cgPtr->getScalarList();
-         it = std::find(scalarList.begin(), scalarList.end(), scalar_ref.getValue());
-         if (scalarList.end() != it) domAxisScalarIds_[2] = *it;
+       }
+     }
-     return (domAxisScalarIds_);
+   }
-   CATCH_DUMP_ATTR
-   CVariable* CField::addVariable(const string& id)
-   TRY
+   {
-     return vVariableGroup->createChild(id);
+   }
-   CATCH
-   CVariableGroup* CField::addVariableGroup(const string& id)
-   TRY
+   {
-     return vVariableGroup->createChildGroup(id);
+   }
-   CATCH
-   void CField::setContextClient(CContextClient* contextClient)
-   TRY
+   {
-     CContext* context = CContext::getCurrent();
-     client = contextClient;
-     if (context->hasClient)
+     {
-       // A grid is sent by a client (both for read or write) or by primary server (write only)
-       if (context->hasServer)
+       {
-         if (file->mode.isEmpty() || (!file->mode.isEmpty() && file->mode == CFile::mode_attr::write))
-           grid->setContextClient(contextClient);
+       }
-       else
-           grid->setContextClient(contextClient);
+     }
+   }
-   CATCH_DUMP_ATTR
-   CContextClient* CField::getContextClient()
-   TRY
+   {
-     return client;
+   }
-   CATCH
-   void CField::sendAddAllVariables(CContextClient* client)
-   TRY
+   {
-     std::vector<CVariable*> allVar = getAllVariables();
-     std::vector<CVariable*>::const_iterator it = allVar.begin();
-     std::vector<CVariable*>::const_iterator itE = allVar.end();
-     for (; it != itE; ++it)
+     {
-       this->sendAddVariable((*it)->getId(), client);
-       (*it)->sendAllAttributesToServer(client);
-       (*it)->sendValue(client);
+     }
+   }
-   CATCH_DUMP_ATTR
-   /*!
-    * Send all Attributes to server. This method is overloaded, since only grid_ref attribute
-    * must be sent to server and not domain_ref/axis_ref/scalar_ref.
-    */
+   void CField::sendAllAttributesToServer(CContextClient* client)
+   TRY
+   {
+     if (grid_ref.isEmpty())
+     {
+       grid_ref=grid->getId() ;
+       SuperClass::sendAllAttributesToServer(client) ;
+       grid_ref.reset();
+     }
+     else SuperClass::sendAllAttributesToServer(client) ;
+   }
+   CATCH_DUMP_ATTR
+  void CField::sendAllAttributesToServer(CContextClient* client)
+  TRY
+  {
+    if (grid_ref.isEmpty())
+    {
+      grid_ref=sentGrid_->getId() ;
+      SuperClass::sendAllAttributesToServer(client) ;
+      domain_ref.reset() ;
+      axis_ref.reset() ;
+      scalar_ref.reset() ;
+      grid_ref.reset();
+    }
+    else
+    {
+      string tmp = grid_ref;
+      grid_ref = sentGrid_->getId() ;
+      SuperClass::sendAllAttributesToServer(client) ;
+      grid_ref = tmp ;
+    }
+  }
+  CATCH_DUMP_ATTR
+   void CField::sendAddVariable(const string& id, CContextClient* client)
+   TRY
+   {
+      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE, client);
+   }
+   CATCH_DUMP_ATTR
+   void CField::sendAddVariableGroup(const string& id, CContextClient* client)
+   TRY
+   {
+      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP, client);
+   }
+   CATCH_DUMP_ATTR
+   void CField::recvAddVariable(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer = event.subEvents.begin()->buffer;
+      string id;
+      *buffer >> id;
+      get(id)->recvAddVariable(*buffer);
+   }
+   CATCH
+   void CField::recvAddVariable(CBufferIn& buffer)
+   TRY
+   {
+      string id;
+      buffer >> id;
+      addVariable(id);
+   }
+   CATCH_DUMP_ATTR
+   void CField::recvAddVariableGroup(CEventServer& event)
+   TRY
+   {
+      CBufferIn* buffer = event.subEvents.begin()->buffer;
+      string id;
+      *buffer >> id;
+      get(id)->recvAddVariableGroup(*buffer);
+   }
+   CATCH
+   void CField::recvAddVariableGroup(CBufferIn& buffer)
+   TRY
+   {
+      string id;
+      buffer >> id;
+      addVariableGroup(id);
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Check on freq_off and freq_op attributes.
+    */
+   void CField::checkTimeAttributes(CDuration* freqOp)
+   TRY
+   {
+     bool isFieldRead  = file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read;
+     bool isFieldWrite = file && ( file->mode.isEmpty() ||  file->mode == CFile::mode_attr::write);
+     if (isFieldRead && !(operation.getValue() == "instant" || operation.getValue() == "once") )
+       ERROR("void CField::checkTimeAttributes(void)",
+             << "Unsupported operation for field '" << getFieldOutputName() << "'." << std::endl
+             << "Currently only \"instant\" is supported for fields read from file.")
+     if (freq_op.isEmpty())
+     {
+       if (operation.getValue() == "instant")
+       {
+         if (isFieldRead || isFieldWrite) freq_op.setValue(file->output_freq.getValue());
+         else freq_op=*freqOp ;
+       }
+       else
+         freq_op.setValue(TimeStep);
+     }
+     if (freq_offset.isEmpty())
+       freq_offset.setValue(isFieldRead ? NoneDu : (freq_op.getValue() - TimeStep));
+   }
+   CATCH_DUMP_ATTR
+   /*!
+    * Returns string arithmetic expression associated to the field.
+    * \return if content is defined return content string, otherwise, if "expr" attribute is defined, return expr string.
+    */
+   const string& CField::getExpression(void)
+   TRY
+   {
+     if (!expr.isEmpty() && content.empty())
+     {
+       content = expr;
+       expr.reset();
+     }
+     return content;
+   }
+   CATCH_DUMP_ATTR
+   bool CField::hasExpression(void) const
+   TRY
+   {
+     return (!expr.isEmpty() || !content.empty());
+   }
+   CATCH
+   bool CField::hasGridMask(void) const
+   TRY
+   {
+     return (this->grid->hasMask());
+   }
+   CATCH
+   DEFINE_REF_FUNC(Field,field)
+  void CField::sendAddVariable(const string& id, CContextClient* client)
+  TRY
+  {
+    sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE, client);
+  }
+  CATCH_DUMP_ATTR
+  void CField::sendAddVariableGroup(const string& id, CContextClient* client)
+  TRY
+  {
+    sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP, client);
+  }
+  CATCH_DUMP_ATTR
+  void CField::recvAddVariable(CEventServer& event)
+  TRY
+  {
+    CBufferIn* buffer = event.subEvents.begin()->buffer;
+    string id;
+    *buffer >> id;
+    get(id)->recvAddVariable(*buffer);
+  }
+  CATCH
+  void CField::recvAddVariable(CBufferIn& buffer)
+  TRY
+  {
+    string id;
+    buffer >> id;
+    addVariable(id);
+  }
+  CATCH_DUMP_ATTR
+  void CField::recvAddVariableGroup(CEventServer& event)
+  TRY
+  {
+    CBufferIn* buffer = event.subEvents.begin()->buffer;
+    string id;
+    *buffer >> id;
+    get(id)->recvAddVariableGroup(*buffer);
+  }
+  CATCH
+  void CField::recvAddVariableGroup(CBufferIn& buffer)
+  TRY
+  {
+    string id;
+    buffer >> id;
+    addVariableGroup(id);
+  }
+  CATCH_DUMP_ATTR
+  /*!
+   * Check on freq_off and freq_op attributes.
+   */
+  void CField::checkTimeAttributes(CDuration* freqOp)
+  TRY
+  {
+    if (hasFileIn() && !(operation.getValue() == "instant" || operation.getValue() == "once") )
+      ERROR("void CField::checkTimeAttributes(void)",
+         << "Unsupported operation for field '" << getFieldOutputName() << "'." << std::endl
+         << "Currently only \"instant\" is supported for fields read from file.")
+    if (freq_op.isEmpty())
+    {
+      if (operation.getValue() == "instant")
+      {
+        if (hasFileIn() || hasFileOut()) freq_op.setValue(getRelFile()->output_freq.getValue());
+        else freq_op=*freqOp ;
+      }
+      else freq_op.setValue(TimeStep);
+    }
+    if (freq_offset.isEmpty()) freq_offset.setValue(hasFileIn() ? NoneDu : (freq_op.getValue() - TimeStep));
+  }
+  CATCH_DUMP_ATTR
+  /*!
+   * Returns string arithmetic expression associated to the field.
+   * \return if content is defined return content string, otherwise, if "expr" attribute is defined, return expr string.
+   */
+  const string& CField::getExpression(void)
+  TRY
+  {
+    if (!expr.isEmpty() && content.empty())
+    {
+      content = expr;
+      expr.reset();
+    }
+    return content;
+  }
+  CATCH_DUMP_ATTR
+  bool CField::hasExpression(void) const
+  TRY
+  {
+    return (!expr.isEmpty() || !content.empty());
+  }
+  CATCH
+  bool CField::hasGridMask(void) const
+  TRY
+  {
+    return (this->grid_->hasMask());
+  }
+  CATCH
+  DEFINE_REF_FUNC(Field,field)
 } // namespace xios

XIOS/dev/dev_trunk_graph/src/node/field.hpp

-                      r1686
+                      r2019
 #include "functor.hpp"
 #include "functor_type.hpp"
-#include "filter.hpp"
 #include "duration.hpp"
 #include "date.hpp"
 …
 #include "variable.hpp"
 #include "context_client.hpp"
+namespace xios {
+#include "pass_through_filter.hpp"
+#include "temporal_filter.hpp"
+#include "model_to_client_source_filter.hpp"
+#include "client_from_client_source_filter.hpp"
+#include "client_from_server_source_filter.hpp"
+#include "client_to_model_store_filter.hpp"
+#include "server_to_client_store_filter.hpp"
+#include "server_from_client_source_filter.hpp"
+#include "file_writer_store_filter.hpp"
+#include "client_to_server_store_filter.hpp"
+#include "file_reader_source_filter.hpp"
+namespace xios
+{
    /// ////////////////////// DÃ©clarations ////////////////////// ///
 …
    class CFile;
+   class CCouplerIn ;
+   class CCouplerOut ;
    class CGrid;
    class CContext;
 …
    class COutputPin;
    class CSourceFilter;
+   class CStoreFilter;
+   class CFileWriterFilter;
+   class CFileServerWriterFilter;
+   class CServerToClientFilter;
    ///--------------------------------------------------------------
 …
 #  include "field_attribute.conf"
    END_DECLARE_ATTRIBUTE_MAP(CField)
+   class CContextClient ;
    ///--------------------------------------------------------------
 …
          typedef CFieldAttributes SuperClassAttribute;
+      public :
          enum EReadField
+         {
 …
+         {
            EVENT_ID_UPDATE_DATA, EVENT_ID_READ_DATA, EVENT_ID_READ_DATA_READY,
            EVENT_ID_ADD_VARIABLE, EVENT_ID_ADD_VARIABLE_GROUP
+           EVENT_ID_ADD_VARIABLE, EVENT_ID_ADD_VARIABLE_GROUP, EVENT_ID_GRID_COMPLETED
          };
 …
       public:
-         int getNStep(void) const;
          template <int N> void getData(CArray<double, N>& _data) const;
-         std::shared_ptr<COutputPin> getInstantDataFilter();
-         /// Mutateur ///
-         void setRelFile(CFile* _file);
-         void incrementNStep(void);
-         void resetNStep(int nstep = 0);
-         void resetNStepMax();
          std::map<int, StdSize> getGridAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
 …
          std::map<int, StdSize> getGridDataBufferSize(CContextClient* client, bool bufferForWriting = false);
+         void setContextClient(CContextClient* newContextClient);
+         CContextClient* getContextClient();
+       public:
+          void makeGridAliasForCoupling(void) ;
        public:
          bool isActive(bool atCurrentTimestep = false) const;
 …
          void solveServerOperation(void);
          void solveCheckMaskIndex(bool doSendingIndex);
-         void solveAllReferenceEnabledField(bool doSending2Server);
-         void solveOnlyReferenceEnabledField(bool doSending2Server);
-         void generateNewTransformationGridDest();
          void updateRef(CGrid* grid);
-         void buildGridTransformationGraph();
          void solveGridDomainAxisRef(bool checkAtt);
-         void solveTransformedGrid();
-         void solveGenerateGrid();
          void solveGridDomainAxisBaseRef();
-         void solveAllEnabledFieldsAndTransform();
          void checkGridOfEnabledFields();
          void sendGridOfEnabledFields();
          void sendGridComponentOfEnabledFields();
+         void sendFieldToFileServer(void) ;
+         void sendCloseDefinition(void) ;
+      public:
+         void sendFieldToCouplerOut(void) ;
+      private:
+         bool sendFieldToCouplerOut_done_=false;
+      public:
+         void sendFieldToInputFileServer(void) ;
          /// VÃ©rifications ///
          void checkTimeAttributes(CDuration* freqOp=NULL);
+         void buildFilterGraph(CGarbageCollector& gc, bool enableOutput, Time start_graph=-1, Time end_graph=-1);
+         bool buildWorkflowGraph(CGarbageCollector& gc) ;
+         bool buildWorkflowGraphDone_ = false ;
          size_t getGlobalWrittenSize(void) ;
+         std::shared_ptr<COutputPin> getFieldReference(CGarbageCollector& gc, Time start_graph=-1, Time end_graph=-1);
+         std::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc, Time start_graph=-1, Time end_graph=-1);
+         std::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc);
          std::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
          std::shared_ptr<COutputPin> getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
 …
         static bool dispatchEvent(CEventServer& event);
         void sendAllAttributesToServer(CContextClient* client) ;
+        void sendUpdateData(const CArray<double,1>& data);
+        void sendUpdateData(const CArray<double,1>& data, CContextClient* client);
         static void recvUpdateData(CEventServer& event);
         void recvUpdateData(std::map<int,CBufferIn*>& rankBuffers);
+        void writeField(void);
+        void receiveUpdateData(CEventServer& event);
         bool sendReadDataRequest(const CDate& tsDataRequested);
         bool sendReadDataRequestIfNeeded(void);
         static void recvReadDataRequest(CEventServer& event);
         void recvReadDataRequest(void);
-        EReadField readField(void);
         static void recvReadDataReady(CEventServer& event);
+        void recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers);
+        void receiveReadDataReady(CEventServer& event);
+        void recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers); // old interface to remove
+        void recvDataFromCoupler(vector<int> ranks, vector<CBufferIn*> buffers) ; // old interface to remove
         void checkForLateDataFromServer(void);
+        void checkIfMustAutoTrigger(void);
+        void autoTriggerIfNeeded(void);
+        void outputField(CArray<double,3>& fieldOut);
+        void outputField(CArray<double,2>& fieldOut);
+        void outputField(CArray<double,1>& fieldOut);
+        void inputField(CArray<double,3>& fieldOut);
+        void inputField(CArray<double,2>& fieldOut);
+        void inputField(CArray<double,1>& fieldOut);
+        void outputCompressedField(CArray<double, 1>& fieldOut);
+        void scaleFactorAddOffset(double scaleFactor, double addOffset);
+        void invertScaleFactorAddOffset(double scaleFactor, double addOffset);
+        void checkForLateDataFromCoupler(void) ;
+        void checkIfMustAutoTrigger(void); // ym obsolete
+        void autoTriggerIfNeeded(void); //ym obsolete
+        void triggerLateField(void) ;
         void parse(xml::CXMLNode& node);
 …
         void recvAddVariableGroup(CBufferIn& buffer);
         void sendAddAllVariables(CContextClient* client);
-        void writeUpdateData(const CArray<double,1>& data);
         const std::vector<StdString>& getRefDomainAxisIds();
 …
         bool hasGridMask(void) const;
+        void connectToFileServer(CGarbageCollector& gc) ;
+        void connectToCouplerOut(CGarbageCollector& gc) ;
+        void connectToCouplerIn(CGarbageCollector& gc) ;
+        void connectToModelInput(CGarbageCollector& gc) ;
+        void connectToFileWriter(CGarbageCollector& gc) ;
+        void connectToClientInput(CGarbageCollector& gc) ;
+        void connectToServerInput(CGarbageCollector& gc) ;
+        void connectToModelOutput(CGarbageCollector& gc);
+        void connectToFileReader(CGarbageCollector& gc) ;
+        void connectToServerToClient(CGarbageCollector& gc) ;
+        void setContextClientDataBufferSize(map<CContextClient*,map<int,size_t>>& bufferSize,
+                                        map<CContextClient*,map<int,size_t>>& maxEventSize,
+                                        bool bufferForWriting) ;
+        void setContextClientAttributesBufferSize(map<CContextClient*,map<int,size_t>>& bufferSize,
+                                                 map<CContextClient*,map<int,size_t>>& maxEventSize,
+                                                 bool bufferForWriting) ;
+      private:
+          bool isGridCompleted_ = true ;
+      public:
+          bool isGridCompleted() { return isGridCompleted_ ;}
+          void setGridCompleted(void) { isGridCompleted_= true; }
+          void unsetGridCompleted(void) { isGridCompleted_ = false ;}
+      public:
+          void sendGridCompleted(void) ;
+      private:
+          static void recvGridCompleted(CEventServer& event);
+          void recvGridCompleted(CBufferIn& buffer);
+      private:
+        std::vector<CGrid*> getGridPath(void) ;
       public:
 …
          CVariableGroup* vVariableGroup;
+         CGrid*  grid;
+         CFile*  file;
+         CDuration freq_operation_srv, freq_write_srv;
+         CGrid*  grid_=nullptr;
+         CGrid* getGrid(void) { return grid_; }
+      private:
+         CGrid* sentGrid_=nullptr ;
+      public:
+         CGrid* getSentGrid(void) { return sentGrid_; }
+      public:
+//         CFile*  file;
+         CFile* fileIn_ = nullptr ; //<! pointer to input related file
+         bool hasFileIn(void) const { return fileIn_==nullptr ? false : true ;}
+         CFile* getFileIn(void) {return fileIn_;}
+         void setFileIn(CFile* fileIn) { fileIn_ = fileIn ;}
+         void unsetFileIn(void) { fileIn_ = nullptr ;}
+         CFile* fileOut_ = nullptr ; //<! pointer to output related file
+         bool hasFileOut(void) const { return fileOut_==nullptr ? false : true ;}
+         CFile* getFileOut(void) {return fileOut_;}
+         void setFileOut(CFile* fileOut) { fileOut_ = fileOut ;}
+         void unsetFileOut(void) { fileOut_ = nullptr ;}
+         CCouplerIn* couplerIn_ = nullptr ; //<!pointer to input related coupler
+         bool hasCouplerIn(void) const { return couplerIn_==nullptr ? false : true ;}
+         CCouplerIn* getCouplerIn(void) {return couplerIn_;}
+         void setCouplerIn(CCouplerIn* couplerIn) { couplerIn_ = couplerIn ;}
+         void unsetCouplerIn(void) { couplerIn_ = nullptr ;}
+         CCouplerOut* couplerOut_ = nullptr ; //<!pointer to output related coupler
+         bool hasCouplerOut(void) const { return couplerOut_==nullptr ? false : true ;}
+         CCouplerOut* getCouplerOut(void) {return couplerOut_;}
+         void setCouplerOut(CCouplerOut* couplerOut) { couplerOut_ = couplerOut ;}
+         void unsetCouplerOut(void) { couplerOut_ = nullptr ;}
+         bool modelIn_ = false ; //<! field can be received from model == true
+         bool getModelIn(void) { return modelIn_ ;}
+         void setModelIn(void) { modelIn_ = true ;}
+         void unsetModelIn(void) { modelIn_ = false ;}
+         bool modelOut_ = false ; //<! field can be retrieve to model == true
+         bool getModelOut(void) { return modelOut_ ;}
+         void setModelOut(void) { modelOut_ = true ;}
+         void unsetModelOut(void) { modelOut_ = false ;}
          bool written; //<! Was the field written at least once
-         int nstep, nstepMax;
-         bool isEOF;
-         CDate lastlast_Write_srv, last_Write_srv, last_operation_srv;
-         CDate lastDataRequestedFromServer, lastDataReceivedFromServer, dateEOF;
-         bool wasDataRequestedFromServer, wasDataAlreadyReceivedFromServer;
          bool mustAutoTrigger;
-         map<int,std::shared_ptr<func::CFunctor> > foperation_srv;
-         // map<int, CArray<double,1> > data_srv;
-         CArray<double,1> recvDataSrv;
-         std::shared_ptr<func::CFunctor> recvFoperationSrv;
          string content;
 …
          bool hasTimeCentered;
-         Time field_graph_start;
-         Time field_graph_end;
          DECLARE_REF_FUNC(Field,field)
       private:
          CContextClient* client;
+      public:
+         void setContextClient(CContextClient* newContextClient);
+         CContextClient* getContextClient(void) {return client;}
+      private:
          bool areAllReferenceSolved;
 …
          bool isReferenceSolvedAndTransformed;
          bool isGridChecked;
+         bool nstepMaxRead;
+      private:
+       private:
+         //! define if the field is part of the active workflow. It will be tagged to true when CField::buildWorkflowGraph is successfull
+         bool workflowEnabled_ = false ;
+       public:
+         /*! workflowEnabled_ public accessor
+          * \return Value of workflowEnabled_ */
+         bool getWorkflowEnabled(void) { return  workflowEnabled_; }
+      private:
          //! The type of operation attached to the field
          func::CFunctor::ETimeType operationTimeType;
+         //! The output pin of the input filter of the field
+         std::shared_ptr<CPassThroughFilter> inputFilter;
+         //! The self temporal data filter
+         std::shared_ptr<CTemporalFilter> selfTemporalDataFilter ;
          //! The output pin of the filter providing the instant data for the field
          std::shared_ptr<COutputPin> instantDataFilter;
+      public:
+          std::shared_ptr<COutputPin> getInstantDataFilter(void) { return instantDataFilter;}
+      private:
          //! The output pin of the filters providing the result of the field's temporal operation
          std::map<CDuration, std::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters;
          //! The output pin of the filter providing the instant data for self references
+         std::shared_ptr<COutputPin> selfReferenceFilter;
+         std::shared_ptr<COutputPin> selfReferenceFilter; // probably redondant with inputFilter
          //! The source filter for data provided by the client
+         std::shared_ptr<CSourceFilter> clientSourceFilter;
+//         std::shared_ptr<CSourceFilter> clientSourceFilter; // obsolete to remove
+         //! The source filter for data provided by the model to enter the client workflow
+         std::shared_ptr<CModelToClientSourceFilter> modelToClientSourceFilter_;
+         //! The source filter for data provided by the model to enter the client workflow
+         std::shared_ptr<CClientToModelStoreFilter> clientToModelStoreFilter_;
+         //! The source filter for data provided by the client that send data to server workflow
+         std::shared_ptr<CServerFromClientSourceFilter> serverFromClientSourceFilter_;
+         //! The source filter for data provided by an other to enter the current client workflow (coupling mode)
+         std::shared_ptr<CClientFromClientSourceFilter> clientFromClientSourceFilter_;
+         //! The source filter for data provided by server to enter the current client workflow (reading mode)
+         std::shared_ptr<CClientFromServerSourceFilter> clientFromServerSourceFilter_;
+         //! The source filter for data read from file on server side
+         std::shared_ptr<CFileReaderSourceFilter> fileReaderSourceFilter_;
          //! The source filter for data provided by the server
+         std::shared_ptr<CSourceFilter> serverSourceFilter;
          //! The terminal filter which stores the instant data
          std::shared_ptr<CStoreFilter> storeFilter;
          //! The terminal filter which writes the data to file
          std::shared_ptr<CFileWriterFilter> fileWriterFilter;
+//         std::shared_ptr<CSourceFilter> serverSourceFilter; // obsolete to remove
+         //! The terminal filter which send data to server for writing
+         std::shared_ptr<CClientToServerStoreFilter> clientToServerStoreFilter_;
          //! The terminal filter which writes data to file
+         std::shared_ptr<CFileServerWriterFilter> fileServerWriterFilter;
+         std::shared_ptr<CFileWriterStoreFilter> fileWriterStoreFilter_;
+         //! The terminal filter which send data from server to client
+         std::shared_ptr<CServerToClientStoreFilter> serverToClientStoreFilter_;
    }; // class CField

XIOS/dev/dev_trunk_graph/src/node/field_impl.hpp

-                      r1653
+                      r2019
 #include "timer.hpp"
 #include "array_new.hpp"
-#include "source_filter.hpp"
-#include "store_filter.hpp"
 …
   TRY
+  {
     if (clientSourceFilter)
+    if (modelToClientSourceFilter_)
+    {
       if (check_if_active.isEmpty() || (!check_if_active.isEmpty() && (!check_if_active) || isActive(true)))
         clientSourceFilter->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
+        modelToClientSourceFilter_->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
+    }
     else if (instantDataFilter)
 …
   TRY
+  {
     if (storeFilter)
+    if (clientToModelStoreFilter_)
+    {
       CDataPacket::StatusCode status = storeFilter->getData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
+      CDataPacket::StatusCode status = clientToModelStoreFilter_->getData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
       if (status == CDataPacket::END_OF_STREAM)

XIOS/dev/dev_trunk_graph/src/node/file.cpp

-                      r1612
+                      r2019
    TRY
+   {
+      if (!this->enabledFields.empty())
+         return (this->enabledFields);
+      const int _outputlevel =
+         (!output_level.isEmpty()) ? output_level.getValue() : default_outputlevel;
+      if (!this->enabledFields.empty()) return (this->enabledFields);
+      const int _outputlevel = (!output_level.isEmpty()) ? output_level.getValue() : default_outputlevel;
       std::vector<CField*>::iterator it;
       this->enabledFields = this->getAllFields();
 …
          newEnabledFields.push_back(*it);
-         // Le champ est finalement actif, on y ajoute la rfrence au champ de base.
-         (*it)->setRelFile(CFile::get(this));
+      }
       enabledFields = newEnabledFields;
 …
       CContext* context = CContext::getCurrent();
       const CDate& currentDate = context->calendar->getCurrentDate();
-      CContextServer* server = context->server;
       lastSync  = currentDate;
 …
       isOpen = false;
-//      if (!record_offset.isEmpty() && record_offset < 0)
-//        ERROR("void CFile::initFile(void)",
-//              "Invalid 'record_offset', this attribute cannot be negative.");
-      const int recordOffset = record_offset.isEmpty() ? 0 : record_offset;
       set<StdString> setAxis;
       set<StdString> setDomains;
 …
+      {
          CField* field = *it;
          std::vector<CAxis*> vecAxis = field->grid->getAxis();
+         std::vector<CAxis*> vecAxis = field->getGrid()->getAxis();
          for (size_t i = 0; i < vecAxis.size(); ++i)
            setAxis.insert(vecAxis[i]->getAxisOutputName());
          std::vector<CDomain*> vecDomains = field->grid->getDomains();
+         std::vector<CDomain*> vecDomains = field->getGrid()->getDomains();
          for (size_t i = 0; i < vecDomains.size(); ++i)
            setDomains.insert(vecDomains[i]->getDomainOutputName());
-         field->resetNStep(recordOffset);
+      }
       nbAxis = setAxis.size();
 …
       createSubComFile();
-      // if (time_counter.isEmpty()) time_counter.setValue(time_counter_attr::centered);
       if (time_counter_name.isEmpty()) time_counter_name = "time_counter";
+    }
 …
     TRY
+    {
+      CContext* context = CContext::getCurrent();
       if (checkRead) return;
+      createSubComFile();
+      //createSubComFile();
+      allZoneEmpty = false;
+      MPI_Comm_dup(context->intraComm_, &fileComm) ;
       checkRead = true;
+    }
 …
+    {
       CContext* context = CContext::getCurrent();
-      CContextServer* server = context->server;
       // create sub communicator for file
 …
+      {
          CField* field = *it;
          bool nullGrid = (0 == field->grid);
          allZoneEmpty &= nullGrid ? false : !field->grid->doGridHaveDataToWrite();
+         bool nullGrid = (nullptr == field->getGrid());
+         allZoneEmpty &= nullGrid ? false : !field->getGrid()->doGridHaveDataToWrite();
+      }
       int color = allZoneEmpty ? 0 : 1;
       MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm);
+      MPI_Comm_split(context->intraComm_, color, context->intraCommRank_, &fileComm);
       if (allZoneEmpty) MPI_Comm_free(&fileComm);
+    }
 …
+    {
       CContext* context = CContext::getCurrent();
+      // Done by classical server or secondary server
+      // This condition should be changed soon
+      if (CServer::serverLevel == 0 || CServer::serverLevel == 2)
+      if (mode.isEmpty() || mode.getValue() == mode_attr::write)
+      {
+        if (mode.isEmpty() || mode.getValue() == mode_attr::write)
+        {
+          CTimer::get("Files : create headers").resume();
+          if (!isOpen) createHeader();
+          CTimer::get("Files : create headers").suspend();
+          checkSync();
+        }
+        checkSplit(); // REally need this?
+      }
+        CTimer::get("Files : create headers").resume();
+        if (!isOpen) createHeader();
+        CTimer::get("Files : create headers").suspend();
+        checkSync();
+      }
+      checkSplit();
+    }
     CATCH_DUMP_ATTR
 …
       // Done by classical server or secondary server
       // TODO: This condition should be changed soon. It only works with maximum number of level as 2
+      if (CServer::serverLevel == 0 || CServer::serverLevel == 1)
+      {
+//ym      if (CServer::serverLevel == 0 || CServer::serverLevel == 1)
+// ym client must doing it also
+//      if (context->getServiceType()==CServicesManager::IO_SERVER || context->getServiceType()==CServicesManager::GATHERER)
+//      {
         if (!mode.isEmpty() && mode.getValue() == mode_attr::read)
+        {
 …
+        }
         //checkSplit(); // Really need for reading?
+      }
+ //     }
+    }
     CATCH_DUMP_ATTR
 …
           lastSplit = lastSplit + split_freq.getValue();
           std::vector<CField*>::iterator it, end = this->enabledFields.end();
           for (it = this->enabledFields.begin(); it != end; it++)
+/*          for (it = this->enabledFields.begin(); it != end; it++)
+          {
             (*it)->resetNStep();
             (*it)->resetNStepMax();
+          }
+          }*/
           if (mode.isEmpty() || mode.getValue() == mode_attr::write)
             createHeader();
 …
     CATCH_DUMP_ATTR
    /*!
    \brief Create header of netcdf file
 …
+   {
       CContext* context = CContext::getCurrent();
+      CContextServer* server = context->server;
       if (!allZoneEmpty)
+      {
 …
             MPI_Comm_rank(fileComm, &commRank);
             if (server->intraCommSize > 1)
+            if (context->intraCommSize_ > 1)
+            {
               oss << "_" ;
 …
+  {
     CContext* context = CContext::getCurrent();
-    CContextServer* server = context->server;
     MPI_Comm readComm = this->fileComm;
 …
         MPI_Comm_rank(readComm, &commRank);
         if (server->intraCommSize > 1)
+        if (context->intraCommSize_ > 1)
+        {
           oss << "_";
 …
       bool isCollective = par_access.isEmpty() || par_access == par_access_attr::collective;
       bool readMetaDataPar = true;
       if (!context->hasServer) readMetaDataPar = (read_metadata_par.isEmpty()) ? false : read_metadata_par;
+      if (context->getServiceType()==CServicesManager::CLIENT) readMetaDataPar = (read_metadata_par.isEmpty()) ? false : read_metadata_par;
       if (isOpen) data_out->closeFile();
 …
         // Now complete domain and axis associated with this field
+        enabledFields[idx]->solveGenerateGrid();
+       //ym => this a problem in wich order are done the grid generation. Probably metadata are read in file and after the grid is ditributed by the filter
+       // => must be checked in detail. But solveGenerated grid is not existing any more with new transformation framework
+       // enabledFields[idx]->solveGenerateGrid();
         // Read necessary value from file
 …
    CATCH_DUMP_ATTR
+   void CFile::readFieldAttributesMetaData(CField* field)
+   {
+     this->data_in->readFieldAttributesMetaData(field);
+   }
+   void CFile::readFieldAttributesValues(CField* field)
+   {
+     this->data_in->readFieldAttributesValues(field);
+   }
    /*!
    \brief Parse xml file and write information into file object
 …
    //----------------------------------------------------------------
-   /*!
-   \brief Resolve all reference of active fields.
-      In order to know exactly which data each active field has, a search for all its
-   reference to find its parents or/and its base reference object must be done. Moreover
-   during this search, there are some information that can only be sent to server AFTER
-   all information of active fields are created on server side, e.g: checking mask or index
-   \param [in] sendToServer: Send all info to server (true) or only a part of it (false)
-   */
-   void CFile::solveOnlyRefOfEnabledFields(bool sendToServer)
-   TRY
+   {
-     int size = this->enabledFields.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFields[i]->solveOnlyReferenceEnabledField(sendToServer);
+     }
+   }
-   CATCH_DUMP_ATTR
    void CFile::checkGridOfEnabledFields()
 …
    CATCH_DUMP_ATTR
-   void CFile::generateNewTransformationGridDest()
-   TRY
+   {
-     int size = this->enabledFields.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFields[i]->generateNewTransformationGridDest();
+     }
+   }
-   CATCH_DUMP_ATTR
-   /*!
-   \brief Resolve all reference of active fields.
-      In order to know exactly which data each active field has, a search for all its
-   reference to find its parents or/and its base reference object must be done. Moreover
-   during this search, there are some information that can only be sent to server AFTER
-   all information of active fields are created on server side, e.g: checking mask or index
-   \param [in] sendToServer: Send all info to server (true) or only a part of it (false)
-   */
-   void CFile::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer)
-   TRY
+   {
-     int size = this->enabledFields.size();
-     for (int i = 0; i < size; ++i)
+     {
-      this->enabledFields[i]->solveAllEnabledFieldsAndTransform();
+     }
+   }
-   CATCH_DUMP_ATTR
-   /*!
-    * Constructs the filter graph for each active field.
+    *
-    * \param gc the garbage collector to use when building the filter graph
-    */
-   void CFile::buildFilterGraphOfEnabledFields(CGarbageCollector& gc)
-   TRY
+   {
-     int size = this->enabledFields.size();
-     for (int i = 0; i < size; ++i)
+     {
-       this->enabledFields[i]->buildFilterGraph(gc, true);
+     }
+   }
-   CATCH_DUMP_ATTR
    /*!
 …
    CATCH_DUMP_ATTR
+   /*!
+    * Send file attribute, related variable and chield field tree to a given file server.
+    * \param[in] client : the context client where to send file
+    */
+   void CFile::sendFileToFileServer(CContextClient* client)
+   TRY
+   {
+     if (sendFileToFileServer_done_.count(client)!=0) return ;
+     else sendFileToFileServer_done_.insert(client) ;
+     StdString fileDefRoot("file_definition");
+     CFileGroup* cfgrpPtr = CFileGroup::get(fileDefRoot);
+     cfgrpPtr->sendCreateChild(this->getId(), client);
+     this->sendAllAttributesToServer(client);
+     this->sendAddAllVariables(client);
+     for(auto field : enabledFields) this->sendAddField(field->getId(), client);
+   }
+   CATCH_DUMP_ATTR
    /*!
    \brief Dispatch event received from client

XIOS/dev/dev_trunk_graph/src/node/file.hpp

-                      r1612
+                      r2019
          void close(void);
          void readAttributesOfEnabledFieldsInReadMode();
+         void readFieldAttributesMetaData(CField* field) ;
+         void readFieldAttributesValues(CField* field) ;
          // Some processing on file
          void solveFieldRefInheritance(bool apply);
          void processEnabledFile(void);
-         void solveOnlyRefOfEnabledFields(bool sendToServer);
-         void generateNewTransformationGridDest();
-         void buildFilterGraphOfEnabledFields(CGarbageCollector& gc);
          void postProcessFilterGraph();
          void prefetchEnabledReadModeFields();
 …
          void doPostTimestepOperationsForEnabledReadModeFields();
-         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
          void checkGridOfEnabledFields();
          void sendGridOfEnabledFields();
 …
          void sendAddVariableGroup(const string& id, CContextClient* client);
          void sendAddAllVariables(CContextClient* client);
+      public:
+         void sendFileToFileServer(CContextClient* client) ;
+      private:
+         std::set<CContextClient*> sendFileToFileServer_done_ ;
+      public:
          // Receive info from client
          static void recvAddField(CEventServer& event);
 …
          CDate lastSync;
          CDate lastSplit;
+         const CDate& getLastSplit(void) { return lastSplit ; }
          int nbAxis, nbDomains;
          bool isOpen;
 …
          std::vector<CField*> enabledFields;
+       private:
+         bool isClientSide_ ; // the file is on client side or on server side ?
+       public:
+         bool isClientSide(void) { return isClientSide_ ;}
+         bool isServerSide(void) { return !isClientSide_ ;}
+         void setClientSide(void) { isClientSide_=true ;}
+         void setServerSide(void) { isClientSide_=false ;}
+       private:
       public:

XIOS/dev/dev_trunk_graph/src/node/generate_rectilinear_domain.cpp

-                      r838
+                      r2019
 #include "generate_rectilinear_domain.hpp"
+#include "domain_algorithm_generate_rectilinear.hpp"
 #include "type.hpp"
 …
   bool CGenerateRectilinearDomain::registerTrans()
+  {
     registerTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, create);
+    registerTransformation(TRANS_GENERATE_RECTILINEAR_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CGenerateRectilinearDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmGenerateRectilinear::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/generate_rectilinear_domain.hpp

-                      r836
+                      r2019
   class CGenerateRectilinearDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CGenerateRectilinearDomain> SuperClass;
       typedef CGenerateRectilinearDomainAttributes SuperClassAttribute;
+      typedef CGenerateRectilinearDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_GENERATE_RECTILINEAR_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

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

-                      r1612
+                      r2019
 #include "client_server_mapping_distributed.hpp"
 #include "distribution_client.hpp"
-#include "grid_transformation.hpp"
-#include "grid_generate.hpp"
 #include "server.hpp"
+namespace xios {
+#include "distribution_type.hpp"
+#include "grid_remote_connector.hpp"
+#include "grid_elements.hpp"
+#include "grid_local_view.hpp"
+#include "grid_mask_connector.hpp"
+#include "transformation_path.hpp"
+#include "grid_transformation_factory_impl.hpp"
+#include "transform_filter.hpp"
+#include "grid_algorithm.hpp"
+#include "grid_algorithm_generic.hpp"
+#include "generic_algorithm_transformation.hpp"
+#include "algo_types.hpp"
+namespace xios
+{
    /// ////////////////////// Dfinitions ////////////////////// ///
 …
       , vAxisGroup_(), axisList_(), isAxisListSet(false)
       , vScalarGroup_(), scalarList_(), isScalarListSet(false)
+      , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
+      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
+      , clientDistribution_(0), isIndexSent(false)
       , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_()
+          , isDataDistributed_(true), isCompressible_(false)
+      , transformations_(0), isTransformed_(false)
+            , isCompressible_(false)
       , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
+      , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
+      , computedWrittenIndex_(false)
+      , gridSrc_(), order_()
       , clients()
+   {
 …
       , vAxisGroup_(), axisList_(), isAxisListSet(false)
       , vScalarGroup_(), scalarList_(), isScalarListSet(false)
+      , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
+      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
+      , clientDistribution_(0), isIndexSent(false)
       , connectedDataSize_(), connectedServerRank_(), connectedServerRankRead_(), connectedDataSizeRead_()
+          , isDataDistributed_(true), isCompressible_(false)
+      , transformations_(0), isTransformed_(false)
+            , isCompressible_(false)
       , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
+      , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
+      , computedWrittenIndex_(false)
+      , gridSrc_(), order_()
       , clients()
+   {
 …
+   {
     if (0 != clientDistribution_) delete clientDistribution_;
-    if (0 != serverDistribution_) delete serverDistribution_;
-    if (0 != clientServerMap_) delete clientServerMap_;
-    if (0 != transformations_) delete transformations_;
+   }
 …
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /////////              MEMBER FUNCTION RELATED TO GRID CONSTRUCTION by ELEMNTS AND MANAGEMENT                      /////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   CGrid* CGrid::createGrid(CDomain* domain)
+   TRY
+   {
+     std::vector<CDomain*> vecDom(1, domain);
+     std::vector<CAxis*> vecAxis;
+     return createGrid(vecDom, vecAxis);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
+   TRY
+  {
+      std::vector<CDomain*> vecDom(1, domain);
+      std::vector<CAxis*> vecAxis(1, axis);
+      return createGrid(vecDom, vecAxis);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+     std::vector<CScalar*> vecScalar;
+     return createGrid(generateId(domains, axis, vecScalar, axisDomainOrder), domains, axis, vecScalar, axisDomainOrder);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+     return createGrid(generateId(domains, axis, scalars, axisDomainOrder), domains, axis, scalars, axisDomainOrder);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
+        ERROR("CGrid* CGrid::createGrid(...)",
+              << "The size of axisDomainOrder (" << axisDomainOrder.numElements()
+              << ") is not coherent with the number of elements (" << domains.size() + axis.size() <<").");
+      CGrid* grid = CGridGroup::get("grid_definition")->createChild(id);
+      grid->setDomainList(domains);
+      grid->setAxisList(axis);
+      grid->setScalarList(scalars);
+      // By default, domains are always the first elements of a grid
+      if (0 == axisDomainOrder.numElements())
+      {
+        int size = domains.size() + axis.size() + scalars.size();
+        int nb = 0;
+        grid->axis_domain_order.resize(size);
+        for (int i = 0; i < size; ++i)
+        {
+          if (i < domains.size())
+          {
+            grid->axis_domain_order(i) = 2;
+            grid->order_.push_back(2) ;
+          }
+          else if ((scalars.size() < (size-nb)) < size)
+          {
+            grid->axis_domain_order(i) = 1;
+            grid->order_.push_back(1) ;
+          }
+          else
+          {
+            grid->axis_domain_order(i) = 0;
+            grid->order_.push_back(0) ;
+          }
+          ++nb;
+        }
+      }
+      else
+      {
+        grid->axis_domain_order.resize(axisDomainOrder.numElements());
+        grid->axis_domain_order = axisDomainOrder;
+        grid->order_.clear() ;
+        for(int i=0; i<axisDomainOrder.numElements();i++) grid->order_.push_back(axisDomainOrder(i)) ;
+      }
+ //     grid->solveElementsRefInheritance(true);
+      grid->computeElements() ;
+      return grid;
+   }
+   CATCH
+   //----------------------------------------------------------------
+   //! Change virtual field group to a new one
+   void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
+   TRY
+   {
+      this->vDomainGroup_ = newVDomainGroup;
+   }
+   CATCH_DUMP_ATTR
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualAxisGroup(CAxisGroup* newVAxisGroup)
+   TRY
+   {
+      this->vAxisGroup_ = newVAxisGroup;
+   }
+   CATCH_DUMP_ATTR
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualScalarGroup(CScalarGroup* newVScalarGroup)
+   TRY
+   {
+      this->vScalarGroup_ = newVScalarGroup;
+   }
+   CATCH_DUMP_ATTR
+   //----------------------------------------------------------------
+   CDomainGroup* CGrid::getVirtualDomainGroup() const
+   TRY
+   {
+     return this->vDomainGroup_;
+   }
+   CATCH
+   CAxisGroup* CGrid::getVirtualAxisGroup() const
+   TRY
+   {
+     return this->vAxisGroup_;
+   }
+   CATCH
+   CScalarGroup* CGrid::getVirtualScalarGroup() const
+   TRY
+   {
+     return this->vScalarGroup_;
+   }
+   CATCH
+  ///---------------------------------------------------------------
+   CDomain* CGrid::addDomain(const std::string& id)
+   TRY
+   {
+     order_.push_back(2);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     CDomain* domain = vDomainGroup_->createChild(id);
+     isDomListSet=false ;
+     computeElements();
+     return domain ;
+   }
+   CATCH_DUMP_ATTR
+   CAxis* CGrid::addAxis(const std::string& id)
+   TRY
+   {
+     order_.push_back(1);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     CAxis* axis=vAxisGroup_->createChild(id);
+     isAxisListSet=false ;
+     computeElements();
+     return axis ;
+   }
+   CATCH_DUMP_ATTR
+   CScalar* CGrid::addScalar(const std::string& id)
+   TRY
+   {
+     order_.push_back(0);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     CScalar* scalar =  vScalarGroup_->createChild(id);
+     isScalarListSet=false ;
+     computeElements();
+     return scalar;
+   }
+   CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of domain pointers
+  \return list of domain pointers
+  */
+  std::vector<CDomain*> CGrid::getDomains()
+  TRY
+  {
+    setDomainList();
+    std::vector<CDomain*> domList;
+    if (!domList_.empty())
+    {
+      for (int i = 0; i < domList_.size(); ++i) domList.push_back(CDomain::get(domList_[i]));
+    }
+    return domList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of  axis pointers
+  \return list of axis pointers
+  */
+  std::vector<CAxis*> CGrid::getAxis()
+  TRY
+  {
+    setAxisList();
+    std::vector<CAxis*> aList;
+    if (!axisList_.empty())
+      for (int i =0; i < axisList_.size(); ++i) aList.push_back(CAxis::get(axisList_[i]));
+    return aList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of  axis pointers
+  \return list of axis pointers
+  */
+  std::vector<CScalar*> CGrid::getScalars()
+  TRY
+  {
+    setScalarList() ;
+    std::vector<CScalar*> sList;
+    if (!scalarList_.empty())
+      for (int i =0; i < scalarList_.size(); ++i) sList.push_back(CScalar::get(scalarList_[i]));
+    return sList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get domain pointer with index
+  \return domain pointer
+  */
+  CDomain* CGrid::getDomain(int domainIndex)
+  TRY
+  {
+    std::vector<CDomain*> domainListP = this->getDomains();
+    if (domainListP.empty())
+    {
+      ERROR("CGrid::getDomain(int domainIndex)",
+            << "No domain associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (domainIndex >= domainListP.size() || (domainIndex < 0))
+      ERROR("CGrid::getDomain(int domainIndex)",
+            << "Domain with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << domainListP.size() << " domain but domain index required is " << domainIndex << std::endl);
+    return domainListP[domainIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the axis pointer with index
+  \return axis pointer
+  */
+  CAxis* CGrid::getAxis(int axisIndex)
+  TRY
+  {
+    std::vector<CAxis*> axisListP = this->getAxis();
+    if (axisListP.empty())
+    {
+      ERROR("CGrid::getDomain(int axisIndex)",
+            << "No axis associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (axisIndex >= axisListP.size() || (axisIndex < 0))
+      ERROR("CGrid::getDomain(int axisIndex)",
+            << "Domain with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << axisListP.size() << " axis but axis index required is " << axisIndex << std::endl);
+    return axisListP[axisIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the a scalar pointer
+  \return scalar pointer
+  */
+  CScalar* CGrid::getScalar(int scalarIndex)
+  TRY
+  {
+    std::vector<CScalar*> scalarListP = this->getScalars();
+    if (scalarListP.empty())
+    {
+      ERROR("CGrid::getScalar(int scalarIndex)",
+            << "No scalar associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (scalarIndex >= scalarListP.size() || (scalarIndex < 0))
+      ERROR("CGrid::getScalar(int scalarIndex)",
+            << "Scalar with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << scalarListP.size() << " scalar but scalar index required is " << scalarIndex << std::endl);
+    return scalarListP[scalarIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set domain(s) of a grid from a list
+  \param[in] domains list of domains
+  */
+  void CGrid::setDomainList(const std::vector<CDomain*> domains)
+  TRY
+  {
+    if (isDomListSet) return;
+    std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
+    if (!domains.empty() && domList.empty())
+    {
+      for (int i = 0; i < domains.size(); ++i)
+        this->getVirtualDomainGroup()->addChild(domains[i]);
+      domList = this->getVirtualDomainGroup()->getAllChildren();
+    }
+    if (!domList.empty())
+    {
+      int sizeDom = domList.size();
+      domList_.resize(sizeDom);
+      for (int i = 0; i < sizeDom; ++i)
+      {
+        domList_[i] = domList[i]->getId();
+      }
+      isDomListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set axis(s) of a grid from a list
+  \param[in] axis list of axis
+  */
+  void CGrid::setAxisList(const std::vector<CAxis*> axis)
+  TRY
+  {
+    if (isAxisListSet) return;
+    std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
+    if (!axis.empty() && aList.empty())
+    {
+      for (int i = 0; i < axis.size(); ++i)
+        this->getVirtualAxisGroup()->addChild(axis[i]);
+      aList = this->getVirtualAxisGroup()->getAllChildren();
+    }
+    if (!aList.empty())
+    {
+      int sizeAxis = aList.size();
+      axisList_.resize(sizeAxis);
+      for (int i = 0; i < sizeAxis; ++i)
+      {
+        axisList_[i] = aList[i]->getId();
+      }
+      isAxisListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set scalar(s) of a grid from a list
+  \param[in] scalars list of scalars
+  */
+  void CGrid::setScalarList(const std::vector<CScalar*> scalars)
+  TRY
+  {
+    if (isScalarListSet) return;
+    std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
+    if (!scalars.empty() && sList.empty())
+    {
+      for (int i = 0; i < scalars.size(); ++i)
+        this->getVirtualScalarGroup()->addChild(scalars[i]);
+      sList = this->getVirtualScalarGroup()->getAllChildren();
+    }
+    if (!sList.empty())
+    {
+      int sizeScalar = sList.size();
+      scalarList_.resize(sizeScalar);
+      for (int i = 0; i < sizeScalar; ++i)
+      {
+        scalarList_[i] = sList[i]->getId();
+      }
+      isScalarListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get list of id of domains
+  \return id list of domains
+  */
+  std::vector<StdString> CGrid::getDomainList()
+  TRY
+  {
+    setDomainList();
+    return domList_;
+  }
+  CATCH
+  /*!
+  \brief Get list of id of axis
+  \return id list of axis
+  */
+  std::vector<StdString> CGrid::getAxisList()
+  TRY
+  {
+    setAxisList();
+    return axisList_;
+  }
+  CATCH
+  /*!
+  \brief Get list of id of scalar
+  \return id list of scalar
+  */
+  std::vector<StdString> CGrid::getScalarList()
+  TRY
+  {
+    setScalarList();
+    return scalarList_;
+  }
+  CATCH
+  void CGrid::computeElements(void)
+  {
+    const auto& domains = getDomains() ;
+    const auto& axis = getAxis() ;
+    const auto& scalars = getScalars() ;
+    int idxDomain = 0, idxAxis=0 , idxScalar=0 ;
+    elements_.clear() ;
+    for(auto type : order_)
+    {
+      if      (type == 0) { elements_.push_back({scalars[idxScalar], TYPE_SCALAR, scalars[idxScalar], nullptr, nullptr } ) ; idxScalar++;}
+      else if (type == 1) { elements_.push_back({axis[idxAxis], TYPE_AXIS, nullptr, axis[idxAxis], nullptr}) ; idxAxis++;}
+      else if (type == 2) { elements_.push_back({domains[idxDomain], TYPE_DOMAIN, nullptr, nullptr, domains[idxDomain] }) ; idxDomain++;}
+    }
+    elementsComputed_ = true ;
+  }
+ /*!
+    Parse a grid, for now, it contains only domain, axis and scalar
+  */
+  void CGrid::parse(xml::CXMLNode& node)
+  TRY
+  {
+    SuperClass::parse(node);
+    if (node.goToChildElement())
+    {
+      StdString domainName("domain");
+      StdString axisName("axis");
+      StdString scalarName("scalar");
+      do
+      {
+        if (node.getElementName() == domainName) {
+          order_.push_back(2);
+          this->getVirtualDomainGroup()->parseChild(node);
+        }
+        if (node.getElementName() == axisName) {
+          order_.push_back(1);
+          this->getVirtualAxisGroup()->parseChild(node);
+        }
+        if (node.getElementName() == scalarName) {
+          order_.push_back(0);
+          this->getVirtualScalarGroup()->parseChild(node);
+        }
+      } while (node.goToNextElement());
+      node.goToParentElement();
+    }
+    if (!order_.empty())
+    {
+      int sizeOrd = order_.size();
+      axis_domain_order.resize(sizeOrd);
+      for (int i = 0; i < sizeOrd; ++i)
+      {
+        axis_domain_order(i) = order_[i];
+      }
+    }
+    setDomainList();
+    setAxisList();
+    setScalarList();
+    computeElements() ;
+   }
+   CATCH_DUMP_ATTR
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StdSize CGrid::getDimension(void)
    TRY
 …
    //---------------------------------------------------------------
    StdSize CGrid::getDataSize(void) const
+   StdSize CGrid::getDataSize(void)
    TRY
+   {
 …
      if (!isScalarGrid())
+     {
        std::vector<int> dataNindex = clientDistribution_->getDataNIndex();
+       std::vector<int> dataNindex = getClientDistribution()->getDataNIndex();
        for (int i = 0; i < dataNindex.size(); ++i) retvalue *= dataNindex[i];
+     }
 …
+   }
    CATCH
+   /*!
+    * Get the local data grid size, ie the size of the compressed grid (inside the workflow)
+    * \return The size od the compressed grid
+    */
+    StdSize  CGrid::getLocalDataSize(void) { return getClientDistribution()->getLocalDataSize();}
    /*!
 …
      for (size_t i = 0; i < axisList.size(); ++i)
+     {
        std::map<int, StdSize> axisAttBuffSize = axisList[i]->getAttributesBufferSize(client, getGlobalDimension(),axisPositionInGrid_[i]);
+       std::map<int, StdSize> axisAttBuffSize = axisList[i]->getAttributesBufferSize(client, getGlobalDimension(),getAxisPositionInGrid()[i]);
        for (it = axisAttBuffSize.begin(), itE = axisAttBuffSize.end(); it != itE; ++it)
+       {
 …
    CATCH_DUMP_ATTR
+   void CGrid::checkAttributesAfterTransformation()
+   TRY
+   {
+      setAxisList();
+      std::vector<CAxis*> axisListP = this->getAxis();
+      if (!axisListP.empty())
+      {
+        int idx = 0;
+        axisPositionInGrid_.resize(0);
+        for (int i = 0; i < axis_domain_order.numElements(); ++i)
+        {
+          int elementDimension = axis_domain_order(i);
+          if (1 == elementDimension)
+          {
+            axisPositionInGrid_.push_back(idx);
+            ++idx;
+          }
+          else if (2 == elementDimension) idx += 2;
+        }
+        for (int i = 0; i < axisListP.size(); ++i)
+        {
+          axisListP[i]->checkAttributesOnClientAfterTransformation(getGlobalDimension(),axisPositionInGrid_[i]);
+        }
+      }
+      setDomainList();
+      std::vector<CDomain*> domListP = this->getDomains();
+      if (!domListP.empty())
+      {
+        for (int i = 0; i < domListP.size(); ++i)
+        {
+          domListP[i]->checkAttributesOnClientAfterTransformation();
+        }
+      }
+   }
+   CATCH_DUMP_ATTR
+   //---------------------------------------------------------------
+   void CGrid::computeAxisPositionInGrid(void)
+   {
+     axisPositionInGrid_.resize(0);
+     int idx = 0;
+     for (int i = 0; i < axis_domain_order.numElements(); ++i)
+     {
+       int elementDimension = axis_domain_order(i);
+       if (1 == elementDimension)
+       {
+         axisPositionInGrid_.push_back(idx);
+         ++idx;
+       }
+       else if (2 == elementDimension) idx += 2;
+     }
+   }
    /*!
     * Test whether the data defined on the grid can be outputted in a compressed way.
 …
    CATCH_DUMP_ATTR
+   //ym obsolete -> to be removed later
    void CGrid::checkMaskIndex(bool doSendingIndex)
    TRY
+   {
      CContext* context = CContext::getCurrent();
+     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 0) : 1;
+     nbSrvPools = 1;
+     for (int p = 0; p < nbSrvPools; ++p)
+     {
+       if (context->hasClient && this->isChecked && doSendingIndex && !isIndexSent)
+       {
+         if (isScalarGrid())
+           sendIndexScalarGrid();
+         else
+           sendIndex();
+         this->isIndexSent = true;
+       }
+       // Not sure about this
+       //if (!(this->hasTransform() && !this->isTransformed()))
+       // this->isChecked = true;
+       //return;
+     }
      if (this->isChecked) return;
+     this->checkAttributesAfterTransformation();
+     // TODO: Transfer grid attributes
+     //if (!context->hasClient && context->hasServer) this->createMask();
+     this->computeIndex();
+     if (!(this->hasTransform() && !this->isTransformed()))
+      this->isChecked = true;
+     if (!(this->hasTransform() && (!this->isGenerated())))
+      this->isChecked = true;
+   }
+   CATCH_DUMP_ATTR
+     this->checkElementsAttributes();
+     this->isChecked = true;
+   }
+   CATCH_DUMP_ATTR
    bool CGrid::hasMask() const
    TRY
 …
    CATCH
+   /*
+     Create mask of grid from mask of its components
+   */
+   void CGrid::createMask(void)
+   TRY
+   {
+      using namespace std;
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+      std::vector<CArray<bool,1>* > domainMasks(domainP.size());
+      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->domainMask);
+      std::vector<CArray<bool,1>* > axisMasks(axisP.size());
+      for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask);
+      switch (dim) {
+        case 1:
+          checkGridMask(mask_1d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 2:
+          checkGridMask(mask_2d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 3:
+          checkGridMask(mask_3d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 4:
+          checkGridMask(mask_4d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 5:
+          checkGridMask(mask_5d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 6:
+          checkGridMask(mask_6d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        case 7:
+          checkGridMask(mask_7d, domainMasks, axisMasks, axis_domain_order, true);
+          break;
+        default:
+          break;
+      }
+   }
+   CATCH_DUMP_ATTR
+   /*
+     Check validity of grid's mask by using the masks of its components
+   */
+   void CGrid::checkMask(void)
+   TRY
+   {
+      using namespace std;
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+      std::vector<CArray<bool,1>* > domainMasks(domainP.size());
+      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->domainMask);
+      std::vector<CArray<bool,1>* > axisMasks(axisP.size());
+      for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask);
+      switch (dim) {
+        case 1:
+          checkGridMask(mask_1d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 2:
+          checkGridMask(mask_2d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 3:
+          checkGridMask(mask_3d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 4:
+          checkGridMask(mask_4d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 5:
+          checkGridMask(mask_5d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 6:
+          checkGridMask(mask_6d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        case 7:
+          checkGridMask(mask_7d, domainMasks, axisMasks, axis_domain_order);
+          break;
+        default:
+          break;
+      }
+   }
+   CATCH_DUMP_ATTR
+   /*
+     Modify value of mask in a certain index
+     This function can be used to correct the mask of grid after being constructed with createMask
+     \param [in] indexToModify
+     \param [in] modifyValue
+   */
+   void CGrid::modifyMask(const CArray<int,1>& indexToModify, bool modifyValue)
+   TRY
+   {
+      using namespace std;
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+      switch (dim) {
+        case 0:
+          modifyGridMask(mask_0d, indexToModify, modifyValue);
+          break;
+        case 1:
+          modifyGridMask(mask_1d, indexToModify, modifyValue);
+          break;
+        case 2:
+          modifyGridMask(mask_2d, indexToModify, modifyValue);
+          break;
+        case 3:
+          modifyGridMask(mask_3d, indexToModify, modifyValue);
+          break;
+        case 4:
+          modifyGridMask(mask_4d, indexToModify, modifyValue);
+          break;
+        case 5:
+          modifyGridMask(mask_5d, indexToModify, modifyValue);
+          break;
+        case 6:
+          modifyGridMask(mask_6d, indexToModify, modifyValue);
+          break;
+        case 7:
+          modifyGridMask(mask_7d, indexToModify, modifyValue);
+          break;
+        default:
+          break;
+      }
+   }
+   CATCH_DUMP_ATTR
+   /*
+     Change the mask size. This function is used on reconstructing mask in server side
+     \param [in] newDimensionSize
+     \param [in] newValue
+   */
+   void CGrid::modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue)
+   TRY
+   {
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+      switch (dim) {
+        case 0:
+          modifyGridMaskSize(mask_0d, newDimensionSize, newValue);
+          break;
+        case 1:
+          modifyGridMaskSize(mask_1d, newDimensionSize, newValue);
+          break;
+        case 2:
+          modifyGridMaskSize(mask_2d, newDimensionSize, newValue);
+          break;
+        case 3:
+          modifyGridMaskSize(mask_3d, newDimensionSize, newValue);
+          break;
+        case 4:
+          modifyGridMaskSize(mask_4d, newDimensionSize, newValue);
+          break;
+        case 5:
+          modifyGridMaskSize(mask_5d, newDimensionSize, newValue);
+          break;
+        case 6:
+          modifyGridMaskSize(mask_6d, newDimensionSize, newValue);
+          break;
+        case 7:
+          modifyGridMaskSize(mask_7d, newDimensionSize, newValue);
+          break;
+        default:
+          break;
+      }
+   }
+   CATCH_DUMP_ATTR
+   CArray<bool,1>& CGrid::getMask(void)
+   {
+      if (mask_.isEmpty())
+      {
+        if (!mask_0d.isEmpty()) mask_.reference(CArray<bool,1>(mask_0d.dataFirst(),shape(mask_0d.numElements()), neverDeleteData)) ;
+        if (!mask_1d.isEmpty()) mask_.reference(CArray<bool,1>(mask_1d.dataFirst(),shape(mask_1d.numElements()), neverDeleteData)) ;
+        if (!mask_2d.isEmpty()) mask_.reference(CArray<bool,1>(mask_2d.dataFirst(),shape(mask_2d.numElements()), neverDeleteData)) ;
+        if (!mask_3d.isEmpty()) mask_.reference(CArray<bool,1>(mask_3d.dataFirst(),shape(mask_3d.numElements()), neverDeleteData)) ;
+        if (!mask_4d.isEmpty()) mask_.reference(CArray<bool,1>(mask_4d.dataFirst(),shape(mask_4d.numElements()), neverDeleteData)) ;
+        if (!mask_5d.isEmpty()) mask_.reference(CArray<bool,1>(mask_5d.dataFirst(),shape(mask_5d.numElements()), neverDeleteData)) ;
+        if (!mask_6d.isEmpty()) mask_.reference(CArray<bool,1>(mask_6d.dataFirst(),shape(mask_6d.numElements()), neverDeleteData)) ;
+        if (!mask_7d.isEmpty()) mask_.reference(CArray<bool,1>(mask_7d.dataFirst(),shape(mask_7d.numElements()), neverDeleteData)) ;
+      }
+      return mask_ ;
+   }
    //---------------------------------------------------------------
 …
       std::vector<CDomain*> domListP = this->getDomains();
       if (!domListP.empty())
+      {
+        for (int i = 0; i < domListP.size(); ++i)
+        {
+          if (sendAtt) domListP[i]->sendCheckedAttributes();
+          else domListP[i]->checkAttributesOnClient();
+        }
+      }
+        for (int i = 0; i < domListP.size(); ++i) domListP[i]->checkAttributes();
+   }
    CATCH_DUMP_ATTR
 …
       std::vector<CAxis*> axisListP = this->getAxis();
       if (!axisListP.empty())
+      {
+        int idx = 0;
+        axisPositionInGrid_.resize(0);
+        for (int i = 0; i < axis_domain_order.numElements(); ++i)
+        {
+          int elementDimension = axis_domain_order(i);
+          if (1 == elementDimension)
+          {
+            axisPositionInGrid_.push_back(idx);
+            ++idx;
+          }
+          else if (2 == elementDimension) idx += 2;
+        }
+        for (int i = 0; i < axisListP.size(); ++i)
+        {
+          if (sendAtt)
+            axisListP[i]->sendCheckedAttributes(getGlobalDimension(),axisPositionInGrid_[i]);
+          else
+            axisListP[i]->checkAttributesOnClient();
+        }
+      }
+        for (int i = 0; i < axisListP.size(); ++i)  axisListP[i]->checkAttributes();
+   }
    CATCH_DUMP_ATTR
 …
       std::vector<CScalar*> scalarListP = this->getScalars();
       if (!scalarListP.empty())
+      {
+        for (int i = 0; i < scalarListP.size(); ++i)
+        {
+          /*Nothing to do for now */
+//          if (sendAtt) scalarListP[i]->sendCheckedAttributes();
+//          else scalarListP[i]->checkAttributesOnClient();
+        }
+      }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+      Compute the index to for write data into a file
+   */
+   void CGrid::computeWrittenIndex()
+   TRY
+   {
+      if (computedWrittenIndex_) return;
+      computedWrittenIndex_ = true;
+      if (isScalarGrid())
+      {
+        size_t nbWritten = 1;
+        int writtenIndex = 0;
+        localIndexToWriteOnClient.resize(nbWritten);
+        localIndexToWriteOnServer.resize(nbWritten);
+        localIndexToWriteOnServer(0) = writtenIndex;
+        localIndexToWriteOnClient(0) = writtenIndex;
+        return;
+      }
+      size_t nbWritten = 0, indGlo;
+      CDistributionClient::GlobalLocalDataMap& globalDataIndex = clientDistribution_->getGlobalDataIndexOnClient();
+      CDistributionClient::GlobalLocalDataMap::const_iterator itb = globalDataIndex.begin(),
+                                                              ite = globalDataIndex.end(), it;
+      const CDistributionServer::GlobalLocalMap& globalLocalIndex = serverDistribution_->getGlobalLocalIndex();
+      CDistributionServer::GlobalLocalMap::const_iterator itSrvb = globalLocalIndex.begin(),
+                                                          itSrve = globalLocalIndex.end(), itSrv;
+      for (it = itb; it != ite; ++it)
+      {
+        indGlo = it->first;
+        if (globalLocalIndex.end() != globalLocalIndex.find(indGlo)) ++nbWritten;
+      }
+      localIndexToWriteOnClient.resize(nbWritten);
+      localIndexToWriteOnServer.resize(nbWritten);
+      {
+        numberWrittenIndexes_ = nbWritten;
+        if (isDataDistributed_)
+        {
+          CContextServer* server = CContext::getCurrent()->server;
+          MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+          MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+          offsetWrittenIndexes_ -= numberWrittenIndexes_;
+        }
+        else
+          totalNumberWrittenIndexes_ = numberWrittenIndexes_;
+      }
+      nbWritten = 0;
+      for (it = itb; it != ite; ++it)
+      {
+        indGlo = it->first;
+        itSrv = globalLocalIndex.find(indGlo);
+        if (itSrve != itSrv)
+        {
+          localIndexToWriteOnServer(nbWritten) = itSrv->second;
+          localIndexToWriteOnClient(nbWritten) = it->second;
+          ++nbWritten;
+        }
+      }
+   }
+   CATCH_DUMP_ATTR
+   //---------------------------------------------------------------
+   /*
+     Compute the global index and its local index taking account mask and data index.
+     These global indexes will be used to compute the connection of this client (sender) to its servers (receivers)
+     (via function computeConnectedClient)
+     These global indexes also correspond to data sent to servers (if any)
+   */
+   void CGrid::computeClientIndex()
+   TRY
+   {
+        for (int i = 0; i < scalarListP.size(); ++i) scalarListP[i]->checkAttributes() ;
+   }
+   CATCH_DUMP_ATTR
+    //---------------------------------------------------------------
+   CDistributionClient* CGrid::getClientDistribution()
+   TRY
+   {
+     if (!computeClientDistribution_done_) computeClientDistribution() ;
+     return clientDistribution_;
+   }
+   CATCH_DUMP_ATTR
+   void CGrid::computeClientDistribution(void)
+   {
+     if (computeClientDistribution_done_) return ;
+     else computeClientDistribution_done_ = true ;
      CContext* context = CContext::getCurrent();
+     CContextClient* client = context->client;
+     int rank = client->clientRank;
+     int rank = context-> getIntraCommRank();
      clientDistribution_ = new CDistributionClient(rank, this);
+     // Get local data index on client
+     int nbStoreIndex = clientDistribution_->getLocalDataIndexOnClient().size();
+     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];
+     if (0 == serverDistribution_) isDataDistributed_= clientDistribution_->isDataDistributed();
+     else
+     {
+        // 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;
+        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];
+          size_t nbIndex = 0;
+          // Keep this code for this moment but it should be removed (or moved to DEBUG) to improve performance
+          for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
+          {
+            if (itGloe != globalDataIndex.find(globalIndex(idx)))
+            {
+              ++nbIndex;
+            }
+          }
+          if (doGridHaveDataDistributed(client) && (nbIndex != localIndex.numElements()))
+               ERROR("void CGrid::computeClientIndex()",
+                  << "Number of local index on client is different from number of received global index"
+                  << "Rank of sent client " << rank <<"."
+                  << "Number of local index " << nbIndex << ". "
+                  << "Number of received global index " << localIndex.numElements() << ".");
+          nbIndex = 0;
+          for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
+          {
+            if (itGloe != globalDataIndex.find(globalIndex(idx)))
+            {
+              localIndex(idx) = globalDataIndex[globalIndex(idx)];
+            }
+          }
+        }
+      }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Compute connected receivers and indexes to be sent to these receivers.
+   */
+   void CGrid::computeConnectedClients()
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     int nbSrvPools = (context->clientPrimServer.size() == 0) ? 1 : context->clientPrimServer.size();
+     connectedServerRank_.clear();
+     connectedDataSize_.clear();
+     globalIndexOnServer_.clear();
+     nbSenders.clear();
+     for (int p = 0; p < nbSrvPools; ++p)
+     {
+       CContextClient* client = (context->clientPrimServer.size() == 0) ? context->client : context->clientPrimServer[p];
+       int receiverSize = client->serverSize;
+//       connectedServerRank_[client].clear();
+       if (connectedServerRank_.find(receiverSize) == connectedServerRank_.end())
+       {
+        if (!doGridHaveDataDistributed(client))
+         {
+            if (client->isServerLeader())
+            {
+              size_t ssize = clientDistribution_->getLocalDataIndexOnClient().size();
+              const std::list<int>& ranks = client->getRanksServerLeader();
+              for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+              {
+                connectedServerRank_[receiverSize].push_back(*itRank);
+                connectedDataSize_[receiverSize][*itRank] = ssize;
+              }
+            }
+            return;
+         }
+         // Compute mapping between client and server
+         std::vector<std::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
+         CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize);
+         std::vector<int> serverZeroIndex = serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement,
+                                                                                                    client->clientRank,
+                                                                                                    client->clientSize,
+                                                                                                    axis_domain_order,
+                                                                                                    getDistributedDimension());
+         // Even if servers have no index, they must received something from client
+         // We only use several client to send "empty" message to these servers
+         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];
+         if (globalIndexOnServer_.find(receiverSize) == globalIndexOnServer_.end())
+           computeIndexByElement(indexServerOnElement, client, globalIndexOnServer_[receiverSize]);
+         const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer();
+         CDistributionClient::GlobalLocalDataMap::const_iterator iteGlobalLocalIndexMap = globalLocalIndexSendToServer.end(), itGlobalLocalIndexMap;
+         CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itbGlobalMap, itGlobalMap;
+         itbGlobalMap = globalIndexOnServer_[receiverSize].begin();
+         iteGlobalMap = globalIndexOnServer_[receiverSize].end();
+         for (itGlobalMap  = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap)
+         {
+           int serverRank = itGlobalMap->first;
+           int indexSize = itGlobalMap->second.size();
+           const std::vector<size_t>& indexVec = itGlobalMap->second;
+           for (int idx = 0; idx < indexSize; ++idx)
+           {
+              itGlobalLocalIndexMap = globalLocalIndexSendToServer.find(indexVec[idx]);
+              if (iteGlobalLocalIndexMap != itGlobalLocalIndexMap)
+              {
+                if (connectedDataSize_[receiverSize].end() == connectedDataSize_[receiverSize].find(serverRank))
+                  connectedDataSize_[receiverSize][serverRank] = 1;
+                else
+                  ++connectedDataSize_[receiverSize][serverRank];
+              }
+           }
+         }
+         // Connected servers which really have index
+         for (itGlobalMap = itbGlobalMap; itGlobalMap != iteGlobalMap; ++itGlobalMap) {
+           connectedServerRank_[receiverSize].push_back(itGlobalMap->first);
+         }
+         // Connected servers which have no index at all
+         for (std::list<int>::iterator it = serverZeroIndexLeader.begin(); it != serverZeroIndexLeader.end(); ++it)
+           connectedServerRank_[receiverSize].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_[receiverSize].empty())
+          connectedServerRank_[receiverSize].push_back(client->clientRank % client->serverSize);
+         // Now check if all servers have data to receive. If not, master client will send empty data.
+         // This ensures that all servers will participate in collective calls upon receiving even if they have no date to receive.
+         std::vector<int> counts (client->clientSize);
+         std::vector<int> displs (client->clientSize);
+         displs[0] = 0;
+         int localCount = connectedServerRank_[receiverSize].size() ;
+         MPI_Gather(&localCount, 1, MPI_INT, &counts[0], 1, MPI_INT, 0, client->intraComm) ;
+         for (int i = 0; i < client->clientSize-1; ++i)
+         {
+           displs[i+1] = displs[i] + counts[i];
+         }
+         std::vector<int> allConnectedServers(displs[client->clientSize-1]+counts[client->clientSize-1]);
+         MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, MPI_INT, &allConnectedServers[0], &counts[0], &displs[0], MPI_INT, 0, client->intraComm);
+         if ((allConnectedServers.size() != receiverSize) && (client->clientRank == 0))
+         {
+           std::vector<bool> isSrvConnected (receiverSize, false);
+           for (int i = 0; i < allConnectedServers.size(); ++i) isSrvConnected[allConnectedServers[i]] = true;
+           for (int i = 0; i < receiverSize; ++i)
+           {
+             if (!isSrvConnected[i]) connectedServerRank_[receiverSize].push_back(i);
+           }
+         }
+         nbSenders[receiverSize] = clientServerMap_->computeConnectedClients(receiverSize, client->clientSize, client->intraComm, connectedServerRank_[receiverSize]);
+       }
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+     Compute the global index of grid to send to server as well as the connected server of the current client.
+     First of all, from the local data on each element of grid, we can calculate their local index which also allows us to know
+     their global index. We can have a map of global index of grid and local index that each client holds
+     Then, each client holds a piece of information about the distribution of servers, which permits to compute the connected server(s)
+     of the current client.
+   */
+   void CGrid::computeIndex(void)
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+     if (isScalarGrid())
+     {
+       computeClientIndexScalarGrid();
+       if (context->hasClient)
+       {
+         computeConnectedClientsScalarGrid();
+       }
+     }
+     else
+     {
+       computeClientIndex();
+       if (context->hasClient)
+       {
+         computeConnectedClients();
+       }
+     }
+     if (CServer::serverLevel==2)
+     {
+       computeWrittenIndex() ;
+       if (serverDistribution_!=0) serverDistribution_->partialClear() ;
+       if (clientDistribution_!=0) clientDistribution_->partialClear() ;
+       outGlobalIndexFromClient.clear() ;
+     }
+   }
+   CATCH_DUMP_ATTR
+   /*!
+      Compute the global of (client) grid to send to server with the global index of each element of grid
+      Each element of grid has its own global index associated to a groups of server. We only search for the global index of each element whose
+      server is the same, then calculate the global index of grid. This way can reduce so much the time for executing DHT, which only needs to run
+      on each element whose size is much smaller than one of whole grid.
+      \param [in] indexServerOnElement global index of each element and the rank of server associated with these index
+      \param [in] client contextClient
+      \param [out] globalIndexOnServer global index of grid and its corresponding rank of server.
+   */
+   void CGrid::computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
+                                     const CContextClient* client,
+                                     CClientServerMapping::GlobalIndexMap& globalIndexOnServer)
+   TRY
+   {
+     int serverSize = client->serverSize;
+     std::vector<CDomain*> domList = getDomains();
+     std::vector<CAxis*> axisList = getAxis();
+     // Some pre-calculations of global index on each element of current grid.
+     int nbElement = axis_domain_order.numElements();
+     std::vector<CArray<size_t,1> > globalIndexElement(nbElement);
+     int domainIdx = 0, axisIdx = 0, scalarIdx = 0;
+     std::vector<size_t> elementNGlobal(nbElement);
+     elementNGlobal[0] = 1;
+     size_t globalSize = 1;
+     for (int idx = 0; idx < nbElement; ++idx)
+     {
+       elementNGlobal[idx] = globalSize;
+       size_t elementSize;
+       size_t elementGlobalSize = 1;
+       if (2 == axis_domain_order(idx)) // This is domain
+       {
+         elementSize = domList[domainIdx]->i_index.numElements();
+         globalIndexElement[idx].resize(elementSize);
+         for (int jdx = 0; jdx < elementSize; ++jdx)
+         {
+           globalIndexElement[idx](jdx) = (domList[domainIdx]->i_index)(jdx) + domList[domainIdx]->ni_glo * (domList[domainIdx]->j_index)(jdx);
+         }
+         elementGlobalSize = domList[domainIdx]->ni_glo.getValue() * domList[domainIdx]->nj_glo.getValue();
+         ++domainIdx;
+       }
+       else if (1 == axis_domain_order(idx))  // This is axis
+       {
+         elementSize = axisList[axisIdx]->index.numElements();
+         globalIndexElement[idx].resize(elementSize);
+         for (int jdx = 0; jdx < elementSize; ++jdx)
+         {
+           globalIndexElement[idx](jdx) = (axisList[axisIdx]->index)(jdx);
+         }
+         elementGlobalSize = axisList[axisIdx]->n_glo.getValue();
+         ++axisIdx;
+       }
+       else  // Of course, this is scalar
+       {
+         globalIndexElement[idx].resize(1);
+         globalIndexElement[idx](0) = 0;
+         elementGlobalSize = 1;
+       }
+       globalSize *= elementGlobalSize;
+     }
+     std::vector<std::vector<bool> > elementOnServer(nbElement, std::vector<bool>(serverSize, false));
+     std::vector<std::unordered_map<int,std::vector<size_t> > > globalElementIndexOnServer(nbElement);
+     CArray<int,1> nbIndexOnServer(serverSize); // Number of distributed global index held by each client for each server
+     // Number of temporary distributed global index held by each client for each server
+     // We have this variable for the case of non-distributed element (often axis) to check the duplicate server rank
+     CArray<int,1> nbIndexOnServerTmp(serverSize);
+     for (int idx = 0; idx < nbElement; ++idx)
+     {
+       nbIndexOnServer = 0;
+       const std::unordered_map<size_t,std::vector<int> >& indexServerElement = indexServerOnElement[idx];
+       const CArray<size_t,1>& globalIndexElementOnClient = globalIndexElement[idx];
+       CClientClientDHTInt clientClientDHT(indexServerElement, client->intraComm);
+       clientClientDHT.computeIndexInfoMapping(globalIndexElementOnClient);
+       const CClientClientDHTInt::Index2VectorInfoTypeMap& globalIndexElementOnServerMap = clientClientDHT.getInfoIndexMap();
+       CClientClientDHTInt::Index2VectorInfoTypeMap::const_iterator itb = globalIndexElementOnServerMap.begin(),
+                                                                    ite = globalIndexElementOnServerMap.end(), it;
+       for (it = itb; it != ite; ++it)
+       {
+         const std::vector<int>& tmp = it->second;
+         nbIndexOnServerTmp = 0;
+         for (int i = 0; i < tmp.size(); ++i)
+         {
+           if (0 == nbIndexOnServerTmp(tmp[i])) ++nbIndexOnServerTmp(tmp[i]);
+         }
+         nbIndexOnServer += nbIndexOnServerTmp;
+       }
+       for (int i = 0; i < serverSize; ++i)
+       {
+         if (0 != nbIndexOnServer(i))
+         {
+           globalElementIndexOnServer[idx][i].resize(nbIndexOnServer(i));
+           elementOnServer[idx][i] = true;
+         }
+       }
+     nbIndexOnServer = 0;
+     for (size_t j = 0; j < globalIndexElementOnServerMap.size(); ++j)
+     {
+       it = globalIndexElementOnServerMap.find(globalIndexElementOnClient(j));
+       if (it != ite)
+       {
+         const std::vector<int>& tmp = it->second;
+         nbIndexOnServerTmp = 0;
+         for (int i = 0; i < tmp.size(); ++i)
+         {
+           if (0 == nbIndexOnServerTmp(tmp[i]))
+           {
+             globalElementIndexOnServer[idx][tmp[i]][nbIndexOnServer(tmp[i])] = it->first;
+             ++nbIndexOnServerTmp(tmp[i]);
+           }
+         }
+         nbIndexOnServer += nbIndexOnServerTmp;
+       }
+     }
+   }
+    // Determine server which contain global source index
+    std::vector<bool> intersectedProc(serverSize, true);
+    for (int idx = 0; idx < nbElement; ++idx)
+    {
+      std::transform(elementOnServer[idx].begin(), elementOnServer[idx].end(),
+                     intersectedProc.begin(), intersectedProc.begin(),
+                     std::logical_and<bool>());
+    }
+    std::vector<int> srcRank;
+    for (int idx = 0; idx < serverSize; ++idx)
+    {
+      if (intersectedProc[idx]) srcRank.push_back(idx);
+    }
+    // Compute the global index of grid from global index of each element.
+    for (int i = 0; i < srcRank.size(); ++i)
+    {
+      size_t ssize = 1;
+      int rankSrc = srcRank[i];
+      std::vector<std::vector<size_t>* > globalIndexOfElementTmp(nbElement);
+      std::vector<size_t> currentIndex(nbElement,0);
+      for (int idx = 0; idx < nbElement; ++idx)
+      {
+        ssize *= (globalElementIndexOnServer[idx][rankSrc]).size();
+        globalIndexOfElementTmp[idx] = &(globalElementIndexOnServer[idx][rankSrc]);
+      }
+      globalIndexOnServer[rankSrc].resize(ssize);
+      std::vector<int> idxLoop(nbElement,0);
+      int innnerLoopSize = (globalIndexOfElementTmp[0])->size();
+      size_t idx = 0;
+      while (idx < ssize)
+      {
+        for (int ind = 0; ind < nbElement; ++ind)
+        {
+          if (idxLoop[ind] == (globalIndexOfElementTmp[ind])->size())
+          {
+            idxLoop[ind] = 0;
+            ++idxLoop[ind+1];
+          }
+          currentIndex[ind] = (*(globalIndexOfElementTmp[ind]))[idxLoop[ind]];
+        }
+        for (int ind = 0; ind < innnerLoopSize; ++ind)
+        {
+          currentIndex[0] = (*globalIndexOfElementTmp[0])[ind];
+          size_t globalSrcIndex = 0;
+          for (int idxElement = 0; idxElement < nbElement; ++idxElement)
+          {
+            globalSrcIndex += currentIndex[idxElement] * elementNGlobal[idxElement];
+          }
+          globalIndexOnServer[rankSrc][idx] = globalSrcIndex;
+          ++idx;
+          ++idxLoop[0];
+        }
+      }
+    }
+   }
+   CATCH_DUMP_ATTR
+//----------------------------------------------------------------
+   CGrid* CGrid::createGrid(CDomain* domain)
+   TRY
+   {
+      std::vector<CDomain*> vecDom(1, domain);
+      std::vector<CAxis*> vecAxis;
+      return createGrid(vecDom, vecAxis);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
+   TRY
+  {
+      std::vector<CDomain*> vecDom(1, domain);
+      std::vector<CAxis*> vecAxis(1, axis);
+      return createGrid(vecDom, vecAxis);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+     std::vector<CScalar*> vecScalar;
+     return createGrid(generateId(domains, axis, vecScalar, axisDomainOrder), domains, axis, vecScalar, axisDomainOrder);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+     return createGrid(generateId(domains, axis, scalars, axisDomainOrder), domains, axis, scalars, axisDomainOrder);
+   }
+   CATCH
+   CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   TRY
+   {
+      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
+        ERROR("CGrid* CGrid::createGrid(...)",
+              << "The size of axisDomainOrder (" << axisDomainOrder.numElements()
+              << ") is not coherent with the number of elements (" << domains.size() + axis.size() <<").");
+      CGrid* grid = CGridGroup::get("grid_definition")->createChild(id);
+      grid->setDomainList(domains);
+      grid->setAxisList(axis);
+      grid->setScalarList(scalars);
+      // By default, domains are always the first elements of a grid
+      if (0 == axisDomainOrder.numElements())
+      {
+        int size = domains.size() + axis.size() + scalars.size();
+        int nb = 0;
+        grid->axis_domain_order.resize(size);
+        for (int i = 0; i < size; ++i)
+        {
+          if (i < domains.size()) {
+            grid->axis_domain_order(i) = 2;
+          }
+          else if ((scalars.size() < (size-nb)) < size) {
+            grid->axis_domain_order(i) = 1;
+          }
+          else
+            grid->axis_domain_order(i) = 0;
+          ++nb;
+        }
+      }
+      else
+      {
+        grid->axis_domain_order.resize(axisDomainOrder.numElements());
+        grid->axis_domain_order = axisDomainOrder;
+      }
+      grid->solveDomainAxisRefInheritance(true);
+      return grid;
+   }
+   CATCH
+   }
+  bool CGrid::isDataDistributed(void)
+  {
+    return getClientDistribution()->isDataDistributed() ;
+  }
    CGrid* CGrid::cloneGrid(const StdString& idNewGrid, CGrid* gridSrc)
 …
    CATCH
    //----------------------------------------------------------------
+   CDomainGroup* CGrid::getVirtualDomainGroup() const
+   TRY
+   {
+     return this->vDomainGroup_;
+   }
+   CATCH
+   CAxisGroup* CGrid::getVirtualAxisGroup() const
+   TRY
+   {
+     return this->vAxisGroup_;
+   }
+   CATCH
+   CScalarGroup* CGrid::getVirtualScalarGroup() const
+   TRY
+   {
+     return this->vScalarGroup_;
+   }
+   CATCH
+/*
+   void CGrid::outputField(int rank, const CArray<double, 1>& stored, double* field)
+   {
+     const CArray<size_t,1>& out_i = outIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       field[out_i(n)] = stored(n);
+     }
+   }
+   void CGrid::inputField(int rank, const double* const field, CArray<double,1>& stored)
+   {
+     const CArray<size_t,1>& out_i = outIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       stored(n) = field[out_i(n)];
+     }
+   }
+   void CGrid::outputCompressedField(int rank, const CArray<double,1>& stored, double* field)
+   {
+     const CArray<size_t,1>& out_i = compressedOutIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       field[out_i(n)] = stored(n);
+     }
+   }
+*/
+   //----------------------------------------------------------------
+   void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const
+   TRY
+   {
+      const StdSize size = storeIndex_client.numElements();
+      stored.resize(size);
+      for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
+   }
+   CATCH
+   void CGrid::restoreField_arr(const CArray<double, 1>& stored, double* const data) const
+   TRY
+   {
+      const StdSize size = storeIndex_client.numElements();
+      for(StdSize i = 0; i < size; i++) data[storeIndex_client(i)] = stored(i);
+   }
+   CATCH
+   void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored) const
+   {
+      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;
+      else
+        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
+   }
+   void CGrid::uncompressField_arr(const double* const data, CArray<double, 1>& out) const
+   TRY
+   {
+      const std::vector<int>& localMaskedDataIndex = clientDistribution_->getLocalMaskedDataIndexOnClient();
+      const int size = localMaskedDataIndex.size();
+      for(int i = 0; i < size; ++i) out(localMaskedDataIndex[i]) = data[i];
+   }
+   CATCH
+  void CGrid::computeClientIndexScalarGrid()
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    {
+      CContextClient* client = context->client;
+      int rank = client->clientRank;
+      clientDistribution_ = new CDistributionClient(rank, this);
+      storeIndex_client.resize(1);
+      storeIndex_client(0) = 0;
+      if (0 != serverDistribution_)
+      {
+        map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(),
+                                               ite = outGlobalIndexFromClient.end(), it;
+        for (it = itb; it != ite; ++it)
+        {
+          int rank = it->first;
+          CArray<size_t,1>& globalIndex = outGlobalIndexFromClient[rank];
+          outLocalIndexStoreOnClient.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements())));
+          CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank];
+          if (1 != globalIndex.numElements())
+            ERROR("void CGrid::computeClientIndexScalarGrid()",
+              << "Something wrong happened. "
+              << "Number of received global index on scalar grid should equal to 1"
+              << "Number of received global index " << globalIndex.numElements() << ".");
+          localIndex(0) = globalIndex(0);
+        }
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::computeConnectedClientsScalarGrid()
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    int nbSrvPools = (context->clientPrimServer.size()==0) ? 1 : context->clientPrimServer.size();
+    connectedServerRank_.clear();
+    connectedDataSize_.clear();
+    nbSenders.clear();
+    for (int p = 0; p < nbSrvPools; ++p)
+    {
+      CContextClient* client = (context->clientPrimServer.size()==0) ? context->client : context->clientPrimServer[p];
+      int receiverSize = client->serverSize;
+//      connectedServerRank_[client].clear();
+      if (connectedServerRank_.find(receiverSize)==connectedServerRank_.end())
+      {
+        if (client->isServerLeader())
+        {
+          const std::list<int>& ranks = client->getRanksServerLeader();
+          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+          {
+            int rank = *itRank;
+            int nb = 1;
+            connectedServerRank_[receiverSize].push_back(rank);
+            connectedDataSize_[receiverSize][rank] = nb;
+            nbSenders[receiverSize][rank] = nb;
+          }
+        }
+        else
+        {
+          const std::list<int>& ranks = client->getRanksServerNotLeader();
+          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+          {
+            int rank = *itRank;
+            int nb = 1;
+            connectedServerRank_[receiverSize].push_back(rank);
+            connectedDataSize_[receiverSize][rank] = nb;
+            nbSenders[receiverSize][rank] = nb;
+          }
+        }
+      }
+      isDataDistributed_ = false;
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::sendIndexScalarGrid()
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    storeIndex_toSrv.clear();
+    std::list<CContextClient*>::iterator it;
+    for (it=clients.begin(); it!=clients.end(); ++it)
+    {
+      CContextClient* client = *it;
+      int receiverSize = client->serverSize;
+      CEventClient event(getType(), EVENT_ID_INDEX);
+      list<CMessage> listMsg;
+      list<CArray<size_t,1> > listOutIndex;
+      if (client->isServerLeader())
+      {
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          int rank = *itRank;
+          int nb = 1;
+          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<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back();
+          for (int k = 0; k < nb; ++k)
+          {
+            outGlobalIndexOnServer(k) = 0;
+            outLocalIndexToServer(k)  = 0;
+          }
+          if (context->hasClient && !context->hasServer)
+            storeIndex_fromSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
+          listMsg.push_back(CMessage());
+          listMsg.back() << getId( )<< isDataDistributed_ << isCompressible_ << listOutIndex.back();
+          event.push(rank, 1, listMsg.back());
+        }
+        client->sendEvent(event);
+      }
+      else
+      {
+        const std::list<int>& ranks = client->getRanksServerNotLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+        {
+          int rank = *itRank;
+          int nb = 1;
+          CArray<int, 1> outLocalIndexToServer(nb);
+          for (int k = 0; k < nb; ++k)
+          {
+            outLocalIndexToServer(k)  = 0;
+          }
+          if (context->hasClient && !context->hasServer)
+            storeIndex_fromSrv.insert(std::make_pair(rank, CArray<int,1>(outLocalIndexToServer)));
+        }
+        client->sendEvent(event);
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::sendIndex(void)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    storeIndex_toSrv.clear();
+    std::list<CContextClient*>::iterator it;
+    for (it=clients.begin(); it!=clients.end(); ++it)
+    {
+      CContextClient* client = *it;
+      int receiverSize = client->serverSize;
+      CEventClient event(getType(), EVENT_ID_INDEX);
+      int rank;
+      list<CMessage> listMsg;
+      list<CArray<size_t,1> > listOutIndex;
+      const CDistributionClient::GlobalLocalDataMap& globalLocalIndexSendToServer = clientDistribution_->getGlobalLocalDataSendToServer();
+      CDistributionClient::GlobalLocalDataMap::const_iterator itbIndex = globalLocalIndexSendToServer.begin(), itIndex,
+                                                              iteIndex = globalLocalIndexSendToServer.end();
+      itIndex = itbIndex;
+      if (!doGridHaveDataDistributed(client))
+      {
+        if (client->isServerLeader())
+        {
+          int indexSize = globalLocalIndexSendToServer.size();
+          CArray<size_t,1> outGlobalIndexOnServer(indexSize);
+          CArray<int,1> outLocalIndexToServer(indexSize);
+          for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx)
+          {
+            outGlobalIndexOnServer(idx) = itIndex->first;
+            outLocalIndexToServer(idx) = itIndex->second;
+          }
+          const std::list<int>& ranks = client->getRanksServerLeader();
+          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)));
+            if (context->hasClient && !context->hasServer)
+              storeIndex_fromSrv.insert(std::make_pair(*itRank, CArray<int,1>(outLocalIndexToServer)));
+            listOutIndex.push_back(CArray<size_t,1>(outGlobalIndexOnServer));
+            listMsg.push_back(CMessage());
+            listMsg.back() << getId() << isDataDistributed_ << isCompressible_ << listOutIndex.back();
+            event.push(*itRank, 1, listMsg.back());
+          }
+          client->sendEvent(event);
+        }
+        else
+        {
+           int indexSize = globalLocalIndexSendToServer.size();
+           CArray<int,1> outLocalIndexToServer(indexSize);
+           for (int idx = 0; itIndex != iteIndex; ++itIndex, ++idx)
+           {
+             outLocalIndexToServer(idx) = itIndex->second;
+           }
+           const std::list<int>& ranks = client->getRanksServerNotLeader();
+           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)));
+           }
+           client->sendEvent(event);
+         }
+      }
+      else
+      {
+        CClientServerMapping::GlobalIndexMap::const_iterator iteGlobalMap, itGlobalMap;
+        itGlobalMap = globalIndexOnServer_[receiverSize].begin();
+        iteGlobalMap = globalIndexOnServer_[receiverSize].end();
+        std::map<int,std::vector<int> >localIndexTmp;
+        std::map<int,std::vector<size_t> > globalIndexTmp;
+        for (; itGlobalMap != iteGlobalMap; ++itGlobalMap)
+        {
+          int serverRank = itGlobalMap->first;
+          int indexSize = itGlobalMap->second.size();
+          const std::vector<size_t>& indexVec = itGlobalMap->second;
+          for (int idx = 0; idx < indexSize; ++idx)
+          {
+            itIndex = globalLocalIndexSendToServer.find(indexVec[idx]);
+            if (iteIndex != itIndex)
+            {
+              globalIndexTmp[serverRank].push_back(itIndex->first);
+              localIndexTmp[serverRank].push_back(itIndex->second);
+            }
+          }
+        }
+        for (int ns = 0; ns < connectedServerRank_[receiverSize].size(); ++ns)
+        {
+          rank = connectedServerRank_[receiverSize][ns];
+          int nb = 0;
+          if (globalIndexTmp.end() != globalIndexTmp.find(rank))
+            nb = globalIndexTmp[rank].size();
+          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<size_t, 1>& outGlobalIndexOnServer = listOutIndex.back();
+          for (int k = 0; k < nb; ++k)
+          {
+            outGlobalIndexOnServer(k) = globalIndexTmp[rank].at(k);
+            outLocalIndexToServer(k)  = localIndexTmp[rank].at(k);
+          }
+          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());
+        }
+        client->sendEvent(event);
+      }
+    }
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::recvIndex(CEventServer& event)
+  TRY
+  {
+    string gridId;
+    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;
+      *buffer >> gridId;
+      buffers.push_back(buffer);
+    }
+    get(gridId)->recvIndex(ranks, buffers);
+  }
+  CATCH
+  void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    connectedServerRankRead_ = ranks;
+    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1;
+    nbSrvPools = 1;
+    nbReadSenders.clear();
+    for (int p = 0; p < nbSrvPools; ++p)
+    {
+      CContextServer* server = (!context->hasClient) ? context->server : context->serverPrimServer[p];
+      CContextClient* client = context->client;   //(!context->hasClient) ? context->client : context->clientPrimServer[p];
+      int idx = 0, numElement = axis_domain_order.numElements();
+      int ssize = numElement;
+      std::vector<int> indexMap(numElement);
+      for (int i = 0; i < numElement; ++i)
+      {
+        indexMap[i] = idx;
+        if (2 == axis_domain_order(i))
+        {
+          ++ssize;
+          idx += 2;
+        }
+        else
+          ++idx;
+      }
+      for (int n = 0; n < ranks.size(); n++)
+      {
+        int rank = ranks[n];
+        CBufferIn& buffer = *buffers[n];
+        buffer >> isDataDistributed_ >> isCompressible_;
+        size_t dataSize = 0;
+        if (0 == serverDistribution_)
+        {
+          int axisId = 0, domainId = 0, scalarId = 0, globalSize = 1;
+          std::vector<CDomain*> domainList = getDomains();
+          std::vector<CAxis*> axisList = getAxis();
+          std::vector<int> nBegin(ssize), nSize(ssize), nGlob(ssize), nBeginGlobal(ssize), nGlobElement(numElement);
+          std::vector<CArray<int,1> > globalIndex(numElement);
+          for (int i = 0; i < numElement; ++i)
+          {
+            nGlobElement[i] = globalSize;
+            if (2 == axis_domain_order(i)) //domain
+            {
+              nBegin[indexMap[i]] = domainList[domainId]->ibegin;
+              nSize[indexMap[i]]  = domainList[domainId]->ni;
+              nBeginGlobal[indexMap[i]] = 0;
+              nGlob[indexMap[i]] = domainList[domainId]->ni_glo;
+              nBegin[indexMap[i] + 1] = domainList[domainId]->jbegin;
+              nSize[indexMap[i] + 1] = domainList[domainId]->nj;
+              nBeginGlobal[indexMap[i] + 1] = 0;
+              nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo;
+              {
+                int count = 0;
+                globalIndex[i].resize(nSize[indexMap[i]]*nSize[indexMap[i]+1]);
+                for (int jdx = 0; jdx < nSize[indexMap[i]+1]; ++jdx)
+                  for (int idx = 0; idx < nSize[indexMap[i]]; ++idx)
+                  {
+                    globalIndex[i](count) = (nBegin[indexMap[i]] + idx) + (nBegin[indexMap[i]+1] + jdx) * nGlob[indexMap[i]];
+                    ++count;
+                  }
+              }
+              ++domainId;
+            }
+            else if (1 == axis_domain_order(i)) // axis
+            {
+              nBegin[indexMap[i]] = axisList[axisId]->begin;
+              nSize[indexMap[i]]  = axisList[axisId]->n;
+              nBeginGlobal[indexMap[i]] = 0;
+              nGlob[indexMap[i]] = axisList[axisId]->n_glo;
+              globalIndex[i].resize(nSize[indexMap[i]]);
+              for (int idx = 0; idx < nSize[indexMap[i]]; ++idx)
+                globalIndex[i](idx) = nBegin[indexMap[i]] + idx;
+              ++axisId;
+            }
+            else // scalar
+            {
+              nBegin[indexMap[i]] = 0;
+              nSize[indexMap[i]]  = 1;
+              nBeginGlobal[indexMap[i]] = 0;
+              nGlob[indexMap[i]] = 1;
+              globalIndex[i].resize(1);
+              globalIndex[i](0) = 0;
+              ++scalarId;
+            }
+          }
+          dataSize = 1;
+          for (int i = 0; i < nSize.size(); ++i)
+            dataSize *= nSize[i];
+          serverDistribution_ = new CDistributionServer(server->intraCommRank,
+                                                        globalIndex, axis_domain_order,
+                                                        nBegin, nSize, nBeginGlobal, nGlob);
+        }
+        CArray<size_t,1> outIndex;
+        buffer >> outIndex;
+        outGlobalIndexFromClient.insert(std::make_pair(rank, outIndex));
+        connectedDataSizeRead_[rank] = outIndex.numElements();
+        if (doGridHaveDataDistributed(client))
+        {}
+        else
+        {
+          // THE PROBLEM HERE IS THAT DATA CAN BE NONDISTRIBUTED ON CLIENT AND DISTRIBUTED ON SERVER
+          // BELOW IS THE TEMPORARY FIX only for a single type of element (domain, asix, scalar)
+          dataSize = serverDistribution_->getGridSize();
+        }
+        writtenDataSize_ += dataSize;
+      }
+      // Compute mask of the current grid
+      {
+        int axisId = 0, domainId = 0, scalarId = 0, globalSize = 1;
+        std::vector<CDomain*> domainList = getDomains();
+        std::vector<CAxis*> axisList = getAxis();
+        int dimSize = 2 * domainList.size() + axisList.size();
+        std::vector<int> nBegin(dimSize), nSize(dimSize), nGlob(dimSize), nBeginGlobal(dimSize);
+        for (int i = 0; i < numElement; ++i)
+        {
+          if (2 == axis_domain_order(i)) //domain
+          {
+            nBegin[indexMap[i]] = domainList[domainId]->ibegin;
+            nSize[indexMap[i]]  = domainList[domainId]->ni;
+            nBeginGlobal[indexMap[i]] = 0;
+            nGlob[indexMap[i]] = domainList[domainId]->ni_glo;
+            nBegin[indexMap[i] + 1] = domainList[domainId]->jbegin;
+            nSize[indexMap[i] + 1] = domainList[domainId]->nj;
+            nBeginGlobal[indexMap[i] + 1] = 0;
+            nGlob[indexMap[i] + 1] = domainList[domainId]->nj_glo;
+            ++domainId;
+          }
+          else if (1 == axis_domain_order(i)) // axis
+          {
+            nBegin[indexMap[i]] = axisList[axisId]->begin;
+            nSize[indexMap[i]]  = axisList[axisId]->n;
+            nBeginGlobal[indexMap[i]] = 0;
+            nGlob[indexMap[i]] = axisList[axisId]->n_glo;
+            ++axisId;
+          }
+          else // scalar
+          {
+          }
+        }
+        if (nSize.empty()) // Scalar grid
+        {
+          nBegin.push_back(0);
+          nSize.push_back(1);
+          nBeginGlobal.push_back(0);
+          nGlob.push_back(1);
+        }
+      }
+      if (isScalarGrid()) return;
+      nbReadSenders[client] = CClientServerMappingDistributed::computeConnectedClients(context->client->serverSize, context->client->clientSize, context->client->intraComm, ranks);
+    }
+  }
+  CATCH_DUMP_ATTR
   /*
      Compute on the fly the global dimension of a grid with its elements
 …
   TRY
+  {
      return (0 != writtenDataSize_);
+     return (0 != getGridLocalElements()->getView(CElementView::FULL)->getSize());
+  }
   CATCH_DUMP_ATTR
+  /*!
+    Return size of data which is written on each server
+    Whatever dimension of a grid, data which are written on server must be presented as
+    an one dimension array.
+    \return size of data written on server
+  */
+  size_t CGrid::getWrittenDataSize() const
+  TRY
+  {
+    return writtenDataSize_;
+  }
+  CATCH
+  /*!
+    Returns the number of indexes written by each server.
+    \return the number of indexes written by each server
+  */
+  int CGrid::getNumberWrittenIndexes() const
+  TRY
+  {
+    return numberWrittenIndexes_;
+  }
+  CATCH
+  /*!
+    Returns the total number of indexes written by the servers.
+    \return the total number of indexes written by the servers
+  */
+  int CGrid::getTotalNumberWrittenIndexes() const
+  TRY
+  {
+    return totalNumberWrittenIndexes_;
+  }
+  CATCH
+  /*!
+    Returns the offset of indexes written by each server.
+    \return the offset of indexes written by each server
+  */
+  int CGrid::getOffsetWrittenIndexes() const
+  TRY
+  {
+    return offsetWrittenIndexes_;
+  }
+  CATCH
+  CDistributionServer* CGrid::getDistributionServer()
+  TRY
+  {
+    return serverDistribution_;
+  }
+  CATCH_DUMP_ATTR
+  CDistributionClient* CGrid::getDistributionClient()
+  TRY
+  {
+    return clientDistribution_;
+  }
+  CATCH_DUMP_ATTR
   bool CGrid::doGridHaveDataDistributed(CContextClient* client)
   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)
+    {
       return  (isDataDistributed_ ||  (1 != client->clientSize) || (1 != client->serverSize));
+      return  (isDataDistributed() ||  (1 != client->clientSize) || (1 != client->serverSize));
+    }
     else
       return isDataDistributed_;
+      return isDataDistributed();
+  }
   CATCH_DUMP_ATTR
 …
       switch(event.type)
+      {
-        case EVENT_ID_INDEX :
-          recvIndex(event);
-          return true;
-          break;
          case EVENT_ID_ADD_DOMAIN :
            recvAddDomain(event);
 …
            return true;
            break;
+         case EVENT_ID_SEND_MASK :
+           recvMask(event);
+           return true;
+           break;
         default :
           ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
+          ERROR("bool CGrid::dispatchEvent(CEventServer& event)",
                 << "Unknown Event");
           return false;
 …
   CATCH
+   ///---------------------------------------------------------------
+   CDomain* CGrid::addDomain(const std::string& id)
+   TRY
+   {
+     order_.push_back(2);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     return vDomainGroup_->createChild(id);
+   }
+   CATCH_DUMP_ATTR
+   CAxis* CGrid::addAxis(const std::string& id)
+   TRY
+   {
+     order_.push_back(1);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     return vAxisGroup_->createChild(id);
+   }
+   CATCH_DUMP_ATTR
+   CScalar* CGrid::addScalar(const std::string& id)
+   TRY
+   {
+     order_.push_back(0);
+     axis_domain_order.resize(order_.size());
+     for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
+     return vScalarGroup_->createChild(id);
+   }
+   CATCH_DUMP_ATTR
+   //! Change virtual field group to a new one
+   void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
+   TRY
+   {
+      this->vDomainGroup_ = newVDomainGroup;
+   }
+   CATCH_DUMP_ATTR
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualAxisGroup(CAxisGroup* newVAxisGroup)
+   TRY
+   {
+      this->vAxisGroup_ = newVAxisGroup;
+   }
+   CATCH_DUMP_ATTR
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualScalarGroup(CScalarGroup* newVScalarGroup)
+   TRY
+   {
+      this->vScalarGroup_ = newVScalarGroup;
+   }
+   CATCH_DUMP_ATTR
+  void CGrid::sendGridToFileServer(CContextClient* client)
+  {
+    if (sendGridToFileServer_done_.count(client)!=0) return ;
+    else sendGridToFileServer_done_.insert(client) ;
+    StdString gridDefRoot("grid_definition");
+    CGridGroup* gridPtr = CGridGroup::get(gridDefRoot);
+    gridPtr->sendCreateChild(this->getId(),client);
+    this->sendAllAttributesToServer(client);
+    distributeGridToFileServer(client) ;
+  }
+  void CGrid::distributeGridToFileServer(CContextClient* client)
+  {
+    CContext* context = CContext::getCurrent();
+    // simple Distribution for now
+    // distribute over the fisrt element except if it is a scalar
+    auto& elements = getElements() ;
+    int posDistributed = 0 ;
+    for(auto& element : elements)
+    {
+      if (element.type==TYPE_DOMAIN) break ;
+      else if (element.type==TYPE_AXIS) break ;
+      else if (element.type==TYPE_SCALAR) posDistributed++ ;
+    }
+    vector<CLocalView*> localViews ;
+    vector<CDistributedView*> remoteViews ;
+    for(int i=0 ; i<elements.size() ; i++)
+    {
+      if (elements[i].type==TYPE_DOMAIN)
+      {
+         CDomain* domain = (CDomain*) elements[i].ptr ;
+         domain->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+         remoteViews.push_back(domain->getRemoteElement(client)->getView(CElementView::FULL)) ;
+         localViews.push_back(domain->getLocalView(CElementView::FULL)) ;
+      }
+      else if (elements[i].type==TYPE_AXIS)
+      {
+        CAxis* axis = (CAxis*) elements[i].ptr ;
+        axis->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+        remoteViews.push_back(axis->getRemoteElement(client)->getView(CElementView::FULL)) ;
+        localViews.push_back(axis->getLocalView(CElementView::FULL)) ;
+      }
+      else if (elements[i].type==TYPE_SCALAR)
+      {
+        CScalar* scalar = (CScalar*) elements[i].ptr ;
+        scalar->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+        remoteViews.push_back(scalar->getRemoteElement(client)->getView(CElementView::FULL)) ;
+        localViews.push_back(scalar->getLocalView(CElementView::FULL)) ;
+      }
+    }
+    CGridRemoteConnector gridRemoteConnector(localViews, remoteViews, context->getIntraComm(), client->getRemoteSize()) ;
+    gridRemoteConnector.computeConnector() ;
+    vector<CScattererConnector*> scattererConnectors ;
+    CScattererConnector* scattererConnector;
+    for(int i=0 ; i<elements.size() ; i++)
+    {
+      if (elements[i].type==TYPE_DOMAIN)
+      {
+         CDomain* domain = (CDomain*) elements[i].ptr ;
+         sendAddDomain(domain->getId(),client) ;
+         domain->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ;
+         scattererConnectors.push_back(scattererConnector) ;
+      }
+      else if (elements[i].type==TYPE_AXIS)
+      {
+        CAxis* axis = (CAxis*) elements[i].ptr ;
+        sendAddAxis(axis->getId(),client) ;
+        axis->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ;
+        scattererConnectors.push_back(scattererConnector) ;
+      }
+      else if (elements[i].type==TYPE_SCALAR)
+      {
+        CScalar* scalar = (CScalar*) elements[i].ptr ;
+        sendAddScalar(scalar->getId(),client) ;
+        scalar->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i), scattererConnector) ;
+        scattererConnectors.push_back(scattererConnector) ;
+      }
+    }
+    CGridScattererConnector gridScattererConnector(scattererConnectors) ;
+    CGridLocalConnector* workflowToFull = getGridLocalElements()->getConnector(CElementView::WORKFLOW, CElementView::FULL) ;
+    CArray<bool,1> maskIn(workflowToFull->getSrcSize()) ;
+    CArray<bool,1> maskOut(workflowToFull->getDstSize()) ;
+    maskIn = true ;
+    workflowToFull->transfer(maskIn,maskOut,false) ;
+    CEventClient event(getType(), EVENT_ID_SEND_MASK);
+    CMessage message ;
+    message<<getId() ;
+    gridScattererConnector.transfer(maskOut, client, event, message) ;
+    for(auto& it : scattererConnectors) delete it ;
+    vector<CScattererConnector*> clientToServerConnectors ;
+    vector<CGathererConnector*>  clientFromServerConnectors ;
+    for(auto& element : elements)
+    {
+      if (element.type==TYPE_DOMAIN)
+      {
+         clientToServerConnectors.push_back(element.domain->getClientToServerConnector(client)) ;
+         clientFromServerConnectors.push_back(element.domain->getClientFromServerConnector(client)) ;
+      }
+      else if (element.type==TYPE_AXIS)
+      {
+        clientToServerConnectors.push_back(element.axis->getClientToServerConnector(client)) ;
+        clientFromServerConnectors.push_back(element.axis->getClientFromServerConnector(client)) ;
+      }
+      else if (element.type==TYPE_SCALAR)
+      {
+        clientToServerConnectors.push_back(element.scalar->getClientToServerConnector(client)) ;
+        clientFromServerConnectors.push_back(element.scalar->getClientFromServerConnector(client)) ;
+      }
+    }
+    // compute the grid clientToServerConnector to send flux from client to servers
+    clientToServerConnector_[client] = new CGridScattererConnector(clientToServerConnectors) ;
+    clientFromServerConnector_[client] = new CGridGathererConnector(clientFromServerConnectors) ;
+  }
+  void CGrid::recvMask(CEventServer& event)
+  {
+    string gridId;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> gridId  ;
+    get(gridId)->receiveMask(event);
+  }
+  void CGrid::receiveMask(CEventServer& event)
+  {
+    vector<CGathererConnector*> gathererConnectors ;
+    vector<CLocalView*> fullViews ;
+    for(auto& element : getElements())
+    {
+      if (element.type==TYPE_DOMAIN)
+      {
+        gathererConnectors.push_back(element.domain->getGathererConnector());
+        fullViews.push_back(element.domain->getLocalElement()->getView(CElementView::FULL));
+      }
+      else if (element.type==TYPE_AXIS)
+      {
+       gathererConnectors.push_back(element.axis->getGathererConnector());
+       fullViews.push_back(element.axis->getLocalElement()->getView(CElementView::FULL));
+      }
+      else if (element.type==TYPE_SCALAR)
+      {
+        gathererConnectors.push_back(element.scalar->getGathererConnector());
+        fullViews.push_back(element.scalar->getLocalElement()->getView(CElementView::FULL));
+      }
+    }
+    CGridGathererConnector gridGathererConnector(gathererConnectors) ;
+    CGridMaskConnector gridMaskConnector(fullViews) ;
+    CArray<bool,1> maskOut ;
+    gridGathererConnector.transfer_or(event,maskOut) ;
+    gridMaskConnector.computeConnector(maskOut) ;
+    CContextClient* client = event.getContextServer()->getAssociatedClient() ;
+    int i=0 ;
+    for(auto& element : getElements())
+    {
+      if (element.type==TYPE_DOMAIN) element.domain->setServerMask(gridMaskConnector.getElementMask(i),client);
+      else if (element.type==TYPE_AXIS) element.axis->setServerMask(gridMaskConnector.getElementMask(i),client);
+      else if (element.type==TYPE_SCALAR) element.scalar->setServerMask(gridMaskConnector.getElementMask(i),client);
+      i++ ;
+    }
+  }
+  void CGrid::sendGridToCouplerOut(CContextClient* client, const string& fieldId)
+  {
+/*    if (sendGridToCouplerOut_done_.count(client)!=0) return ;
+    else sendGridToCouplerOut_done_.insert(client) ;
+    CContext* context = CContext::getCurrent();
+    // simple Distribution for now
+    // distribute over the fisrt element except if it is a scalar
+    auto& elements = getElements() ;
+    int posDistributed = 0 ;
+    for(auto& element : elements)
+    {
+      if (element.type==TYPE_DOMAIN) break ;
+      else if (element.type==TYPE_AXIS) break ;
+      else if (element.type==TYPE_SCALAR) posDistributed++ ;
+    }
+    vector<CLocalView*> localViews ;
+    vector<CDistributedView*> remoteViews ;
+    for(int i=0 ; i<elements.size() ; i++)
+    {
+      if (elements[i].type==TYPE_DOMAIN)
+      {
+         CDomain* domain = (CDomain*) elements[i].ptr ;
+         domain->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+         remoteViews.push_back(domain->getRemoteElement(client)->getView(CElementView::FULL)) ;
+         localViews.push_back(domain->getLocalView(CElementView::FULL)) ;
+      }
+      else if (elements[i].type==TYPE_AXIS)
+      {
+        CAxis* axis = (CAxis*) elements[i].ptr ;
+        axis->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+        remoteViews.push_back(axis->getRemoteElement(client)->getView(CElementView::FULL)) ;
+        localViews.push_back(axis->getLocalView(CElementView::FULL)) ;
+      }
+      else if (elements[i].type==TYPE_SCALAR)
+      {
+        CScalar* scalar = (CScalar*) elements[i].ptr ;
+        scalar->computeRemoteElement(client, posDistributed==i ? EDistributionType::BANDS : EDistributionType::NONE) ;
+        remoteViews.push_back(scalar->getRemoteElement(client)->getView(CElementView::FULL)) ;
+        localViews.push_back(scalar->getLocalView(CElementView::FULL)) ;
+      }
+    }
+    CGridRemoteConnector gridRemoteConnector(localViews, remoteViews, context->getIntraComm(), client->getRemoteSize()) ;
+    gridRemoteConnector.computeConnector() ;
+    vector<CScattererConnector*> clientToClientConnectors ;
+    for(int i=0 ; i<elements.size() ; i++)
+    {
+      if (elements[i].type==TYPE_DOMAIN)
+      {
+         CDomain* domain = (CDomain*) elements[i].ptr ;
+         sendAddDomain(domain->getId(),client) ;
+         domain->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ;
+         clientToClientConnectors.push_back(domain->getClientToServerConnector(client)) ;
+      }
+      else if (elements[i].type==TYPE_AXIS)
+      {
+        CAxis* axis = (CAxis*) elements[i].ptr ;
+        sendAddAxis(axis->getId(),client) ;
+        axis->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ;
+        clientToClientConnectors.push_back(axis->getClientToServerConnector(client)) ;
+      }
+      else if (elements[i].type==TYPE_SCALAR)
+      {
+        CScalar* scalar = (CScalar*) elements[i].ptr ;
+        sendAddScalar(scalar->getId(),client) ;
+        scalar->distributeToServer(client, gridRemoteConnector.getDistributedGlobalIndex(i)) ;
+        clientToClientConnectors.push_back(scalar->getClientToServerConnector(client)) ;
+      }
+    }
+    // compute the grid clientToServerConnector to send flux from client to servers
+    clientToClientConnector_[client] = new CGridScattererConnector(clientToClientConnectors) ;*/
+  }
+  void CGrid::makeAliasForCoupling(const string& fieldId)
+  {
+    string gridId="_grid_of_"+fieldId ;
+    createAlias(gridId) ;
+    const auto& domVect = getDomains() ;
+    for (int pos=0; pos<domVect.size();pos++) domVect[pos]->makeAliasForCoupling(fieldId, pos);
+    const auto& axisVect=getAxis() ;
+    for (int pos=0; pos<axisVect.size();pos++) axisVect[pos]->makeAliasForCoupling(fieldId, pos);
+    const auto& scalVect=getScalars() ;
+    for (int pos=0; pos<scalVect.size();pos++) scalVect[pos]->makeAliasForCoupling(fieldId, pos);
+  }
    /*!
 …
    \param[in] id String identity of domain that will be created on server
    */
    void CGrid::sendAddDomain(const string& id)
    TRY
+  {
       sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN);
+   void CGrid::sendAddDomain(const string& id, CContextClient* contextClient)
+   TRY
+  {
+      sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN, contextClient);
+   }
    CATCH_DUMP_ATTR
 …
    \param[in] id String identity of axis that will be created on server
    */
    void CGrid::sendAddAxis(const string& id)
    TRY
+   {
       sendAddItem(id, (int)EVENT_ID_ADD_AXIS);
+   void CGrid::sendAddAxis(const string& id, CContextClient* contextClient)
+   TRY
+   {
+      sendAddItem(id, (int)EVENT_ID_ADD_AXIS, contextClient);
+   }
    CATCH_DUMP_ATTR
 …
    \param[in] id String identity of scalar that will be created on server
    */
    void CGrid::sendAddScalar(const string& id)
    TRY
+   {
       sendAddItem(id, (int)EVENT_ID_ADD_SCALAR);
+   void CGrid::sendAddScalar(const string& id, CContextClient* contextClient)
+   TRY
+   {
+      sendAddItem(id, (int)EVENT_ID_ADD_SCALAR, contextClient);
+   }
    CATCH_DUMP_ATTR
 …
+   }
    CATCH_DUMP_ATTR
+  /*!
+  \brief Check if all elements of the grid are complete
+  Before make any grid processing, we must be sure that all grid information elements have
+  been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+  other context (coupling)
+  */
+  bool CGrid::isCompleted(void)
+  {
+    setDomainList();
+    for (auto domainId : domList_) if (!CDomain::get(domainId)->isCompleted()) return false ;
+    setAxisList() ;
+    for (auto axisId : axisList_) if (!CAxis::get(axisId)->isCompleted()) return false ;
+    setScalarList() ;
+    for (auto scalarId : scalarList_) if (!CScalar::get(scalarId)->isCompleted()) return false ;
+    return true ;
+  }
+  /*!
+  \brief impose that all elements of the grid are complete
+  Before make any grid processing, we must be sure that all grid information elements have
+  been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+  other context (coupling)
+  */
+  void CGrid::setCompleted(void)
+  {
+    setDomainList();
+    for (auto domainId : domList_) CDomain::get(domainId)->setCompleted() ;
+    setAxisList() ;
+    for (auto axisId : axisList_) CAxis::get(axisId)->setCompleted() ;
+    setScalarList() ;
+    for (auto scalarId : scalarList_) CScalar::get(scalarId)->setCompleted() ;
+  }
+/*!
+  \brief impose that all elements of the grid are incomplete
+  Before make any grid processing, we must be sure that all grid information elements have
+  been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+  other context (coupling)
+  */
+  void CGrid::unsetCompleted(void)
+  {
+    setDomainList();
+    for (auto domainId : domList_) CDomain::get(domainId)->unsetCompleted() ;
+    setAxisList() ;
+    for (auto axisId : axisList_) CAxis::get(axisId)->unsetCompleted() ;
+    setScalarList() ;
+    for (auto scalarId : scalarList_) CScalar::get(scalarId)->unsetCompleted() ;
+  }
   /*!
 …
   \param[in] apply inherit all attributes of parents (true)
   */
+  void CGrid::solveDomainAxisRefInheritance(bool apply)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    unsigned int vecSize, i;
+    std::vector<StdString>::iterator it, itE;
+  void CGrid::solveElementsRefInheritance(bool apply)
+  TRY
+  {
     setDomainList();
+    it = domList_.begin(); itE = domList_.end();
+    for (; it != itE; ++it)
+    {
+      CDomain* pDom = CDomain::get(*it);
+      if (context->hasClient && !context->hasServer)
+      {
+        pDom->solveRefInheritance(apply);
+        pDom->solveInheritanceTransformation();
+      }
+    for (auto domainId : domList_)
+    {
+      CDomain* pDom = CDomain::get(domainId);
+      pDom->solveRefInheritance(apply);
+      pDom->solveInheritanceTransformation();
+    }
     setAxisList();
+    it = axisList_.begin(); itE = axisList_.end();
+    for (; it != itE; ++it)
+    {
+      CAxis* pAxis = CAxis::get(*it);
+      if (context->hasClient && !context->hasServer)
+      {
+        pAxis->solveRefInheritance(apply);
+        pAxis->solveInheritanceTransformation();
+      }
+    for (auto axisId : axisList_)
+    {
+      CAxis* pAxis = CAxis::get(axisId);
+      pAxis->solveRefInheritance(apply);
+      pAxis->solveInheritanceTransformation();
+    }
     setScalarList();
+    it = scalarList_.begin(); itE = scalarList_.end();
+    for (; it != itE; ++it)
+    {
+      CScalar* pScalar = CScalar::get(*it);
+      if (context->hasClient && !context->hasServer)
+      {
+        pScalar->solveRefInheritance(apply);
+        pScalar->solveInheritanceTransformation();
+      }
+    for (auto scalarId : scalarList_)
+    {
+      CScalar* pScalar = CScalar::get(scalarId);
+      pScalar->solveRefInheritance(apply);
+      pScalar->solveInheritanceTransformation();
+    }
+  }
   CATCH_DUMP_ATTR
+  bool CGrid::isTransformed()
+  TRY
+  {
+    return isTransformed_;
+ /*!
+  \brief check attributes of all elements of the grid
+  */
+  void CGrid::checkElementsAttributes(void)
+  TRY
+  {
+    setDomainList();
+    for (auto domainId : domList_) CDomain::get(domainId)->checkAttributes();
+    setAxisList();
+    for (auto axisId : axisList_) CAxis::get(axisId)->checkAttributes();
+    setScalarList();
+    for (auto scalarId : scalarList_) CScalar::get(scalarId)->checkAttributes();
+  }
   CATCH_DUMP_ATTR
+  void CGrid::setTransformed()
+  TRY
+  {
+    isTransformed_ = true;
+//**********************************************************
+//**************   New transformation method  **************
+//**********************************************************
+  std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> >
+  CGrid::buildTransformationGraph(CGarbageCollector& gc, bool isSource, CGrid* gridSrc, double detectMissingValues, double defaultValue, CGrid*& newGrid, bool graphEnabled)
+  TRY
+  {
+    registerAlgorithmTransformation() ; // needed to enable self-registration of the transformations
+                                        // big mystery why it doesn't work witout that...
+                                        // problem with the linker ??
+    std::shared_ptr<CFilter> inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc));
+    std::shared_ptr<CFilter> outputFilter = inputFilter ;
+    string newId ;
+    if (gridSrc!=nullptr) newId = gridSrc->getId() + " --> " + this->getId()  ;
+    else newId = " --> " + this->getId()  ;
+    bool isNewGrid ;
+    if (CGrid::has(newId))
+    {
+      cout<<"Retrive existing grid : "<<newId<<endl ;
+      newGrid = CGrid::get(newId);
+      isNewGrid = false ;
+    }
+    else
+    {
+      cout<<"Create new grid : "<<newId<<endl ;
+      newGrid = CGrid::create(newId) ;
+      isNewGrid = true ;
+    }
+    bool hadTransform=false ;
+    bool hasTransform=false ;
+    bool hasRemainTransform=false ;
+    CGenericAlgorithmTransformation* algo ;
+    int pos ;
+    for(int i=0 ; i<elements_.size(); i++)
+    {
+      CTransformationPaths transformationPath ;
+      auto dstElement = elements_[i] ;
+      if (dstElement.type==TYPE_DOMAIN)      transformationPath = dstElement.domain->getTransformationPaths() ;
+      else if (dstElement.type==TYPE_AXIS)   transformationPath = dstElement.axis->getTransformationPaths() ;
+      else if (dstElement.type==TYPE_SCALAR) transformationPath = dstElement.scalar->getTransformationPaths() ;
+      SElement srcElement  ;
+      if (gridSrc==nullptr) srcElement = this->elements_[i] ;
+      else srcElement = gridSrc->elements_[i] ;
+      if (gridSrc==nullptr) transformationPath.mergePaths() ;
+      else
+      {
+        if (srcElement.type==TYPE_DOMAIN)      transformationPath.mergePaths(srcElement.domain->getTransformationPaths()) ;
+        else if (srcElement.type==TYPE_AXIS)   transformationPath.mergePaths(srcElement.axis->getTransformationPaths()) ;
+        else if (srcElement.type==TYPE_SCALAR) transformationPath.mergePaths(srcElement.scalar->getTransformationPaths()) ;
+      }
+      hasTransform=transformationPath.hasTransform()  ;
+      if (hasTransform && !hadTransform)
+      {
+        pos=i ;
+        EElement dstElementType=transformationPath.getNextElementType() ;
+        string dstElementId=transformationPath.getNextElementId() ;
+        string srcElementId=transformationPath.getNextElementSrcId() ;
+        auto transType = transformationPath.getNextTransformationType() ;
+        auto transId = transformationPath.getNextTransformationId() ;
+        CGrid* tmpGridSrc=CGrid::create(); // source grid
+        if (srcElement.type==TYPE_DOMAIN)      tmpGridSrc->addDomain(srcElement.domain->getId()) ;
+        else if (srcElement.type==TYPE_AXIS)   tmpGridSrc->addAxis(srcElement.axis->getId()) ;
+        else if (srcElement.type==TYPE_SCALAR) tmpGridSrc->addScalar(srcElement.scalar->getId()) ;
+        tmpGridSrc->checkElementsAttributes() ;
+        CGrid* tmpGridDst=CGrid::create(); // destination Grid
+        map<int,int> posInGrid={{0,0}} ;
+        cout<<"--> New transform from "<<srcElementId<<" to "<<dstElementId<<endl ;
+        if (dstElementType==EElement::DOMAIN)
+        {
+          CDomain* dstDomain ;
+          CDomain* lastDstDomain ;
+          bool isGenerate=false ;
+          do
+          {
+            if (CDomain::has(dstElementId))
+            {
+              dstDomain = CDomain::get(dstElementId) ;
+              cout<<"Retrive existing domain : "<<dstElementId<<endl ;
+            }
+            else
+            {
+              dstDomain = CDomain::create() ;
+              dstDomain->createAlias(dstElementId) ;
+              cout<<"Create new domain : "<<dstDomain->getId()<<" with alias : "<<dstElementId<<endl ;
+              if (isGenerate) dstDomain->duplicateAttributes(lastDstDomain) ;
+              else if (srcElementId=="" && srcElement.type==TYPE_DOMAIN)  dstDomain->duplicateAttributes(srcElement.domain) ; // make a copy
+              else dstDomain->duplicateAttributes(dstElement.domain) ; // make a copy
+              CTransformation<CDomain>* transformation = CTransformation<CDomain>::createTransformation(transType,"") ;
+              auto srcTransform = CTransformation<CDomain>::getTransformation(transType, transId) ;
+              transformation->inheritFrom(srcTransform) ;
+              CGrid* tmpGridDst=CGrid::create(); // destination Grid
+              tmpGridDst->addDomain(dstDomain->getId()) ;
+              algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,
+                                                       posInGrid,posInGrid,posInGrid,
+                                                       posInGrid,posInGrid,posInGrid );
+              dstDomain->setTransformationAlgorithm(algo) ;
+              dstDomain->setTransformationPaths(transformationPath) ;
+            }
+            algo=dstDomain->getTransformationAlgorithm() ;
+            isGenerate = algo->isGenerateTransformation() ;
+            transformationPath.removeNextTransform() ;
+            dstElementId=transformationPath.getNextElementId() ;
+            srcElementId=transformationPath.getNextElementSrcId() ;
+            transType = transformationPath.getNextTransformationType() ;
+            transId = transformationPath.getNextTransformationId() ;
+            lastDstDomain=dstDomain ;
+            dstDomain->setTransformationPaths(transformationPath) ;
+          } while(transformationPath.hasTransform() && isGenerate) ;
+          if (isNewGrid) newGrid->addDomain(dstDomain->getId()) ;
+          algo = dstDomain->getTransformationAlgorithm() ;
+        }
+        else if (dstElementType==EElement::AXIS)
+        {
+          CAxis* dstAxis ;
+          CAxis* lastDstAxis ;
+          bool isGenerate=false ;
+          do
+          {
+            if (CAxis::has(dstElementId))
+            {
+              dstAxis = CAxis::get(dstElementId) ;
+              cout<<"Retrive existing axis : "<<dstElementId<<endl ;
+            }
+            else
+            {
+              dstAxis = CAxis::create() ;
+              dstAxis->createAlias(dstElementId) ;
+              cout<<"Create new axis : "<<dstAxis->getId()<<" with alias : "<<dstElementId<<endl ;
+              if (isGenerate) dstAxis->duplicateAttributes(lastDstAxis) ;
+              else if (srcElementId=="" && srcElement.type==TYPE_AXIS)  dstAxis->duplicateAttributes(srcElement.axis) ; // make a copy
+              else dstAxis->duplicateAttributes(dstElement.axis) ; // make a copy
+              CTransformation<CAxis>* transformation = CTransformation<CAxis>::createTransformation(transType,"") ;
+              auto srcTransform = CTransformation<CAxis>::getTransformation(transType, transId) ;
+              transformation->inheritFrom(srcTransform) ;
+              tmpGridDst->addAxis(dstAxis->getId()) ;
+              algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,
+                                                      posInGrid,posInGrid,posInGrid,
+                                                      posInGrid,posInGrid,posInGrid );
+              dstAxis->setTransformationAlgorithm(algo) ;
+              dstAxis->setTransformationPaths(transformationPath) ;
+            }
+            algo=dstAxis->getTransformationAlgorithm() ;
+            isGenerate = algo->isGenerateTransformation() ;
+            transformationPath.removeNextTransform() ;
+            dstElementId=transformationPath.getNextElementId() ;
+            srcElementId=transformationPath.getNextElementSrcId() ;
+            transType = transformationPath.getNextTransformationType() ;
+            transId = transformationPath.getNextTransformationId() ;
+            lastDstAxis=dstAxis ;
+            dstAxis->setTransformationPaths(transformationPath) ;
+          } while(transformationPath.hasTransform() && isGenerate) ;
+          if (isNewGrid) newGrid->addAxis(dstAxis->getId()) ;
+          algo = dstAxis->getTransformationAlgorithm() ;
+        }
+        else if (dstElementType==EElement::SCALAR)
+        {
+          CScalar* dstScalar ;
+          CScalar* lastDstScalar ;
+          bool isGenerate=false ;
+          do
+          {
+            if (CScalar::has(dstElementId))
+            {
+              dstScalar = CScalar::get(dstElementId) ;
+              cout<<"Retrive existing scalar : "<<dstElementId<<endl ;
+            }
+            else
+            {
+              dstScalar = CScalar::create() ;
+              dstScalar->createAlias(dstElementId) ;
+              cout<<"Create new scalar : "<<dstScalar->getId()<<" with alias : "<<dstElementId<<endl ;
+              if (isGenerate) dstScalar->duplicateAttributes(lastDstScalar) ;
+              else if (srcElementId=="" && srcElement.type==TYPE_SCALAR)  dstScalar->duplicateAttributes(srcElement.scalar) ; // make a copy
+              else dstScalar->duplicateAttributes(dstElement.scalar) ; // make a copy
+              CTransformation<CScalar>* transformation = CTransformation<CScalar>::createTransformation(transType,"") ;
+              auto srcTransform = CTransformation<CScalar>::getTransformation(transType, transId) ;
+              transformation->inheritFrom(srcTransform) ;
+              tmpGridDst->addScalar(dstScalar->getId()) ;
+              algo = transformation -> createAlgorithm(false, tmpGridDst, tmpGridSrc, 0,
+                                                       posInGrid,posInGrid,posInGrid,
+                                                       posInGrid,posInGrid,posInGrid );
+              dstScalar->setTransformationAlgorithm(algo) ;
+              dstScalar->setTransformationPaths(transformationPath) ;
+            }
+            algo=dstScalar->getTransformationAlgorithm() ;
+            isGenerate = algo->isGenerateTransformation() ;
+            transformationPath.removeNextTransform() ;
+            dstElementId=transformationPath.getNextElementId() ;
+            srcElementId=transformationPath.getNextElementSrcId() ;
+            transType = transformationPath.getNextTransformationType() ;
+            transId = transformationPath.getNextTransformationId() ;
+            lastDstScalar=dstScalar ;
+            dstScalar->setTransformationPaths(transformationPath) ;
+          } while(transformationPath.hasTransform() && isGenerate) ;
+          if (isNewGrid) newGrid->addScalar(dstScalar->getId()) ;
+          algo = dstScalar->getTransformationAlgorithm() ;
+        }
+        // here create a new spatial filter with algo
+        hadTransform=true ;
+        hasTransform=false ;
+      }
+      else
+      {
+        string srcElementId=transformationPath.getNextElementSrcId() ;
+        if (srcElement.type==TYPE_DOMAIN)
+        {
+          CDomain* domain ;
+          if (srcElementId=="") srcElementId=srcElement.domain->getId() ;
+          if (!CDomain::has(srcElementId))
+          {
+            domain=srcElement.domain ;
+            domain->createAlias(srcElementId) ;
+          }
+          else domain = CDomain::get(srcElementId) ;
+          domain->checkAttributes() ;
+          if (isNewGrid) newGrid->addDomain(srcElementId) ;
+        }
+        else if (srcElement.type==TYPE_AXIS)
+        {
+          CAxis* axis ;
+          if (srcElementId=="") srcElementId=srcElement.axis->getId() ;
+          if (!CAxis::has(srcElementId))
+          {
+            axis=srcElement.axis ;
+            axis->createAlias(srcElementId) ;
+          }
+          else axis = CAxis::get(srcElementId) ;
+          axis->checkAttributes() ;
+          if (isNewGrid) newGrid->addAxis(srcElementId) ;
+        }
+        else if (srcElement.type==TYPE_SCALAR)
+        {
+          CScalar* scalar ;
+          if (srcElementId=="") srcElementId=srcElement.scalar->getId() ;
+          if (!CScalar::has(srcElementId))
+          {
+            scalar=srcElement.scalar ;
+            scalar->createAlias(srcElementId) ;
+          }
+          else scalar = CScalar::get(srcElementId) ;
+          scalar->checkAttributes() ;
+          if (isNewGrid) newGrid->addScalar(srcElementId) ;
+        }
+      }
+      if (transformationPath.hasTransform() && hadTransform) hasRemainTransform=true ;
+    }
+    if (hadTransform)
+    {
+      if (!isSource)
+      {
+        CGridAlgorithm* gridAlgorithm  ;
+        if (isNewGrid)
+        {
+          gridAlgorithm = algo->createGridAlgorithm(gridSrc, newGrid, pos) ;
+          newGrid->setGridAlgorithm(gridAlgorithm);
+        }
+        else gridAlgorithm = newGrid->getGridAlgorithm() ;
+        shared_ptr<CTransformFilter> transformFilter = shared_ptr<CTransformFilter>(gridAlgorithm->createTransformFilter(gc, detectMissingValues, defaultValue)) ;
+        outputFilter->connectOutput(transformFilter,0) ;
+        vector<string> auxFieldId = algo->getAuxFieldId() ; // better to do that at transformation not algo ??
+        int i=1;
+        for (auto& it : auxFieldId)
+        {
+          CField* auxField = CField::get(it) ;
+          auxField->buildWorkflowGraph(gc) ;
+          auxField->getInstantDataFilter()->connectOutput(transformFilter,i) ;
+          i++ ;
+        }
+        outputFilter = transformFilter ;
+      }
+      if (hasRemainTransform)
+      {
+        gridSrc=newGrid ;
+        pair<shared_ptr<CFilter>, shared_ptr<CFilter> > filters = this->buildTransformationGraph(gc, isSource, gridSrc, detectMissingValues, defaultValue, newGrid) ;
+        outputFilter->connectOutput(filters.first,0) ;
+        outputFilter=filters.second ;
+      }
+    }
+    return {inputFilter,outputFilter} ;
+  }
   CATCH_DUMP_ATTR
+  CGridTransformation* CGrid::getTransformations()
+  TRY
+  {
+    return transformations_;
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::addTransGridSource(CGrid* gridSrc)
+  TRY
+  {
+    if (gridSrc_.end() == gridSrc_.find(gridSrc))
+      gridSrc_.insert(make_pair(gridSrc,make_pair(false,"")));
+  }
+  CATCH_DUMP_ATTR
+  std::map<CGrid*,std::pair<bool,StdString> >& CGrid::getTransGridSource()
+  TRY
+  {
+    return gridSrc_;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+     Complete all the necessary (and lacking) attributes of a grid
+     This function is similar to gridTransformation but works only (till now) on generate_rectilinear_domain transformation
+  */
+  void CGrid::completeGrid(CGrid* transformGridSrc)
+  TRY
+  {
+    if (0 != transformGridSrc)
+    {
+      if (axis_domain_order.numElements() != transformGridSrc->axis_domain_order.numElements())
+      {
+        ERROR("CGrid::completeGrid(CGrid* transformGridSrc)",
+             << "Two grids have different number of elements. " << std::endl
+             << "Number of element of grid destination " << this->getId() << " is " << axis_domain_order.numElements() << std::endl
+             << "Number of element of grid source " << transformGridSrc->getId() << " is " << transformGridSrc->axis_domain_order.numElements());
+      }
+    }
+    if (isGenerated()) return;
+    setGenerated();
+    CGridGenerate gridGenerate(this, transformGridSrc);
+    gridGenerate.completeGrid();
+  }
+  CATCH_DUMP_ATTR
+  bool CGrid::isGenerated()
+  TRY
+  {
+    return isGenerated_;
+  }
+  CATCH
+  void CGrid::setGenerated()
+  TRY
+  {
+    isGenerated_ = true;
+  }
+  CATCH_DUMP_ATTR
+  void CGrid::transformGrid(CGrid* transformGridSrc)
+  TRY
+  {
+    if (!transformGridSrc)
+      ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
+            << "Impossible to transform grid '" << getId() << "', the source grid is null.");
+    if (isTransformed()) return;
+    setTransformed();
+    if (axis_domain_order.numElements() != transformGridSrc->axis_domain_order.numElements())
+    {
+      ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
+           << "Two grids have different number of elements. " << std::endl
+           << "Number of element of grid destination " << this->getId() << " is " << axis_domain_order.numElements() << std::endl
+           << "Number of element of grid source " << transformGridSrc->getId() << " is " << transformGridSrc->axis_domain_order.numElements());
+    }
+//****************************************************************
+//****************************************************************
+//----------------------------------------------------------------
+  CGrid* CGrid::duplicateSentGrid(void)
+  {
+    CGrid* newGrid ;
+    string sentGridId="sent__"+getId() ;
+    if (has(sentGridId)) newGrid = get(sentGridId) ;
     else
+    {
+    }
+    transformations_ = new CGridTransformation(this, transformGridSrc);
+    transformations_->computeAll();
+    if (0 < transformations_->getNbAlgo()) hasTransform_ = true;
+    // Ok, now need to compute index of grid source
+    transformGridSrc->checkMaskIndex(false);
+  }
+  CATCH_DUMP_ATTR
+  bool CGrid::hasTransform()
+  TRY
+  {
+    if (hasTransform_) return hasTransform_;
+    std::vector<CDomain*> domList = getDomains();
+    std::vector<CAxis*> axisList = getAxis();
+    std::vector<CScalar*> scalarList = getScalars();
+    for (int idx = 0; idx < domList.size(); ++idx) hasTransform_ |= domList[idx]->hasTransformation();
+    for (int idx = 0; idx < axisList.size(); ++idx) hasTransform_ |= axisList[idx]->hasTransformation();
+    for (int idx = 0; idx < scalarList.size(); ++idx) hasTransform_ |= scalarList[idx]->hasTransformation();
+    return hasTransform_;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of domain pointers
+  \return list of domain pointers
+  */
+  std::vector<CDomain*> CGrid::getDomains()
+  TRY
+  {
+    std::vector<CDomain*> domList;
+    if (!domList_.empty())
+    {
+      for (int i = 0; i < domList_.size(); ++i) domList.push_back(CDomain::get(domList_[i]));
+    }
+    return domList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of  axis pointers
+  \return list of axis pointers
+  */
+  std::vector<CAxis*> CGrid::getAxis()
+  TRY
+  {
+    std::vector<CAxis*> aList;
+    if (!axisList_.empty())
+      for (int i =0; i < axisList_.size(); ++i) aList.push_back(CAxis::get(axisList_[i]));
+    return aList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the list of  axis pointers
+  \return list of axis pointers
+  */
+  std::vector<CScalar*> CGrid::getScalars()
+  TRY
+  {
+    std::vector<CScalar*> sList;
+    if (!scalarList_.empty())
+      for (int i =0; i < scalarList_.size(); ++i) sList.push_back(CScalar::get(scalarList_[i]));
+    return sList;
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get domain pointer with index
+  \return domain pointer
+  */
+  CDomain* CGrid::getDomain(int domainIndex)
+  TRY
+  {
+    std::vector<CDomain*> domainListP = this->getDomains();
+    if (domainListP.empty())
+    {
+      ERROR("CGrid::getDomain(int domainIndex)",
+            << "No domain associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (domainIndex >= domainListP.size() || (domainIndex < 0))
+      ERROR("CGrid::getDomain(int domainIndex)",
+            << "Domain with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << domainListP.size() << " domain but domain index required is " << domainIndex << std::endl);
+    return domainListP[domainIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the axis pointer with index
+  \return axis pointer
+  */
+  CAxis* CGrid::getAxis(int axisIndex)
+  TRY
+  {
+    std::vector<CAxis*> axisListP = this->getAxis();
+    if (axisListP.empty())
+    {
+      ERROR("CGrid::getDomain(int axisIndex)",
+            << "No axis associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (axisIndex >= axisListP.size() || (axisIndex < 0))
+      ERROR("CGrid::getDomain(int axisIndex)",
+            << "Domain with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << axisListP.size() << " axis but axis index required is " << axisIndex << std::endl);
+    return axisListP[axisIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get the a scalar pointer
+  \return scalar pointer
+  */
+  CScalar* CGrid::getScalar(int scalarIndex)
+  TRY
+  {
+    std::vector<CScalar*> scalarListP = this->getScalars();
+    if (scalarListP.empty())
+    {
+      ERROR("CGrid::getScalar(int scalarIndex)",
+            << "No scalar associated to this grid. " << std::endl
+            << "Grid id = " << this->getId());
+    }
+    if (scalarIndex >= scalarListP.size() || (scalarIndex < 0))
+      ERROR("CGrid::getScalar(int scalarIndex)",
+            << "Scalar with the index doesn't exist " << std::endl
+            << "Grid id = " << this->getId() << std::endl
+            << "Grid has only " << scalarListP.size() << " scalar but scalar index required is " << scalarIndex << std::endl);
+    return scalarListP[scalarIndex];
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set domain(s) of a grid from a list
+  \param[in] domains list of domains
+  */
+  void CGrid::setDomainList(const std::vector<CDomain*> domains)
+  TRY
+  {
+    if (isDomListSet) return;
+    std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
+    if (!domains.empty() && domList.empty())
+    {
+      for (int i = 0; i < domains.size(); ++i)
+        this->getVirtualDomainGroup()->addChild(domains[i]);
+      domList = this->getVirtualDomainGroup()->getAllChildren();
+    }
+    if (!domList.empty())
+    {
+      int sizeDom = domList.size();
+      domList_.resize(sizeDom);
+      for (int i = 0; i < sizeDom; ++i)
+      {
+        domList_[i] = domList[i]->getId();
+      }
+      isDomListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set axis(s) of a grid from a list
+  \param[in] axis list of axis
+  */
+  void CGrid::setAxisList(const std::vector<CAxis*> axis)
+  TRY
+  {
+    if (isAxisListSet) return;
+    std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
+    if (!axis.empty() && aList.empty())
+    {
+      for (int i = 0; i < axis.size(); ++i)
+        this->getVirtualAxisGroup()->addChild(axis[i]);
+      aList = this->getVirtualAxisGroup()->getAllChildren();
+    }
+    if (!aList.empty())
+    {
+      int sizeAxis = aList.size();
+      axisList_.resize(sizeAxis);
+      for (int i = 0; i < sizeAxis; ++i)
+      {
+        axisList_[i] = aList[i]->getId();
+      }
+      isAxisListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Set scalar(s) of a grid from a list
+  \param[in] scalars list of scalars
+  */
+  void CGrid::setScalarList(const std::vector<CScalar*> scalars)
+  TRY
+  {
+    if (isScalarListSet) return;
+    std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
+    if (!scalars.empty() && sList.empty())
+    {
+      for (int i = 0; i < scalars.size(); ++i)
+        this->getVirtualScalarGroup()->addChild(scalars[i]);
+      sList = this->getVirtualScalarGroup()->getAllChildren();
+    }
+    if (!sList.empty())
+    {
+      int sizeScalar = sList.size();
+      scalarList_.resize(sizeScalar);
+      for (int i = 0; i < sizeScalar; ++i)
+      {
+        scalarList_[i] = sList[i]->getId();
+      }
+      isScalarListSet = true;
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+  \brief Get list of id of domains
+  \return id list of domains
+  */
+  std::vector<StdString> CGrid::getDomainList()
+  TRY
+  {
+    setDomainList();
+    return domList_;
+  }
+  CATCH
+  /*!
+  \brief Get list of id of axis
+  \return id list of axis
+  */
+  std::vector<StdString> CGrid::getAxisList()
+  TRY
+  {
+    setAxisList();
+    return axisList_;
+  }
+  CATCH
+  /*!
+  \brief Get list of id of scalar
+  \return id list of scalar
+  */
+  std::vector<StdString> CGrid::getScalarList()
+  TRY
+  {
+    setScalarList();
+    return scalarList_;
+  }
+  CATCH
+  /*!
+    Send all attributes of domains from client to server
+  */
+  void CGrid::sendAllDomains()
+  TRY
+  {
+    std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
+    int dSize = domList.size();
+    for (int i = 0; i < dSize; ++i)
+    {
+      sendAddDomain(domList[i]->getId());
+      domList[i]->sendAllAttributesToServer();
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Send all attributes of axis from client to server
+  */
+  void CGrid::sendAllAxis()
+  TRY
+  {
+    std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
+    int aSize = aList.size();
+    for (int i = 0; i < aSize; ++i)
+    {
+      sendAddAxis(aList[i]->getId());
+      aList[i]->sendAllAttributesToServer();
+    }
+  }
+  CATCH_DUMP_ATTR
+  /*!
+    Send all attributes of scalars from client to server
+  */
+  void CGrid::sendAllScalars()
+  TRY
+  {
+    std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
+    int sSize = sList.size();
+    for (int i = 0; i < sSize; ++i)
+    {
+      sendAddScalar(sList[i]->getId());
+      sList[i]->sendAllAttributesToServer();
+    }
+  }
+  CATCH_DUMP_ATTR
+      newGrid = CGrid::create(sentGridId) ;
+      for(auto element : elements_)
+      {
+        if (element.type==TYPE_DOMAIN)
+        {
+          CDomain* domain = CDomain::create();
+          domain->duplicateAttributes(element.domain) ;
+          domain->name = element.domain->getId() ;
+          newGrid->addDomain(domain->getId()) ;
+        }
+        else if (element.type==TYPE_AXIS)
+        {
+          CAxis* axis = CAxis::create();
+          axis->duplicateAttributes(element.axis) ;
+          axis->name = element.axis->getId() ;
+          newGrid->addAxis(axis->getId()) ;
+        }
+        else if (element.type==TYPE_SCALAR)
+        {
+          CScalar* scalar = CScalar::create();
+          scalar->duplicateAttributes(element.scalar) ;
+          scalar->name = element.scalar->getId() ;
+          newGrid->addScalar(scalar->getId()) ;
+        }
+      }
+      newGrid->checkElementsAttributes() ;
+    }
+    return newGrid ;
+  }
   void CGrid::setContextClient(CContextClient* contextClient)
 …
       clientsSet.insert(contextClient);
+    }
     for (int i=0; i<this->getDomains().size(); i++)
         this->getDomains()[i]->setContextClient(contextClient);
     for (int i=0; i<this->getAxis().size(); i++)
         this->getAxis()[i]->setContextClient(contextClient);
+    for (auto domain : getDomains()) domain->setContextClient(contextClient);
+    for (auto axis : getAxis()) axis->setContextClient(contextClient);
+    for (auto scalar : getScalars()) scalar->setContextClient(contextClient);
+  }
   CATCH_DUMP_ATTR
+  /*!
+    Parse a grid, for now, it contains only domain, axis and scalar
+  */
+  void CGrid::parse(xml::CXMLNode& node)
+  TRY
+  {
+    SuperClass::parse(node);
+    if (node.goToChildElement())
+    {
+      StdString domainName("domain");
+      StdString axisName("axis");
+      StdString scalarName("scalar");
+      do
+      {
+        if (node.getElementName() == domainName) {
+          order_.push_back(2);
+          this->getVirtualDomainGroup()->parseChild(node);
+        }
+        if (node.getElementName() == axisName) {
+          order_.push_back(1);
+          this->getVirtualAxisGroup()->parseChild(node);
+        }
+        if (node.getElementName() == scalarName) {
+          order_.push_back(0);
+          this->getVirtualScalarGroup()->parseChild(node);
+        }
+      } while (node.goToNextElement());
+      node.goToParentElement();
+    }
+    if (!order_.empty())
+    {
+      int sizeOrd = order_.size();
+      axis_domain_order.resize(sizeOrd);
+      for (int i = 0; i < sizeOrd; ++i)
+      {
+        axis_domain_order(i) = order_[i];
+      }
+    }
+    setDomainList();
+    setAxisList();
+    setScalarList();
+   }
+  CATCH_DUMP_ATTR
+  void CGrid::computeGridLocalElements()
+  {
+    std::vector<CDomain*> domainList = this->getDomains();
+    std::vector<CAxis*> axisList = this->getAxis();
+    std::vector<CScalar*> scalarList = this->getScalars();
+    auto domain=domainList.begin() ;
+    auto axis=axisList.begin() ;
+    auto scalar=scalarList.begin() ;
+    vector<CLocalElement*> elements;
+    for(auto order : order_)
+    {
+      if (order==2)
+      {
+        elements.push_back((*domain)->getLocalElement());
+        domain++ ;
+      }
+      else if (order==1)
+      {
+        elements.push_back((*axis)->getLocalElement());
+        axis++ ;
+      }
+      else if (order==0)
+      {
+        elements.push_back((*scalar)->getLocalElement());
+        scalar++ ;
+      }
+    }
+    if (hasMask())
+    {
+      vector<bool> mask(getMask().getVector()) ;
+      gridLocalElements_ = new CGridLocalElements(elements, mask) ;
+    }
+    else gridLocalElements_ = new CGridLocalElements(elements) ;
+  }
+  void CGrid::computeModelToWorkflowConnector(void)
+  {
+    modelToWorkflowConnector_ = getGridLocalElements()->getConnector(CElementView::MODEL,CElementView::WORKFLOW,true) ;
+  }
+  void CGrid::computeWorkflowToFullConnector(void)
+  {
+    workflowToFullConnector_ = getGridLocalElements()->getConnector(CElementView::WORKFLOW,CElementView::FULL) ;
+  }
+  void CGrid::computeWorkflowToModelConnector(void)
+  {
+    workflowToModelConnector_ = getGridLocalElements()->getConnector(CElementView::WORKFLOW,CElementView::MODEL,true) ;
+  }
+  void CGrid::computeFullToWorkflowConnector(void)
+  {
+    fullToWorkflowConnector_ = getGridLocalElements()->getConnector(CElementView::FULL,CElementView::WORKFLOW) ;
+  }
+  void CGrid::computeServerFromClientConnector(void)
+  {
+    vector<CGathererConnector*> connectors ;
+    for(auto& element : getElements())
+    {
+      if (element.type==TYPE_DOMAIN) connectors.push_back(element.domain->getServerFromClientConnector()) ;
+      else if (element.type==TYPE_AXIS) connectors.push_back(element.axis->getServerFromClientConnector()) ;
+      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerFromClientConnector()) ;
+    }
+    serverFromClientConnector_ = new CGridGathererConnector(connectors) ;
+  }
+  void CGrid::computeServerToClientConnector(void)
+  {
+    vector<CScattererConnector*> connectors ;
+    for(auto& element : getElements())
+    {
+      if (element.type==TYPE_DOMAIN) connectors.push_back(element.domain->getServerToClientConnector()) ;
+      else if (element.type==TYPE_AXIS) connectors.push_back(element.axis->getServerToClientConnector()) ;
+      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerToClientConnector()) ;
+    }
+    serverToClientConnector_ = new CGridScattererConnector(connectors) ;
+  }
+  void CGrid::computeClientFromClientConnector(void)
+  {
+    vector<CGathererConnector*> connectors ;
+    for(auto& element : getElements())
+    {
+      if (element.type==TYPE_DOMAIN) connectors.push_back(element.domain->getServerFromClientConnector()) ;
+      else if (element.type==TYPE_AXIS) connectors.push_back(element.axis->getServerFromClientConnector()) ;
+      else if (element.type==TYPE_SCALAR) connectors.push_back(element.scalar->getServerFromClientConnector()) ;
+    }
+    clientFromClientConnector_ = new CGridGathererConnector(connectors) ;
+  }
 } // namespace xios

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

-                      r1653
+                      r2019
 #include "utils.hpp"
 #include "transformation_enum.hpp"
+#include "grid_local_connector.hpp"
+#include "grid_elements.hpp"
+#include "grid_scatterer_connector.hpp"
+#include "grid_gatherer_connector.hpp"
+#include "transformation_path.hpp"
+#include "filter.hpp"
+#include "grid_algorithm.hpp"
 namespace xios {
 …
    class CServerDistributionDescription;
    class CClientServerMapping;
+   class CGridTransformation;
    ///--------------------------------------------------------------
 …
          typedef CGridAttributes SuperClassAttribute;
+      private:
+        // define a structure to store elements (CDomain, CAxis, CScalar) using a void* and a type to cast the pointer
+         enum EElementType { TYPE_SCALAR, TYPE_AXIS, TYPE_DOMAIN } ;
+         struct SElement {void* ptr ; EElementType type ; CScalar* scalar ;  CAxis* axis ; CDomain* domain ; } ;
+         vector<SElement> elements_ ;
+         bool elementsComputed_ = false ;
+         /** retrieve the vector of elements as a structure containing a void* and the type of pointer */
+         vector<SElement>& getElements(void) { if (!elementsComputed_) computeElements() ; return elements_ ; }
+         void computeElements(void) ;
+         /** List order of axis and domain in a grid, if there is a domain, it will take value 2, axis 1, scalar 0 */
+         std::vector<int> order_;
       public:
 …
          enum EEventId
+         {
+           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR
+           EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR,
+           EVENT_ID_SEND_MASK,
          };
 …
          void checkEligibilityForCompressedOutput();
+         void solveDomainAxisRef(bool areAttributesChecked);
          void checkMaskIndex(bool doCalculateIndex);
 …
          StdSize getDimension(void);
+         StdSize  getDataSize(void) const;
+         /// Entrees-sorties de champs
+         template <int n>
+         void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
+         template <int n>
+         void maskField(const CArray<double,n>& field, CArray<double,1>& stored) const;
+         template <int n>
+         void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;
+         template <int n>
+         void uncompressField(const CArray<double,n>& data, CArray<double,1>& outData) const;
+         StdSize  getDataSize(void) ;
+         /**
+          * Get the local data grid size, ie the size of the compressed grid (inside the workflow)
+          * \return The size od the compressed grid
+          */
+         StdSize  getLocalDataSize(void) ;
          virtual void parse(xml::CXMLNode& node);
 …
       public:
+         void computeIndexServer(void);
+         void computeIndex(void);
+         void computeIndexScalarGrid();
+         void computeWrittenIndex();
+         void solveDomainAxisRef(bool areAttributesChecked);
+         void checkElementsAttributes(void) ;
          void solveDomainRef(bool checkAtt);
          void solveAxisRef(bool checkAtt);
          void solveScalarRef(bool checkAtt);
          void solveDomainAxisRefInheritance(bool apply = true);
          void solveTransformations();
+         void solveElementsRefInheritance(bool apply = true);
+        // void solveTransformations();
          void solveDomainAxisBaseRef();
 …
          CAxis* addAxis(const std::string& id=StdString());
          CScalar* addScalar(const std::string& id=StdString());
+         void sendAddDomain(const std::string& id="");
+         void sendAddAxis(const std::string& id="");
+         void sendAddScalar(const std::string& id="");
+         void sendAllDomains();
+         void sendAllAxis();
+         void sendAllScalars();
+      public:
+         void sendGridToFileServer(CContextClient* client) ;
+      private:
+         std::set<CContextClient*> sendGridToFileServer_done_ ;
+      public:
+         void sendGridToCouplerOut(CContextClient* client, const string& fieldId) ;
+      private:
+         std::set<CContextClient*> sendGridToCouplerOut_done_ ;
+      public:
+         void makeAliasForCoupling(const string& fieldId) ;
+      public:
+         void sendAddDomain(const std::string& id,CContextClient* contextClient);
+         void sendAddAxis(const std::string& id,CContextClient* contextClient);
+         void sendAddScalar(const std::string& id,CContextClient* contextClient);
          static void recvAddDomain(CEventServer& event);
          void recvAddDomain(CBufferIn& buffer);
 …
          static bool dispatchEvent(CEventServer& event);
+         static void recvIndex(CEventServer& event);
+         void recvIndex(vector<int> ranks, vector<CBufferIn*> buffers);
+         void sendIndex(void);
+         void sendIndexScalarGrid();
+       public:
          void setContextClient(CContextClient* contextClient);
-         void computeDomConServer();
-         std::map<int, int> getDomConServerSide();
          std::map<int, StdSize> getAttributesBufferSize(CContextClient* client, bool bufferForWriting = false);
          std::map<int, StdSize> getDataBufferSize(CContextClient* client, const std::string& id = "", bool bufferForWriting = false);
 …
          bool doGridHaveDataToWrite();
          bool doGridHaveDataDistributed(CContextClient* client = 0);
+         size_t getWrittenDataSize() const;
+         int getNumberWrittenIndexes() const;
+         int getTotalNumberWrittenIndexes() const;
+         int getOffsetWrittenIndexes() const;
+         CDistributionServer* getDistributionServer();
+         CDistributionClient* getDistributionClient();
+         CGridTransformation* getTransformations();
+         void transformGrid(CGrid* transformGridSrc);
+         void completeGrid(CGrid* transformGridSrc = 0);
+         void doAutoDistribution(CGrid* transformGridSrc);
+         bool isTransformed();
+         void setTransformed();
+         bool isGenerated();
+         void setGenerated();
+         void addTransGridSource(CGrid* gridSrc);
+         std::map<CGrid*, std::pair<bool,StdString> >& getTransGridSource();
+         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> > outIndexFromClient;  // Deprecated
+         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;
+         ///////////////////////////////////////////
+         ////////    TRANSFORMATIONS           /////
+         ///////////////////////////////////////////
+      public:
+         pair<shared_ptr<CFilter>, shared_ptr<CFilter> > buildTransformationGraph(CGarbageCollector& gc, bool isSource, CGrid* gridSrc, double detectMissingValues,
+                                                                                  double defaultValue, CGrid*& newGrid, bool graphEnabled=false) ;
+      private:
+        CGridAlgorithm* gridAlgorithm_ = nullptr ;
+      public:
+        void setGridAlgorithm(CGridAlgorithm* gridAlgorithm) {gridAlgorithm_ = gridAlgorithm;}
+        CGridAlgorithm* getGridAlgorithm(void) { return gridAlgorithm_ ;}
+        ///////////////////////////////////////////
+      public:
+        size_t getGlobalWrittenSize(void) ;
+         bool isCompleted(void) ;
+         void setCompleted(void) ;
+         void unsetCompleted(void) ;
          bool hasMask(void) const;
+         void checkMask(void);
+         void createMask(void);
+         void modifyMask(const CArray<int,1>& indexToModify, bool valueToModify = false);
+         void modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue = false);
+         void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
+                                         const std::vector<CAxis*>& axis,
+                                         const std::vector<CScalar*>& scalars,
+                                         const CArray<int,1>& axisDomainOrder);
+      private:
+       template<int N>
+       void checkGridMask(CArray<bool,N>& gridMask,
+                          const std::vector<CArray<bool,1>* >& domainMasks,
+                          const std::vector<CArray<bool,1>* >& axisMasks,
+                          const CArray<int,1>& axisDomainOrder,
+                          bool createMask = false);
+        template<int N>
+        void modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify);
+        template<int N>
+        void modifyGridMaskSize(CArray<bool,N>& gridMask, const std::vector<int>& eachDimSize, bool newValue);
+        void storeField_arr(const double* const data, CArray<double, 1>& stored) const;
+        void restoreField_arr(const CArray<double, 1>& stored, double* const data) const;
+        void uncompressField_arr(const double* const data, CArray<double, 1>& outData) const;
+        void maskField_arr(const double* const data, CArray<double, 1>& stored) const;
+        /** get mask pointer stored in mask_1d, or mask_2d, or..., or mask_7d */
+         CArray<bool,1> mask_ ;
+         CArray<bool,1>& getMask(void) ;
+      private:
+        /** Client-like distribution calculated based on the knowledge of the entire grid */
+       CDistributionClient* clientDistribution_;
+     public:
+       void computeClientDistribution(void) ;
+     private:
+       bool computeClientDistribution_done_ = false ;
+     public:
+       CDistributionClient* getClientDistribution(void);
+     private:
         void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
         void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
 …
         CScalarGroup* getVirtualScalarGroup() const;
-        void checkAttributesAfterTransformation();
-        void setTransformationAlgorithms();
-        void computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
-                                   const CContextClient* client,
-                                   CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
         int computeGridGlobalDimension(std::vector<int>& globalDim,
                                        const std::vector<CDomain*> domains,
 …
                                        const CArray<int,1>& axisDomainOrder);
         int getDistributedDimension();
+        void computeClientIndex();
+        void computeConnectedClients();
+        void computeClientIndexScalarGrid();
+        void computeConnectedClientsScalarGrid();
+      public:
+        bool isDataDistributed(void) ;
       private:
 …
         std::set<CContextClient*> clientsSet;
+      private:
         bool isChecked;
         bool isDomainAxisChecked;
 …
         bool isAxisListSet, isDomListSet, isScalarListSet;
-/** Client-like distribution calculated based on the knowledge of the entire grid */
-        CDistributionClient* clientDistribution_;
-/** Server-like distribution calculated upon receiving indexes */
-        CDistributionServer* serverDistribution_;
-        CClientServerMapping* clientServerMap_;
-        size_t writtenDataSize_;
-        int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
 /** Map storing local ranks of connected receivers. Key = size of receiver's intracomm.
   * It is calculated in computeConnectedClients(). */
 …
 /** Size of data to be send in case of reading. It is calculated in recvIndex(). */
         std::map<int,size_t> connectedDataSizeRead_;
+        bool isDataDistributed_;
          //! True if and only if the data defined on the grid can be outputted in a compressed way
         bool isCompressible_;
         std::set<std::string> relFilesCompressed;
+        bool isTransformed_, isGenerated_;
+        bool computedWrittenIndex_;
         std::vector<int> axisPositionInGrid_;
+        CGridTransformation* transformations_;
+        void computeAxisPositionInGrid(void) ;
+        bool computeAxisPositionInGrid_done_ = false ;
+        std::vector<int>& getAxisPositionInGrid(void) { if (!computeAxisPositionInGrid_done_) computeAxisPositionInGrid() ; return axisPositionInGrid_ ;}
         bool hasDomainAxisBaseRef_;
         std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
+        bool hasTransform_;
+/** Map storing global indexes of server-like (band-wise) distribution for sending to receivers.
+  * Key = size of receiver's intracomm.
+  */
+//        std::map<CContextClient*, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
+        std::map<int, CClientServerMapping::GlobalIndexMap> globalIndexOnServer_;
+/** List order of axis and domain in a grid, if there is a domain, it will take value 1 (true), axis 0 (false) */
+        std::vector<int> order_;
+     //////////////////////////////////////////////////////////////////////////////////////
+     //  this part is related to distribution, element definition, views and connectors  //
+     //////////////////////////////////////////////////////////////////////////////////////
+      public:
+       CGrid* duplicateSentGrid(void) ;
+      private:
+       static void recvMask(CEventServer& event) ;
+       void receiveMask(CEventServer& event) ;
+      private:
+        CGridLocalElements* gridLocalElements_= nullptr ;
+        void computeGridLocalElements(void) ;
+      public:
+        CGridLocalElements* getGridLocalElements(void) { if (gridLocalElements_==nullptr) computeGridLocalElements() ; return gridLocalElements_ ;}
+      private:
+        CGridLocalConnector* modelToWorkflowConnector_ = nullptr ;
+      public:
+        void computeModelToWorkflowConnector(void) ;
+        CGridLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_;}
+      private:
+        CGridLocalConnector* workflowToModelConnector_ ;
+      public:
+        void computeWorkflowToModelConnector(void) ;
+        CGridLocalConnector* getWorkflowToModelConnector(void) { if (workflowToModelConnector_==nullptr) computeWorkflowToModelConnector() ; return workflowToModelConnector_;}
+      public: //?
+        void distributeGridToFileServer(CContextClient* client);
+      private:
+        CGridLocalConnector* workflowToFullConnector_ = nullptr;
+      public:
+        void computeWorkflowToFullConnector(void) ;
+        CGridLocalConnector* getWorkflowToFullConnector(void) { if (workflowToFullConnector_==nullptr) computeWorkflowToFullConnector() ; return workflowToFullConnector_;}
+      private:
+        CGridLocalConnector* fullToWorkflowConnector_ = nullptr;
+      public:
+        void computeFullToWorkflowConnector(void) ;
+        CGridLocalConnector* getFullToWorkflowConnector(void) { if (fullToWorkflowConnector_==nullptr) computeFullToWorkflowConnector() ; return fullToWorkflowConnector_;}
+      private:
+         CGridGathererConnector* clientFromClientConnector_ = nullptr ;
+      public:
+         CGridGathererConnector* getClientFromClientConnector(void) { if (clientFromClientConnector_==nullptr) computeClientFromClientConnector() ; return clientFromClientConnector_;}
+         void computeClientFromClientConnector(void) ;
+      private:
+         map<CContextClient*, CGridScattererConnector*> clientToClientConnector_ ;
+      public:
+         CGridScattererConnector* getClientToClientConnector(CContextClient* client) { return clientToClientConnector_[client] ;} // make some test to see if connector exits for the given client
+      private:
+         map<CContextClient*,CGridGathererConnector*> clientFromServerConnector_  ;
+      public:
+         CGridGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client];}
+         void computeClientFromServerConnector(void) ;
+      private:
+         CGridScattererConnector* serverToClientConnector_=nullptr ;
+      public:
+         CGridScattererConnector* getServerToClientConnector(void) { if (serverToClientConnector_==nullptr) computeServerToClientConnector() ; return serverToClientConnector_;}
+         void computeServerToClientConnector(void) ;
+      private:
+         map<CContextClient*, CGridScattererConnector*> clientToServerConnector_ ;
+      public:
+         CGridScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;} // make some test to see if connector exits for the given client
+      private:
+         CGridGathererConnector* serverFromClientConnector_ = nullptr ;
+      public:
+         CGridGathererConnector* getServerFromClientConnector(void) { if (serverFromClientConnector_==nullptr) computeServerFromClientConnector() ; return serverFromClientConnector_;}
+         void computeServerFromClientConnector(void) ;
    }; // class CGrid
-   ///--------------------------------------------------------------
-   template <int n>
-   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
-   TRY
+   {
-//#ifdef __XIOS_DEBUG
-      if (this->getDataSize() != field.numElements())
-         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
-                << "[ Awaiting data of size = " << this->getDataSize() << ", "
-                << "Received data size = "      << field.numElements() << " ] "
-                << "The data array does not have the right size! "
-                << "Grid = " << this->getId())
-//#endif
-      this->storeField_arr(field.dataFirst(), stored);
+   }
-   CATCH
-   template <int n>
-   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const
+   {
-//#ifdef __XIOS_DEBUG
-      if (this->getDataSize() != field.numElements())
-         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
-                << "[ Awaiting data of size = " << this->getDataSize() << ", "
-                << "Received data size = "      << field.numElements() << " ] "
-                << "The data array does not have the right size! "
-                << "Grid = " << this->getId())
-//#endif
-      this->maskField_arr(field.dataFirst(), stored);
+   }
-   template <int n>
-   void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const
-   TRY
+   {
-//#ifdef __XIOS_DEBUG
-      if (this->getDataSize() != field.numElements())
-         ERROR("void CGrid::outputField(const CArray<double,1>& stored, CArray<double,n>& field) const",
-                << "[ Size of the data = " << this->getDataSize() << ", "
-                << "Output data size = "   << field.numElements() << " ] "
-                << "The ouput array does not have the right size! "
-                << "Grid = " << this->getId())
-//#endif
-      this->restoreField_arr(stored, field.dataFirst());
+   }
-   CATCH
-   /*!
-     This function removes the effect of mask on received data on the server.
-     This function only serve for the checking purpose. TODO: Something must be done to seperate mask and data_index from each other in received data
-     \data data received data with masking effect on the server
-     \outData data without masking effect
-   */
-   template <int N>
-   void CGrid::uncompressField(const CArray<double,N>& data, CArray<double,1>& outData) const
-   TRY
+   {
-     uncompressField_arr(data.dataFirst(), outData);
+   }
-   CATCH
-   template<int N>
-   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
-                             const std::vector<CArray<bool,1>* >& domainMasks,
-                             const std::vector<CArray<bool,1>* >& axisMasks,
-                             const CArray<int,1>& axisDomainOrder,
-                             bool createMask)
-   TRY
+   {
-     int idx = 0;
-     int numElement = axisDomainOrder.numElements();
-     int dim = domainMasks.size() * 2 + axisMasks.size();
-     std::vector<CDomain*> domainP = this->getDomains();
-     std::vector<CAxis*> axisP = this->getAxis();
-     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
-     std::vector<int> currentIndex(dim);
-     int idxDomain = 0, idxAxis = 0;
-    for (int i = 0; i < numElement; ++i)
+    {
-      indexMap[i] = idx;
-      if (2 == axisDomainOrder(i)) {
-          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
-          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
-          idx += 2; ++idxDomain;
+      }
-      else if (1 == axisDomainOrder(i)) {
-//        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
-        eachDimSize[indexMap[i]] = axisP[idxAxis]->n;
-        ++idx; ++idxAxis;
+      }
-      else {};
+    }
-    if (!gridMask.isEmpty() && !createMask)
+    {
-      for (int i = 0; i < dim; ++i)
+      {
-        if (gridMask.extent(i) != eachDimSize[i])
-          ERROR("CGrid::checkMask(void)",
-                << "The mask has one dimension whose size is different from the one of the local grid." << std::endl
-                << "Local size of dimension " << i << " is " << eachDimSize[i] << "." << std::endl
-                << "Mask size for dimension " << i << " is " << gridMask.extent(i) << "." << std::endl
-                << "Grid = " << this->getId())
+      }
+    }
-    else {
-        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
-        gridMask = true;
+    }
-    int ssize = gridMask.numElements();
-    idx = 0;
-    while (idx < ssize)
+    {
-      for (int i = 0; i < dim-1; ++i)
+      {
-        if (idxLoop[i] == eachDimSize[i])
+        {
-          idxLoop[i] = 0;
-          ++idxLoop[i+1];
+        }
+      }
-      // Find out outer index
-      idxDomain = idxAxis = 0;
-      bool maskValue = true;
-      for (int i = 0; i < numElement; ++i)
+      {
-        if (2 == axisDomainOrder(i))
+        {
-          int idxTmp = idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]];
-          if (idxTmp < (*domainMasks[idxDomain]).numElements())
-            maskValue = maskValue && (*domainMasks[idxDomain])(idxTmp);
-          else
-            maskValue = false;
-          ++idxDomain;
+        }
-        else if (1 == axisDomainOrder(i))
+        {
-          int idxTmp = idxLoop[indexMap[i]];
-          if (idxTmp < (*axisMasks[idxAxis]).numElements())
-            maskValue = maskValue && (*axisMasks[idxAxis])(idxTmp);
-          else
-            maskValue = false;
-          ++idxAxis;
+        }
+      }
-      int maskIndex = idxLoop[0];
-      int mulDim = 1;
-      for (int k = 1; k < dim; ++k)
+      {
-        mulDim *= eachDimSize[k-1];
-        maskIndex += idxLoop[k]*mulDim;
+      }
-      *(gridMask.dataFirst()+maskIndex) &= maskValue;
-      ++idxLoop[0];
-      ++idx;
+    }
+   }
-   CATCH_DUMP_ATTR
-   template<int N>
-   void CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
-                                  const std::vector<int>& eachDimSize,
-                                  bool newValue)
-   TRY
+   {
-      if (N != eachDimSize.size())
+      {
-        // ERROR("CGrid::modifyGridMaskSize(CArray<bool,N>& gridMask,
-        //                                  const std::vector<int>& eachDimSize,
-        //                                  bool newValue)",
-        //       << "Dimension size of the mask is different from input dimension size." << std::endl
-        //       << "Mask dimension is " << N << "." << std::endl
-        //       << "Input dimension is " << eachDimSize.size() << "." << std::endl
-        //       << "Grid = " << this->getId())
+      }
-      CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
-      gridMask = newValue;
+   }
-   CATCH_DUMP_ATTR
-   /*!
-     Modify the current mask of grid, the local index to be modified will take value false
-     \param [in/out] gridMask current mask of grid
-     \param [in] indexToModify local index to modify
-   */
-   template<int N>
-   void CGrid::modifyGridMask(CArray<bool,N>& gridMask, const CArray<int,1>& indexToModify, bool valueToModify)
-   TRY
+   {
-     int num = indexToModify.numElements();
-     for (int idx = 0; idx < num; ++idx)
+     {
-       *(gridMask.dataFirst()+indexToModify(idx)) = valueToModify;
+     }
+   }
-   CATCH_DUMP_ATTR
-   ///--------------------------------------------------------------
    // Declare/Define CGridGroup and CGridDefinition

XIOS/dev/dev_trunk_graph/src/node/interpolate_axis.cpp

-                      r937
+                      r2019
 #include "interpolate_axis.hpp"
+#include "axis_algorithm_interpolate_coordinate.hpp"
+#include "axis_algorithm_interpolate.hpp"
 #include "type.hpp"
 #include "field.hpp"
 …
   bool CInterpolateAxis::registerTrans()
+  {
     return registerTransformation(TRANS_INTERPOLATE_AXIS, CInterpolateAxis::create);
+    return registerTransformation(TRANS_INTERPOLATE_AXIS, {create, getTransformation});
+  }
 …
     return auxInputs;
+  }
+  CGenericAlgorithmTransformation* CInterpolateAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    if (!coordinate.isEmpty())  return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                                      elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                                      elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+    else return CAxisAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/interpolate_axis.hpp

-                      r836
+                      r2019
   class CInterpolateAxis;
   class CAxis;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CInterpolateAxis> SuperClass;
       typedef CInterpolateAxisAttributes SuperClassAttribute;
+      typedef CInterpolateAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_INTERPOLATE_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/interpolate_domain.cpp

-                      r1653
+                      r2019
 #include "interpolate_domain.hpp"
+#include "domain_algorithm_interpolate.hpp"
 #include "type.hpp"
 …
   bool CInterpolateDomain::registerTrans()
+  {
     registerTransformation(TRANS_INTERPOLATE_DOMAIN, create);
+    registerTransformation(TRANS_INTERPOLATE_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CInterpolateDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/interpolate_domain.hpp

-                      r1021
+                      r2019
   class CInterpolateDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CInterpolateDomain> SuperClass;
       typedef CInterpolateDomainAttributes SuperClassAttribute;
+      typedef CInterpolateDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_INTERPOLATE_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/inverse_axis.cpp

-                      r836
+                      r2019
 #include "inverse_axis.hpp"
+#include "axis_algorithm_inverse.hpp"
 #include "type.hpp"
 …
   bool CInverseAxis::registerTrans()
+  {
     return registerTransformation(TRANS_INVERSE_AXIS, CInverseAxis::create);
+    return registerTransformation(TRANS_INVERSE_AXIS, {create, getTransformation});
+  }
 …
   {}
+  CGenericAlgorithmTransformation* CInverseAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmInverse::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/inverse_axis.hpp

-                      r836
+                      r2019
   class CInverseAxis;
   class CAxis;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CInverseAxis> SuperClass;
       typedef CInverseAxisAttributes SuperClassAttribute;
+      typedef CInverseAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_INVERSE_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/mesh.cpp

r1542	r2019
539	539	}
540	540	}
541		nodeHashList.resizeAndPreserve(nbHash);
	541	if (nbHash==0) nodeHashList.resize(nbHash);
	542	else nodeHashList.resizeAndPreserve(nbHash);
542	543
543	544	// (2.2) Generating global node indexes
…	…
986	987	}
987	988	}
988		edgeHashList.resizeAndPreserve(nEdgeHash);
	989	if (nEdgeHash==0) edgeHashList.resize(nEdgeHash);
	990	else edgeHashList.resizeAndPreserve(nEdgeHash);
989	991
990	992	// (2.3) Generating global edge indexes
…	…
1327	1329	}
1328	1330	}
1329		nodeIdxList.resizeAndPreserve(nIdx);
	1331	if (nIdx==0) nodeIdxList.resize(nIdx);
	1332	else nodeIdxList.resizeAndPreserve(nIdx);
1330	1333	CClientClientDHTSizet dhtNodeIdx(nodeIdx2Idx, comm);
1331	1334	dhtNodeIdx.computeIndexInfoMapping(nodeIdxList);
…	…
1377	1380	}
1378	1381	}
1379		edgeHashList.resizeAndPreserve(nEdgeHash);
	1382	if (nEdgeHash==0) edgeHashList.resize(nEdgeHash);
	1383	else edgeHashList.resizeAndPreserve(nEdgeHash);
1380	1384
1381	1385	// (3.4) Generating global edge indexes
…	…
1754	1758	}
1755	1759	}
1756		nghbFaces.resizeAndPreserve(2, nbNghb);
	1760	if (nbNghb==0) nghbFaces.resize(2, nbNghb);
	1761	else nghbFaces.resizeAndPreserve(2, nbNghb);
1757	1762	} // getGloNghbFacesNodeType
1758	1763
…	…
1806	1811	}
1807	1812	}
1808		nodeHashList.resizeAndPreserve(iIdx);
	1813	if (iIdx==0) nodeHashList.resize(iIdx);
	1814	else nodeHashList.resizeAndPreserve(iIdx);
1809	1815
1810	1816	// (1.2) Generating node indexes
…	…
1934	1940	}
1935	1941	}
1936		nghbFaces.resizeAndPreserve(2, nbNghb);
	1942	if (nbNghb==0) nghbFaces.resize(2, nbNghb);
	1943	else nghbFaces.resizeAndPreserve(2, nbNghb);
1937	1944	} // getGloNghbFacesEdgeType
1938	1945

XIOS/dev/dev_trunk_graph/src/node/node_enum.hpp

r1558	r2019
15	15	eField,gField,
16	16	eFile,gFile,
	17	eCouplerIn,gCouplerIn,
	18	eCouplerOut,gCouplerOut,
17	19	eGrid,gGrid,
18	20	eVariable,gVariable,

XIOS/dev/dev_trunk_graph/src/node/node_type.hpp

r1558	r2019
6	6	#include "field.hpp"
7	7	#include "file.hpp"
	8	#include "coupler_in.hpp"
	9	#include "coupler_out.hpp"
8	10	#include "grid.hpp"
9	11	#include "variable.hpp"

XIOS/dev/dev_trunk_graph/src/node/reduce_axis_to_axis.cpp

-                      r1314
+                      r2019
 #include "reduce_axis_to_axis.hpp"
+#include "axis_algorithm_reduce_axis.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CReduceAxisToAxis::registerTrans()
+  {
     return registerTransformation(TRANS_REDUCE_AXIS_TO_AXIS, CReduceAxisToAxis::create);
+    return registerTransformation(TRANS_REDUCE_AXIS_TO_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReduceAxisToAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmReduceAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reduce_axis_to_axis.hpp

-                      r1301
+                      r2019
   class CReduceAxisToAxis;
   class CAxis;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReduceAxisToAxis> SuperClass;
       typedef CReduceAxisToAxisAttributes SuperClassAttribute;
+      typedef CReduceAxisToAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+    private:
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REDUCE_AXIS_TO_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
+   private:
       static bool registerTrans();
       static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node);

XIOS/dev/dev_trunk_graph/src/node/reduce_axis_to_scalar.cpp

-                      r980
+                      r2019
 #include "reduce_axis_to_scalar.hpp"
+#include "scalar_algorithm_reduce_axis.hpp"
 #include "type.hpp"
 …
   bool CReduceAxisToScalar::registerTrans()
+  {
     return registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, CReduceAxisToScalar::create);
+    return registerTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReduceAxisToScalar::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CScalarAlgorithmReduceAxis::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reduce_axis_to_scalar.hpp

-                      r888
+                      r2019
   class CReduceAxisToScalar;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReduceAxisToScalar> SuperClass;
       typedef CReduceAxisToScalarAttributes SuperClassAttribute;
+      typedef CReduceAxisToScalar MyClass ;
+      typedef CTransformation<CScalar> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REDUCE_AXIS_TO_SCALAR ;}
+      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/reduce_domain_to_axis.cpp

-                      r1299
+                      r2019
 #include "reduce_domain_to_axis.hpp"
+#include "axis_algorithm_reduce_domain.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CReduceDomainToAxis::registerTrans()
+  {
     return registerTransformation(TRANS_REDUCE_DOMAIN_TO_AXIS, CReduceDomainToAxis::create);
+    return registerTransformation(TRANS_REDUCE_DOMAIN_TO_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReduceDomainToAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmReduceDomain::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reduce_domain_to_axis.hpp

-                      r895
+                      r2019
   class CAxis;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReduceDomainToAxis> SuperClass;
       typedef CReduceDomainToAxisAttributes SuperClassAttribute;
+      typedef CReduceDomainToAxis MyClass ;
+     typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+    private:
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REDUCE_DOMAIN_TO_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
+     private:
       static bool registerTrans();
       static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node);

XIOS/dev/dev_trunk_graph/src/node/reduce_domain_to_scalar.cpp

-                      r1313
+                      r2019
 #include "reduce_domain_to_scalar.hpp"
+#include "scalar_algorithm_reduce_domain.hpp"
 #include "type.hpp"
 …
   bool CReduceDomainToScalar::registerTrans()
+  {
     return registerTransformation(TRANS_REDUCE_DOMAIN_TO_SCALAR, CReduceDomainToScalar::create);
+    return registerTransformation(TRANS_REDUCE_DOMAIN_TO_SCALAR, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReduceDomainToScalar::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CScalarAlgorithmReduceDomain::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition) ;
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reduce_domain_to_scalar.hpp

-                      r976
+                      r2019
   class CDomain;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReduceDomainToScalar> SuperClass;
       typedef CReduceDomainToScalarAttributes SuperClassAttribute;
+      typedef CReduceDomainToScalar MyClass ;
+      typedef CTransformation<CScalar> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REDUCE_DOMAIN_TO_SCALAR ;}
+      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/reduce_scalar_to_scalar.cpp

-                      r1314
+                      r2019
 #include "reduce_scalar_to_scalar.hpp"
+#include "scalar_algorithm_reduce_scalar.hpp"
 #include "type.hpp"
 …
   bool CReduceScalarToScalar::registerTrans()
+  {
     return registerTransformation(TRANS_REDUCE_SCALAR_TO_SCALAR, CReduceScalarToScalar::create);
+    return registerTransformation(TRANS_REDUCE_SCALAR_TO_SCALAR, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReduceScalarToScalar::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CScalarAlgorithmReduceScalar::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reduce_scalar_to_scalar.hpp

-                      r1314
+                      r2019
   class CReduceScalarToScalar;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReduceScalarToScalar> SuperClass;
       typedef CReduceScalarToScalarAttributes SuperClassAttribute;
+      typedef CReduceScalarToScalar MyClass ;
+      typedef CTransformation<CScalar> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REDUCE_SCALAR_TO_SCALAR ;}
+      static CTransformation<CScalar>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/reorder_domain.cpp

-                      r1457
+                      r2019
 #include "reorder_domain.hpp"
+#include "domain_algorithm_reorder.hpp"
 #include "type.hpp"
 …
   bool CReorderDomain::registerTrans()
+  {
     registerTransformation(TRANS_REORDER_DOMAIN, CReorderDomain::create);
+    registerTransformation(TRANS_REORDER_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CReorderDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmReorder::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/reorder_domain.hpp

-                      r1457
+                      r2019
   class CReorderDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CReorderDomain> SuperClass;
       typedef CReorderDomainAttributes SuperClassAttribute;
+      typedef CReorderDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+    private:
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_REORDER_DOMAIN ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
+     private:
       static bool registerTrans();
       static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);

XIOS/dev/dev_trunk_graph/src/node/scalar.cpp

-                      r1314
+                      r2019
 #include "xios_spl.hpp"
 #include "type.hpp"
+namespace xios {
+   /// ////////////////////// DÃ©finitions ////////////////////// ///
+   CScalar::CScalar(void)
+      : CObjectTemplate<CScalar>()
+      , CScalarAttributes()
+      , relFiles()
+   { /* Ne rien faire de plus */ }
+   CScalar::CScalar(const StdString & id)
+      : CObjectTemplate<CScalar>(id)
+      , CScalarAttributes()
+      , relFiles()
+   { /* Ne rien faire de plus */ }
+   CScalar::~CScalar(void)
+   { /* Ne rien faire de plus */ }
+   std::map<StdString, ETranformationType> CScalar::transformationMapList_ = std::map<StdString, ETranformationType>();
+   bool CScalar::dummyTransformationMapList_ = CScalar::initializeTransformationMap(CScalar::transformationMapList_);
+   bool CScalar::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+   {
+     m["reduce_axis"]   = TRANS_REDUCE_AXIS_TO_SCALAR;
+     m["extract_axis"]  = TRANS_EXTRACT_AXIS_TO_SCALAR;
+     m["reduce_domain"] = TRANS_REDUCE_DOMAIN_TO_SCALAR;
+     m["reduce_scalar"] = TRANS_REDUCE_SCALAR_TO_SCALAR;
+   }
+   StdString CScalar::GetName(void)   { return (StdString("scalar")); }
+   StdString CScalar::GetDefName(void){ return (CScalar::GetName()); }
+   ENodeType CScalar::GetType(void)   { return (eScalar); }
+   CScalar* CScalar::createScalar()
+   {
+     CScalar* scalar = CScalarGroup::get("scalar_definition")->createChild();
+     return scalar;
+   }
+   bool CScalar::IsWritten(const StdString & filename) const
+   {
+      return (this->relFiles.find(filename) != this->relFiles.end());
+   }
+   void CScalar::addRelFile(const StdString& filename)
+   {
+#include "context.hpp"
+namespace xios
+{
+  /// ////////////////////// DÃ©finitions ////////////////////// ///
+  CScalar::CScalar(void)
+     : CObjectTemplate<CScalar>()
+     , CScalarAttributes()
+     , relFiles()
+  { /* Ne rien faire de plus */ }
+  CScalar::CScalar(const StdString & id)
+     : CObjectTemplate<CScalar>(id)
+     , CScalarAttributes()
+     , relFiles()
+  { /* Ne rien faire de plus */ }
+  CScalar::~CScalar(void)
+  { /* Ne rien faire de plus */ }
+  std::map<StdString, ETranformationType> CScalar::transformationMapList_ = std::map<StdString, ETranformationType>();
+  bool CScalar::dummyTransformationMapList_ = CScalar::initializeTransformationMap(CScalar::transformationMapList_);
+  bool CScalar::initializeTransformationMap(std::map<StdString, ETranformationType>& m)
+  {
+    m["reduce_axis"]   = TRANS_REDUCE_AXIS_TO_SCALAR;
+    m["extract_axis"]  = TRANS_EXTRACT_AXIS_TO_SCALAR;
+    m["reduce_domain"] = TRANS_REDUCE_DOMAIN_TO_SCALAR;
+    m["reduce_scalar"] = TRANS_REDUCE_SCALAR_TO_SCALAR;
+  }
+  StdString CScalar::GetName(void)   { return (StdString("scalar")); }
+  StdString CScalar::GetDefName(void){ return (CScalar::GetName()); }
+  ENodeType CScalar::GetType(void)   { return (eScalar); }
+  CScalar* CScalar::createScalar()
+  {
+    CScalar* scalar = CScalarGroup::get("scalar_definition")->createChild();
+    return scalar;
+  }
+  bool CScalar::IsWritten(const StdString & filename) const
+  {
+    return (this->relFiles.find(filename) != this->relFiles.end());
+  }
+  void CScalar::addRelFile(const StdString& filename)
+  {
       this->relFiles.insert(filename);
+   }
+   void CScalar::checkAttributes(void)
+   {
+   }
+  void CScalar::checkAttributesOnClient()
+  {
+  }
+  void CScalar::checkAttributes(void)
+  {
+    if (checkAttributes_done_) return ;
+    checkAttributes_done_ = true ;
+    if (mask.isEmpty()) mask=true ;
+    initializeLocalElement() ;
+    addFullView() ;
+    addWorkflowView() ;
+    addModelView() ;
+  }
 …
    * Go through the hierarchy to find the scalar from which the transformations must be inherited
    */
   void CScalar::solveInheritanceTransformation()
+  void CScalar::solveInheritanceTransformation_old()
+  {
     if (hasTransformation() || !hasDirectScalarReference())
 …
         refScalar[i]->setTransformations(scalar->getAllTransformations());
+  }
+  void CScalar::solveInheritanceTransformation()
+  TRY
+  {
+    if (solveInheritanceTransformation_done_) return;
+    else solveInheritanceTransformation_done_=true ;
+    CScalar* scalar = this;
+    CScalar* Lastscalar ;
+    std::list<CScalar*> refScalars;
+    bool out=false ;
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("scalar_ref");
+    refScalars.push_front(scalar) ;
+    while (scalar->hasDirectScalarReference() && !out)
+    {
+      CScalar* lastScalar=scalar ;
+      scalar = scalar->getDirectScalarReference();
+      scalar->solveRefInheritance() ;
+      if (!scalar->SuperClass::isEqual(lastScalar,excludedAttr)) out=true ;
+      refScalars.push_front(scalar) ;
+    }
+    CTransformationPaths::TPath path ;
+    auto& pathList = std::get<2>(path) ;
+    std::get<0>(path) = EElement::SCALAR ;
+    std::get<1>(path) = refScalars.front()->getId() ;
+    for (auto& scalar : refScalars)
+    {
+      CScalar::TransMapTypes transformations = scalar->getAllTransformations();
+      for(auto& transformation : transformations) pathList.push_back({transformation.second->getTransformationType(),
+                                                                      transformation.second->getId()}) ;
+    }
+    transformationPaths_.addPath(path) ;
+  }
+  CATCH_DUMP_ATTR
+  /* obsolete, to remove after reimplementing coupling */
+  void CScalar::sendScalarToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid)
+  {
+    if (sendScalarToCouplerOut_done_.count(client)!=0) return ;
+    else sendScalarToCouplerOut_done_.insert(client) ;
+    string scalarId="_scalar["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    this->sendAllAttributesToServer(client, scalarId);
+  }
+  void CScalar::makeAliasForCoupling(const string& fieldId, int posInGrid)
+  {
+    const string scalarId = "_scalar["+std::to_string(posInGrid)+"]_of_"+fieldId ;
+    this->createAlias(scalarId) ;
+  }
+  void CScalar::setContextClient(CContextClient* contextClient)
+  TRY
+  {
+    if (clientsSet.find(contextClient)==clientsSet.end())
+    {
+      clients.push_back(contextClient) ;
+      clientsSet.insert(contextClient);
+    }
+  }
+  CATCH_DUMP_ATTR
   /*!
     Parse children nodes of a scalar in xml file.
 …
+  }
+   //////////////////////////////////////////////////////////////////////////////////////
+   //  this part is related to distribution, element definition, views and connectors  //
+   //////////////////////////////////////////////////////////////////////////////////////
+   void CScalar::initializeLocalElement(void)
+   {
+      // after checkAttribute index of size n
+      int rank = CContext::getCurrent()->getIntraCommRank() ;
+      CArray<size_t,1> ind(1) ;
+      ind(0)=0 ;
+      localElement_ = new CLocalElement(rank, 1, ind) ;
+   }
+   void CScalar::addFullView(void)
+   {
+      CArray<int,1> index(1) ;
+      for(int i=0; i<1 ; i++) index(0)=0 ;
+      localElement_ -> addView(CElementView::FULL, index) ;
+   }
+   void CScalar::addWorkflowView(void)
+   {
+      CArray<int,1> index ;
+      if (mask)
+      {
+        index.resize(1) ;
+        index(0)=0 ;
+      }
+      else index.resize(0) ;
+      localElement_ -> addView(CElementView::WORKFLOW, index) ;
+   }
+   void CScalar::addModelView(void)
+   {
+     CArray<int,1> index(1) ;
+     for(int i=0; i<1 ; i++) index(0)=0 ;
+     localElement_->addView(CElementView::MODEL, index) ;
+   }
+   void CScalar::computeModelToWorkflowConnector(void)
+   {
+     CLocalView* srcView=getLocalView(CElementView::MODEL) ;
+     CLocalView* dstView=getLocalView(CElementView::WORKFLOW) ;
+     modelToWorkflowConnector_ = new CLocalConnector(srcView, dstView);
+     modelToWorkflowConnector_->computeConnector() ;
+   }
+  void CScalar::computeRemoteElement(CContextClient* client, EDistributionType type)
+  {
+    CContext* context = CContext::getCurrent();
+    map<int, CArray<size_t,1>> globalIndex ;
+    int nbServer = client->serverSize;
+    size_t nglo=1 ;
+    CArray<size_t,1> indGlo(nglo) ;
+    for(size_t i=0;i<nglo;i++) indGlo(i) = i ;
+    for (auto& rankServer : client->getRanksServerLeader()) globalIndex[rankServer].reference(indGlo.copy()) ;
+    remoteElement_[client] = new CDistributedElement(nglo, globalIndex) ;
+    remoteElement_[client]->addFullView() ;
+  }
+  void CScalar::distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex,
+                                   CScattererConnector* &scattererConnector, const string& scalarId)
+  {
+    string serverScalarId = scalarId.empty() ? this->getId() : scalarId ;
+    CContext* context = CContext::getCurrent();
+    this->sendAllAttributesToServer(client, serverScalarId)  ;
+    CDistributedElement scatteredElement(1,globalIndex) ;
+    scatteredElement.addFullView() ;
+    scattererConnector = new CScattererConnector(localElement_->getView(CElementView::FULL), scatteredElement.getView(CElementView::FULL),
+                                                 context->getIntraComm(), client->getRemoteSize()) ;
+    scattererConnector->computeConnector() ;
+    // phase 0
+    // send remote element to construct the full view on server, ie without hole
+    CEventClient event0(getType(), EVENT_ID_SCALAR_DISTRIBUTION);
+    CMessage message0 ;
+    message0<<serverScalarId<<0 ;
+    remoteElement_[client]->sendToServer(client,event0,message0) ;
+    // phase 1
+    // send the full view of element to construct the connector which connect distributed data coming from client to the full local view
+    CEventClient event1(getType(), EVENT_ID_SCALAR_DISTRIBUTION);
+    CMessage message1 ;
+    message1<<serverScalarId<<1<<localElement_->getView(CElementView::FULL)->getGlobalSize() ;
+    scattererConnector->transfer(localElement_->getView(CElementView::FULL)->getGlobalIndex(),client,event1,message1) ;
+    sendDistributedAttributes(client, *scattererConnector, scalarId) ;
+    // phase 2 send the mask : data index + mask2D
+    CArray<bool,1> maskIn(localElement_->getView(CElementView::WORKFLOW)->getSize());
+    CArray<bool,1> maskOut ;
+    CLocalConnector workflowToFull(localElement_->getView(CElementView::WORKFLOW), localElement_->getView(CElementView::FULL)) ;
+    workflowToFull.computeConnector() ;
+    maskIn=true ;
+    workflowToFull.transfer(maskIn,maskOut,false) ;
+    // phase 3 : prepare grid scatterer connector to send data from client to server
+    map<int,CArray<size_t,1>> workflowGlobalIndex ;
+    map<int,CArray<bool,1>> maskOut2 ;
+    scattererConnector->transfer(maskOut, maskOut2) ;
+    scatteredElement.addView(CElementView::WORKFLOW, maskOut2) ;
+    scatteredElement.getView(CElementView::WORKFLOW)->getGlobalIndexView(workflowGlobalIndex) ;
+    // create new workflow view for scattered element
+    CDistributedElement clientToServerElement(scatteredElement.getGlobalSize(), workflowGlobalIndex) ;
+    clientToServerElement.addFullView() ;
+    CEventClient event2(getType(), EVENT_ID_SCALAR_DISTRIBUTION);
+    CMessage message2 ;
+    message2<<serverScalarId<<2 ;
+    clientToServerElement.sendToServer(client, event2, message2) ;
+    clientToServerConnector_[client] = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), clientToServerElement.getView(CElementView::FULL),
+                                                               context->getIntraComm(), client->getRemoteSize()) ;
+    clientToServerConnector_[client]->computeConnector() ;
+    clientFromServerConnector_[client] = new CGathererConnector(clientToServerElement.getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW));
+    clientFromServerConnector_[client]->computeConnector() ;
+  }
+  void CScalar::recvScalarDistribution(CEventServer& event)
+  TRY
+  {
+    string scalarId;
+    int phasis ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> scalarId >> phasis ;
+    get(scalarId)->receivedScalarDistribution(event, phasis);
+  }
+  CATCH
+  void CScalar::receivedScalarDistribution(CEventServer& event, int phasis)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    if (phasis==0) // receive the remote element to construct the full view
+    {
+      localElement_ = new  CLocalElement(context->getIntraCommRank(),event) ;
+      localElement_->addFullView() ;
+      // construct the local dimension and indexes
+      auto& globalIndex=localElement_->getGlobalIndex() ;
+      int nk=globalIndex.numElements() ;
+      // no distribution for scalar => nk ==1 or maybe 0 ?
+    }
+    else if (phasis==1) // receive the sent view from client to construct the full distributed full view on server
+    {
+      CContext* context = CContext::getCurrent();
+      CDistributedElement* elementFrom = new  CDistributedElement(event) ;
+      elementFrom->addFullView() ;
+      gathererConnector_ = new CGathererConnector(elementFrom->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+      gathererConnector_->computeConnector() ;
+    }
+    else if (phasis==2)
+    {
+//      delete gathererConnector_ ;
+      elementFrom_ = new  CDistributedElement(event) ;
+      elementFrom_->addFullView() ;
+//      gathererConnector_ =  new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::FULL)) ;
+//      gathererConnector_ -> computeConnector() ;
+    }
+  }
+  CATCH
+  void CScalar::setServerMask(CArray<bool,1>& serverMask, CContextClient* client)
+  TRY
+  {
+    CContext* context = CContext::getCurrent();
+    localElement_->addView(CElementView::WORKFLOW, serverMask) ;
+    mask = serverMask(0) ;
+    serverFromClientConnector_ = new CGathererConnector(elementFrom_->getView(CElementView::FULL), localElement_->getView(CElementView::WORKFLOW)) ;
+    serverFromClientConnector_->computeConnector() ;
+    serverToClientConnector_ = new CScattererConnector(localElement_->getView(CElementView::WORKFLOW), elementFrom_->getView(CElementView::FULL),
+                                                         context->getIntraComm(), client->getRemoteSize()) ;
+    serverToClientConnector_->computeConnector() ;
+  }
+  CATCH_DUMP_ATTR
+  void CScalar::sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId)
+  {
+    string serverScalarId = scalarId.empty() ? this->getId() : scalarId ;
+    CContext* context = CContext::getCurrent();
+    // nothing for now
+  }
+  void CScalar::recvDistributedAttributes(CEventServer& event)
+  TRY
+  {
+    string scalarId;
+    string type ;
+    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> scalarId >> type ;
+    get(scalarId)->recvDistributedAttributes(event, type);
+  }
+  CATCH
+  void CScalar::recvDistributedAttributes(CEventServer& event, const string& type)
+  TRY
+  {
+    // nothing for now
+  }
+  CATCH
+  bool CScalar::dispatchEvent(CEventServer& event)
+  TRY
+  {
+     if (SuperClass::dispatchEvent(event)) return true;
+     else
+     {
+       switch(event.type)
+       {
+          case EVENT_ID_SCALAR_DISTRIBUTION:
+            recvScalarDistribution(event);
+            return true;
+            break;
+          case EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE:
+            recvDistributedAttributes(event);
+            return true;
+            break;
+          default :
+            ERROR("bool CScalar::dispatchEvent(CEventServer& event)",
+                   << "Unknown Event");
+          return false;
+        }
+     }
+  }
+  CATCH
   // Definition of some macros
   DEFINE_REF_FUNC(Scalar,scalar)

XIOS/dev/dev_trunk_graph/src/node/scalar.hpp

-                      r1436
+                      r2019
 #include "transformation.hpp"
 #include "transformation_enum.hpp"
+#include "transformation_path.hpp"
+#include "element.hpp"
+#include "local_connector.hpp"
+#include "scatterer_connector.hpp"
+#include "gatherer_connector.hpp"
+#include "distribution_type.hpp"
+#include "generic_algorithm_transformation.hpp"
 namespace xios
+{
       /// ////////////////////// DÃ©clarations ////////////////////// ///
       class CScalarGroup;
       class CScalarAttributes;
       class CScalar;
       ///--------------------------------------------------------------
       // Declare/Define CVarAttribute
       BEGIN_DECLARE_ATTRIBUTE_MAP(CScalar)
+  /// ////////////////////// DÃ©clarations ////////////////////// ///
+  class CScalarGroup;
+  class CScalarAttributes;
+  class CScalar;
+  ///--------------------------------------------------------------
+  // Declare/Define CVarAttribute
+  BEGIN_DECLARE_ATTRIBUTE_MAP(CScalar)
 #include "scalar_attribute.conf"
+      END_DECLARE_ATTRIBUTE_MAP(CScalar)
+      ///--------------------------------------------------------------
+      class CScalar
+         : public CObjectTemplate<CScalar>
+         , public CScalarAttributes
+  END_DECLARE_ATTRIBUTE_MAP(CScalar)
+  ///--------------------------------------------------------------
+  class CScalar: public CObjectTemplate<CScalar>
+               , public CScalarAttributes
+  {
+      friend class CScalarGroup;
+      /// typedef ///
+      typedef CObjectTemplate<CScalar>   SuperClass;
+      typedef CScalarAttributes SuperClassAttribute;
+    public:
+      enum EEventId
+      {
+            /// typedef ///
+            typedef CObjectTemplate<CScalar>   SuperClass;
+            typedef CScalarAttributes SuperClassAttribute;
+            friend class CScalarGroup;
+         public :
+            typedef CScalarAttributes RelAttributes;
+            typedef CScalarGroup      RelGroup;
+            typedef CTransformation<CScalar>::TransformationMapTypes TransMapTypes;
+            /// Constructeurs ///
+            CScalar(void);
+            explicit CScalar(const StdString & id);
+            CScalar(const CScalar & var);       // Not implemented yet.
+            CScalar(const CScalar * const var); // Not implemented yet.
+            /// Destructeur ///
+            virtual ~CScalar(void);
+         public :
+            /// Accesseurs statiques ///
+            static StdString GetName(void);
+            static StdString GetDefName(void);
+            static ENodeType GetType(void);
+         public:
+            static CScalar* createScalar();
+         public:
+            void checkAttributes(void);
+            void addRelFile(const StdString& filename);
+            bool IsWritten(const StdString& filename) const;
+            void checkAttributesOnClient();
+            virtual void parse(xml::CXMLNode & node);
+         public:
+           bool hasTransformation();
+           void solveInheritanceTransformation();
+           TransMapTypes getAllTransformations();
+           void duplicateTransformation(CScalar*);
+           CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id="");
+           bool isEqual(CScalar* scalar);
+         private:
+           std::set<StdString> relFiles;
+           TransMapTypes transformationMap_;
+            void setTransformations(const TransMapTypes&);
+       private:
+           static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+           static std::map<StdString, ETranformationType> transformationMapList_;
+           static bool dummyTransformationMapList_;
+            DECLARE_REF_FUNC(Scalar,scalar)
+      }; // class CVar
+      ///--------------------------------------------------------------
+      // Declare/Define CScalarGroup and CScalarDefinition
+      DECLARE_GROUP(CScalar);
+        EVENT_ID_SCALAR_DISTRIBUTION,
+        EVENT_ID_SEND_DISTRIBUTED_ATTRIBUTE,
+      } ;
+      static bool dispatchEvent(CEventServer& event);
+    public :
+      typedef CScalarAttributes RelAttributes;
+      typedef CScalarGroup      RelGroup;
+      /// Constructeurs ///
+      CScalar(void);
+      explicit CScalar(const StdString & id);
+      CScalar(const CScalar & var);       // Not implemented yet.
+      CScalar(const CScalar * const var); // Not implemented yet.
+      /// Destructeur ///
+      virtual ~CScalar(void);
+    public :
+      /// Accesseurs statiques ///
+      static StdString GetName(void);
+      static StdString GetDefName(void);
+      static ENodeType GetType(void);
+    public:
+      static CScalar* createScalar();
+    public:
+      void checkAttributes(void);
+      bool checkAttributes_done_ = false ;
+      void addRelFile(const StdString& filename);
+      bool IsWritten(const StdString& filename) const;
+      virtual void parse(xml::CXMLNode & node);
+    public:
+      void sendScalarToCouplerOut(CContextClient* client, const string& fieldId, int posInGrid) ;
+    private:
+      std::set<CContextClient*> sendScalarToCouplerOut_done_ ;
+    public:
+      void makeAliasForCoupling(const string& fieldId, int posInGrid) ;
+      ////////////////////////////////
+      ////    TRANSFORMATIONS     ////
+      ////////////////////////////////
+    public:
+      typedef CTransformation<CScalar>::TransformationMapTypes TransMapTypes;
+    private:
+      static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
+      static std::map<StdString, ETranformationType> transformationMapList_;
+      static bool dummyTransformationMapList_;      TransMapTypes transformationMap_;
+      void setTransformations(const TransMapTypes&);
+    public:
+      bool hasTransformation();
+      TransMapTypes getAllTransformations();
+      void duplicateTransformation(CScalar*);
+      CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id="");
+       void solveInheritanceTransformation_old();
+       void solveInheritanceTransformation();
+      private:
+        bool solveInheritanceTransformation_done_= false ;
+      private:
+        CGenericAlgorithmTransformation* transformationAlgorithm_ = nullptr ;
+      public:
+        void setTransformationAlgorithm(CGenericAlgorithmTransformation* transformationAlgorithm) { transformationAlgorithm_=transformationAlgorithm ;}
+        CGenericAlgorithmTransformation* getTransformationAlgorithm(void) { return transformationAlgorithm_ ;}
+      private:
+        CTransformationPaths transformationPaths_ ;
+      public:
+        CTransformationPaths getTransformationPaths(void) {return transformationPaths_;}
+        void setTransformationPaths(const CTransformationPaths& transformationPaths) { transformationPaths_=transformationPaths ;}
+      ////////////////////////////////
+      ////////////////////////////////
+      bool isEqual(CScalar* scalar);
+    private:
+          /** Clients that have to send a scalar. There can be multiple clients in case of secondary server, otherwise only one client. */
+      std::list<CContextClient*> clients;
+      std::set<CContextClient*> clientsSet;
+    public:
+      void setContextClient(CContextClient* contextClient) ;
+    private:
+      std::set<StdString> relFiles;
+    private:
+      /** define if the scalar is completed or not ie all attributes have been received before in case
+           of grid reading from file or coupling */
+      bool isCompleted_=true ;
+    public:
+      /*!
+        \brief Check if a scalar is completed
+        Before make any scalar processing, we must be sure that all scalar informations have
+        been sent, for exemple when reading a grid in a file or when grid elements are sent by an
+        other context (coupling). So all direct reference of the scalar (scalar_ref) must be also completed
+        \return true if scalar and scalar reference are completed
+      */
+      bool isCompleted(void)
+      {
+        if (hasDirectScalarReference()) if (!getDirectScalarReference()->isCompleted()) return false;
+        else return isCompleted_ ;
+      }
+      void setCompleted(void) { isCompleted_=true ; }
+      void unsetCompleted(void) { isCompleted_=false ; }
+    //////////////////////////////////////////////////////////////////////////////////////
+    //  this part is related to distribution, element definition, views and connectors  //
+    //////////////////////////////////////////////////////////////////////////////////////
+    private:
+      CLocalElement* localElement_ = nullptr ;
+      void initializeLocalElement(void) ;
+    public:
+      CLocalElement* getLocalElement(void) { if (localElement_==nullptr) initializeLocalElement() ; return localElement_ ; }
+      CLocalView* getLocalView(CElementView::type type) { return getLocalElement()->getView(type) ;}
+    private:
+      void addFullView(void) ;
+      void addWorkflowView(void) ;
+      void addModelView(void) ;
+    private:
+      CLocalConnector* modelToWorkflowConnector_ ;
+      void computeModelToWorkflowConnector(void)  ;
+    public:
+      CLocalConnector* getModelToWorkflowConnector(void) { if (modelToWorkflowConnector_==nullptr) computeModelToWorkflowConnector() ; return modelToWorkflowConnector_ ;}
+    public:
+      void computeRemoteElement(CContextClient* client, EDistributionType) ;
+      void distributeToServer(CContextClient* client, std::map<int, CArray<size_t,1>>& globalIndex, CScattererConnector* &scattererConnector,
+                                 const string& scalarId="") ;
+      static void recvScalarDistribution(CEventServer& event) ;
+      void receivedScalarDistribution(CEventServer& event, int phasis) ;
+      void setServerMask(CArray<bool,1>& serverMask, CContextClient* client) ;
+      void sendDistributedAttributes(CContextClient* client, CScattererConnector& scattererConnector, const string& scalarId) ;
+      static void recvDistributedAttributes(CEventServer& event) ;
+      void recvDistributedAttributes(CEventServer& event, const string& type) ;
+    private:
+      map<CContextClient*, CDistributedElement*> remoteElement_ ;
+    public:
+      CDistributedElement* getRemoteElement(CContextClient* client) {return remoteElement_[client] ;}
+    private:
+      map<CContextClient*, CScattererConnector*> clientToServerConnector_ ;
+    public:
+      CScattererConnector* getClientToServerConnector(CContextClient* client) { return clientToServerConnector_[client] ;}
+    private:
+      CGathererConnector*  gathererConnector_ ;
+    public:
+      CGathererConnector* getGathererConnector(void) { return gathererConnector_ ;}
+    private:
+      CGathererConnector* serverFromClientConnector_ ;
+      CDistributedElement* elementFrom_ ;
+    public:
+      CGathererConnector* getServerFromClientConnector(void) { return serverFromClientConnector_ ;}
+    private:
+      CScattererConnector*  serverToClientConnector_ = nullptr ;
+    public:
+      CScattererConnector* getServerToClientConnector(void) { return serverToClientConnector_ ;}
+    private:
+      map<CContextClient*,CGathererConnector*>  clientFromServerConnector_  ;
+    public:
+      CGathererConnector* getClientFromServerConnector(CContextClient* client) { return clientFromServerConnector_[client] ;}
+    private:
+      DECLARE_REF_FUNC(Scalar,scalar)
+  }; // class CVar
+  ///--------------------------------------------------------------
+  // Declare/Define CScalarGroup and CScalarDefinition
+  DECLARE_GROUP(CScalar);
 } // namespace xios

XIOS/dev/dev_trunk_graph/src/node/temporal_splitting.cpp

-                      r1275
+                      r2019
 #include "temporal_splitting.hpp"
+#include "axis_algorithm_temporal_splitting.hpp"
 #include "type.hpp"
 #include "axis.hpp"
 …
   bool CTemporalSplitting::registerTrans()
+  {
     return registerTransformation(TRANS_TEMPORAL_SPLITTING, CTemporalSplitting::create);
+    return registerTransformation(TRANS_TEMPORAL_SPLITTING, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CTemporalSplitting::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmTemporalSplitting::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/temporal_splitting.hpp

-                      r1275
+                      r2019
   class CAxis;
   class CScalar;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CTemporalSplitting> SuperClass;
       typedef CTemporalSplittingAttributes SuperClassAttribute;
+      typedef CTemporalSplitting MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_TEMPORAL_SPLITTING ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/variable.cpp

-                      r1158
+                      r2019
+   *
    */
+   void CVariable::sendValue()
+   {
+     CContext* context=CContext::getCurrent() ;
+     if (context->hasClient)
+     {
+       // Use correct context client to send message
+       // int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1;
+      int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 0) : 1;
+       for (int i = 0; i < nbSrvPools; ++i)
+       {
+//       CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer
+         CContextClient* contextClientTmp = (context->hasServer) ? context->clientPrimServer[i]
+                                                                             : context->client;
+         CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ;
+         if (contextClientTmp->isServerLeader())
+         {
+           CMessage msg ;
+           msg<<this->getId() ;
+           msg<<content ;
+           const std::list<int>& ranks = contextClientTmp->getRanksServerLeader();
+           for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+             event.push(*itRank,1,msg);
+           contextClientTmp->sendEvent(event) ;
+         }
+         else contextClientTmp->sendEvent(event) ;
+      }
+     }
+   }
+   void CVariable::sendValue(CContextClient* client, bool clientPrim /*= false*/)
+   void CVariable::sendValue(CContextClient* client)
+   {
      CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ;

XIOS/dev/dev_trunk_graph/src/node/variable.hpp

-                      r1158
+                      r2019
             //! Sending a request to set up variable data
+            void sendValue();
+            void sendValue(CContextClient* client, bool clientPrim = false);
+            void sendValue(CContextClient* client);
             static void recvValue(CEventServer& event) ;

XIOS/dev/dev_trunk_graph/src/node/zoom_axis.cpp

-                      r1201
+                      r2019
 #include "zoom_axis.hpp"
+#include "axis_algorithm_zoom.hpp"
 #include "type.hpp"
 …
   bool CZoomAxis::registerTrans()
+  {
     return registerTransformation(TRANS_ZOOM_AXIS, CZoomAxis::create);
+    return registerTransformation(TRANS_ZOOM_AXIS, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CZoomAxis::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CAxisAlgorithmZoom::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/zoom_axis.hpp

-                      r836
+                      r2019
   class CZoomAxis;
   class CAxis;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CZoomAxis> SuperClass;
       typedef CZoomAxisAttributes SuperClassAttribute;
+      typedef CZoomAxis MyClass ;
+      typedef CTransformation<CAxis> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_ZOOM_AXIS ;}
+      static CTransformation<CAxis>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();

XIOS/dev/dev_trunk_graph/src/node/zoom_domain.cpp

-                      r836
+                      r2019
 #include "zoom_domain.hpp"
+#include "domain_algorithm_zoom.hpp"
 #include "type.hpp"
 …
   bool CZoomDomain::registerTrans()
+  {
     registerTransformation(TRANS_ZOOM_DOMAIN, CZoomDomain::create);
+    registerTransformation(TRANS_ZOOM_DOMAIN, {create, getTransformation});
+  }
 …
+  }
+  CGenericAlgorithmTransformation* CZoomDomain::createAlgorithm(bool isSource,
+                                                        CGrid* gridDst, CGrid* gridSrc,
+                                                        int elementPositionInGrid,
+                                                        std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition)
+  {
+    return CDomainAlgorithmZoom::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,
+                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition,
+                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition);
+  }
+}

XIOS/dev/dev_trunk_graph/src/node/zoom_domain.hpp

-                      r836
+                      r2019
   class CZoomDomain;
   class CDomain;
+  class CGenericAlgorithmTransformation ;
+  class CGrid;
   ///--------------------------------------------------------------
 …
       typedef CObjectTemplate<CZoomDomain> SuperClass;
       typedef CZoomDomainAttributes SuperClassAttribute;
+      typedef CZoomDomain MyClass ;
+      typedef CTransformation<CDomain> SuperTransform ;
     public :
 …
       static StdString GetDefName(void);
       static ENodeType GetType(void);
+      const string& getId(void) { return this->SuperClass::getId();}
+      ETranformationType getTransformationType(void) { return TRANS_ZOOM_DOMAIN ;}
+      virtual void inheritFrom(SuperTransform* srcTransform) { solveDescInheritance(true, this->SuperClass::get((MyClass*)srcTransform)) ;}
+      static CTransformation<CDomain>* getTransformation(const StdString& id) { return SuperClass::get(id);}
+      virtual CGenericAlgorithmTransformation* createAlgorithm(bool isSource,
+                                                               CGrid* gridDst, CGrid* gridSrc,
+                                                               int elementPositionInGrid,
+                                                               std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridSrc2DomainPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2ScalarPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2AxisPosition,
+                                                               std::map<int, int>& elementPositionInGridDst2DomainPosition)  ;
     private:
       static bool registerTrans();
       static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node);
       static bool _dummyRegistered;
   }; // class CZoomDomain

Context Navigation

Legend:

Download in other formats: