Changeset 1642 for XIOS/dev/branch_openmp/src/node/grid.cpp

Timestamp:

01/23/19 10:31:44 (6 years ago)

Author:

yushan

Message:

dev on ADA. add flag switch _usingEP/_usingMPI

File:

• XIOS/dev/branch_openmp/src/node/grid.cpp (modified) (122 diffs)

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

@@ -82 +82 @@
 
    StdSize CGrid::getDimension(void)
+   TRY
    {
       return getGlobalDimension().size();
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
 
    StdSize CGrid::getDataSize(void) const
+   TRY
    {
      StdSize retvalue = 1;
@@ -98 +101 @@
      return retvalue;
    }
+   CATCH
 
    /*!
@@ -106 +110 @@
     */
    std::map<int, StdSize> CGrid::getAttributesBufferSize(CContextClient* client, bool bufferForWriting)
+   TRY
    {
      std::map<int, StdSize> attributesSizes = getMinimumBufferSizeForAttributes(client);
@@ -147 +152 @@
      return attributesSizes;
   }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -156 +162 @@
     */
    std::map<int, StdSize> CGrid::getDataBufferSize(CContextClient* client, const std::string& id /*= ""*/, bool bufferForWriting /*= "false"*/)
+   TRY
    {     
      // The record index is sometimes sent along with the data but we always
@@ -180 +187 @@
      return dataSizes;
    }
+   CATCH_DUMP_ATTR
 
    size_t CGrid::getGlobalWrittenSize(void)
+   TRY
    {
          std::vector<CDomain*> domainP = this->getDomains();
@@ -191 +200 @@
      return globalGridSize ;
    }
-   
+   CATCH_DUMP_ATTR
    
    void CGrid::checkAttributesAfterTransformation()
+   TRY
    {
       setAxisList();
@@ -228 +238 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
@@ -237 +248 @@
     */
    bool CGrid::isCompressible(void) const
+   TRY
    {
       return isCompressible_;
    }
+   CATCH
 
    //---------------------------------------------------------------
 
    void CGrid::addRelFileCompressed(const StdString& filename)
+   TRY
    {
       this->relFilesCompressed.insert(filename);
    }
+   CATCH_DUMP_ATTR
 
    bool CGrid::isWrittenCompressed(const StdString& filename) const
+   TRY
    {
       return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
    }
+   CATCH
 
    //---------------------------------------------------------------
@@ -258 +275 @@
    */
    void CGrid::solveDomainAxisRef(bool areAttributesChecked)
+   TRY
    {
      if (this->isDomainAxisChecked) return;
@@ -266 +284 @@
      this->isDomainAxisChecked = areAttributesChecked;
    }
+   CATCH_DUMP_ATTR
 
    /*
@@ -272 +291 @@
    */
    void CGrid::solveDomainAxisBaseRef()
+   TRY
    {
      if (this->hasDomainAxisBaseRef_) return;
@@ -297 +317 @@
      this->hasDomainAxisBaseRef_ = true;
    }
+   CATCH_DUMP_ATTR
 
    void CGrid::checkEligibilityForCompressedOutput()
+   TRY
    {
      // We don't check if the mask is valid here, just if a mask has been defined at this point.
      isCompressible_ = !mask_1d.isEmpty() || !mask_2d.isEmpty() || !mask_3d.isEmpty();
    }
+   CATCH_DUMP_ATTR
 
    void CGrid::checkMaskIndex(bool doSendingIndex)
+   TRY
    {
      CContext* context = CContext::getCurrent();
@@ -339 +363 @@
       this->isChecked = true;
    }
+   CATCH_DUMP_ATTR
+   bool CGrid::hasMask() const
+   TRY
+   {
+     return (!mask_1d.isEmpty() || !mask_2d.isEmpty() || !mask_3d.isEmpty() ||
+             !mask_4d.isEmpty() || !mask_5d.isEmpty() || !mask_6d.isEmpty() || !mask_7d.isEmpty());
+   }
+   CATCH
 
    /*
@@ -344 +376 @@
    */
    void CGrid::createMask(void)
+   TRY
    {
       using namespace std;
@@ -381 +414 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    /*
@@ -386 +420 @@
    */
    void CGrid::checkMask(void)
+   TRY
    {
       using namespace std;
@@ -423 +458 @@
       }
    }
-
-
-/*!
-  A grid can have multiple dimension, so can its mask in the form of multi-dimension array.
-It's not a good idea to store all multi-dimension arrays corresponding to each mask.
-One of the ways is to convert this array into 1-dimension one and every process is taken place on it.
-  \param [in] multi-dimension array grid mask
-*/
-
-  void CGrid::getLocalMask(CArray<bool,1>& localMask)
-  {
-      std::vector<CDomain*> domainP = this->getDomains();
-      std::vector<CAxis*> axisP = this->getAxis();
-      int dim = domainP.size() * 2 + axisP.size();
-
-      switch (dim)
-      {
-        case 0:
-          getLocalMask(mask_0d, localMask);
-          break;
-        case 1:
-          getLocalMask(mask_1d, localMask);
-          break;
-        case 2:
-          getLocalMask(mask_2d, localMask);
-          break;
-        case 3:
-          getLocalMask(mask_3d, localMask);
-          break;
-        case 4:
-          getLocalMask(mask_4d, localMask);
-          break;
-        case 5:
-          getLocalMask(mask_5d, localMask);
-          break;
-        case 6:
-          getLocalMask(mask_6d, localMask);
-          break;
-        case 7:
-          getLocalMask(mask_7d, localMask);
-          break;
-        default:
-          break;
-      }
-  }
-      
+   CATCH_DUMP_ATTR
+
    /*
      Modify value of mask in a certain index
@@ -476 +467 @@
    */
    void CGrid::modifyMask(const CArray<int,1>& indexToModify, bool modifyValue)
+   TRY
    {
       using namespace std;
@@ -511 +503 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    /*
@@ -518 +511 @@
    */
    void CGrid::modifyMaskSize(const std::vector<int>& newDimensionSize, bool newValue)
+   TRY
    {      
       std::vector<CDomain*> domainP = this->getDomains();
@@ -552 +546 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
 
    void CGrid::solveDomainRef(bool sendAtt)
+   TRY
    {
       setDomainList();
@@ -568 +564 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
 
    void CGrid::solveAxisRef(bool sendAtt)
+   TRY
    {
       setAxisList();
@@ -599 +597 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
 
    void CGrid::solveScalarRef(bool sendAtt)
+   TRY
    {
       setScalarList();
@@ -616 +616 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -621 +622 @@
    */
    void CGrid::computeWrittenIndex()
+   TRY
    {      
       if (computedWrittenIndex_) return;
@@ -659 +661 @@
         {
           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);
+          ep_lib::MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
+          ep_lib::MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, EP_INT, EP_SUM, server->intraComm);
           offsetWrittenIndexes_ -= numberWrittenIndexes_;
         }
@@ -680 +682 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    //---------------------------------------------------------------
@@ -690 +693 @@
    */
    void CGrid::computeClientIndex()
+   TRY
    {
      CContext* context = CContext::getCurrent();
 
-     CContextClient* client = context->client;  // Here it's not important which contextClient to recuperate
+     CContextClient* client = context->client;
      int rank = client->clientRank;
 
      clientDistribution_ = new CDistributionClient(rank, this);
      // Get local data index on client
-     storeIndex_client.resize(clientDistribution_->getLocalDataIndexOnClient().size());
-     int nbStoreIndex = storeIndex_client.numElements();
+     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();
@@ -746 +754 @@
       }
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -751 +760 @@
    */
    void CGrid::computeConnectedClients()
+   TRY
    {
      CContext* context = CContext::getCurrent();
@@ -840 +850 @@
           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() ;
+         ep_lib::MPI_Gather(&localCount, 1, EP_INT, &counts[0], 1, EP_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]);
+         ep_lib::MPI_Gatherv(&(connectedServerRank_[receiverSize])[0], localCount, EP_INT, &allConnectedServers[0], &counts[0], &displs[0], EP_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
 
    /*!
@@ -853 +888 @@
    */
    void CGrid::computeIndex(void)
+   TRY
    {
      CContext* context = CContext::getCurrent();
@@ -879 +915 @@
      }
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -892 +929 @@
                                      const CContextClient* client,
                                      CClientServerMapping::GlobalIndexMap& globalIndexOnServer)
+   TRY
    {
      int serverSize = client->serverSize;
@@ -1058 +1096 @@
     }
    }
-   //----------------------------------------------------------------
+   CATCH_DUMP_ATTR
+//----------------------------------------------------------------
 
    CGrid* CGrid::createGrid(CDomain* domain)
+   TRY
    {
       std::vector<CDomain*> vecDom(1, domain);
@@ -1067 +1107 @@
       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);
@@ -1075 +1117 @@
       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()))
@@ -1132 +1180 @@
       return grid;
    }
+   CATCH
 
    CGrid* CGrid::cloneGrid(const StdString& idNewGrid, CGrid* gridSrc)
+   TRY
    {
      std::vector<CDomain*> domainSrcTmp = gridSrc->getDomains(), domainSrc;
@@ -1173 +1223 @@
       return grid;
    }
+   CATCH
 
    StdString CGrid::generateId(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()))
@@ -1216 +1268 @@
       return id.str();
    }
+   CATCH
 
    StdString CGrid::generateId(const CGrid* gridSrc, const CGrid* gridDest)
+   TRY
    {
      StdString idSrc  = gridSrc->getId();
@@ -1227 +1281 @@
      return id.str();
    }
+   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
 
 /*
@@ -1279 +1340 @@
 
    void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const
+   TRY
    {
       const StdSize size = storeIndex_client.numElements();
@@ -1285 +1347 @@
       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();
@@ -1292 +1356 @@
       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();    
-//    int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1; // This should be changed soon
-//    for (int p = 0; p < nbSrvPools; ++p)
-    {
-//      CContextClient* client = (context->hasServer) ? (context->hasClient ? context->clientPrimServer[p] : context->client)
-//                                                    : context->client;
+    {
       CContextClient* client = context->client;
 
@@ -1340 +1414 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::computeConnectedClientsScalarGrid()
+  TRY
   {
     CContext* context = CContext::getCurrent();    
@@ -1386 +1462 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::sendIndexScalarGrid()
+  TRY
   {
     CContext* context = CContext::getCurrent();
@@ -1451 +1529 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::sendIndex(void)
+  TRY
   {
     CContext* context = CContext::getCurrent();
@@ -1572 +1652 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::recvIndex(CEventServer& event)
+  TRY
   {
     string gridId;
@@ -1589 +1671 @@
     get(gridId)->recvIndex(ranks, buffers);
   }
+  CATCH
 
   void CGrid::recvIndex(vector<int> ranks, vector<CBufferIn*> buffers)
+  TRY
   {
     CContext* context = CContext::getCurrent();
@@ -1631 +1715 @@
           std::vector<CDomain*> domainList = getDomains();
           std::vector<CAxis*> axisList = getAxis();
-          std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize), nGlobElement(numElement);
-          std::vector<CArray<int,1> > globalZoomIndex(numElement);
+          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)
           {
@@ -1638 +1722 @@
             if (2 == axis_domain_order(i)) //domain
             {
-              nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin;
-              nZoomSize[indexMap[i]]  = domainList[domainId]->zoom_ni;
-              nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->global_zoom_ibegin;              
+              nBegin[indexMap[i]] = domainList[domainId]->ibegin;
+              nSize[indexMap[i]]  = domainList[domainId]->ni;
+              nBeginGlobal[indexMap[i]] = 0;
               nGlob[indexMap[i]] = domainList[domainId]->ni_glo;
 
-              nZoomBegin[indexMap[i] + 1] = domainList[domainId]->zoom_jbegin;
-              nZoomSize[indexMap[i] + 1] = domainList[domainId]->zoom_nj;
-              nZoomBeginGlobal[indexMap[i] + 1] = domainList[domainId]->global_zoom_jbegin;              
+              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;
-                globalZoomIndex[i].resize(nZoomSize[indexMap[i]]*nZoomSize[indexMap[i]+1]);
-                for (int jdx = 0; jdx < nZoomSize[indexMap[i]+1]; ++jdx)
-                  for (int idx = 0; idx < nZoomSize[indexMap[i]]; ++idx)                
+                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)
                   {
-                    globalZoomIndex[i](count) = (nZoomBegin[indexMap[i]] + idx) + (nZoomBegin[indexMap[i]+1] + jdx) * nGlob[indexMap[i]];
+                    globalIndex[i](count) = (nBegin[indexMap[i]] + idx) + (nBegin[indexMap[i]+1] + jdx) * nGlob[indexMap[i]];
                     ++count;
                   }
@@ -1663 +1747 @@
             else if (1 == axis_domain_order(i)) // axis
             {
-              nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin;
-              nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_n;
-              nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;              
+              nBegin[indexMap[i]] = axisList[axisId]->begin;
+              nSize[indexMap[i]]  = axisList[axisId]->n;
+              nBeginGlobal[indexMap[i]] = 0;
               nGlob[indexMap[i]] = axisList[axisId]->n_glo;     
-              if (axisList[axisId]->zoomByIndex())
-              {
-                globalZoomIndex[i].reference(axisList[axisId]->zoom_index);                
-              }
-              else
-              {
-                globalZoomIndex[i].resize(nZoomSize[indexMap[i]]);
-                for (int idx = 0; idx < nZoomSize[indexMap[i]]; ++idx)
-                  globalZoomIndex[i](idx) = nZoomBegin[indexMap[i]] + idx;
-              }
+              globalIndex[i].resize(nSize[indexMap[i]]);
+              for (int idx = 0; idx < nSize[indexMap[i]]; ++idx)
+                globalIndex[i](idx) = nBegin[indexMap[i]] + idx;
 
               ++axisId;
@@ -1682 +1759 @@
             else // scalar
             { 
-              nZoomBegin[indexMap[i]] = 0;
-              nZoomSize[indexMap[i]]  = 1;
-              nZoomBeginGlobal[indexMap[i]] = 0;              
+              nBegin[indexMap[i]] = 0;
+              nSize[indexMap[i]]  = 1;
+              nBeginGlobal[indexMap[i]] = 0;
               nGlob[indexMap[i]] = 1;
-              globalZoomIndex[i].resize(1);
-              globalZoomIndex[i](0) = 0;
+              globalIndex[i].resize(1);
+              globalIndex[i](0) = 0;
               ++scalarId;
             }
@@ -1693 +1770 @@
           dataSize = 1;
 
-          for (int i = 0; i < nZoomSize.size(); ++i)
-            dataSize *= nZoomSize[i];
+          for (int i = 0; i < nSize.size(); ++i)
+            dataSize *= nSize[i];
           serverDistribution_ = new CDistributionServer(server->intraCommRank, 
-                                                        globalZoomIndex, axis_domain_order,
-                                                        nZoomBegin, nZoomSize, nZoomBeginGlobal, nGlob);
+                                                        globalIndex, axis_domain_order,
+                                                        nBegin, nSize, nBeginGlobal, nGlob);
         }
 
@@ -1760 +1837 @@
           nGlob.push_back(1);  
         }
-
-        modifyMaskSize(nSize, false);
-
-        // These below codes are reserved for future
-        CDistributionServer srvDist(server->intraCommRank, nBegin, nSize, nBeginGlobal, nGlob); 
-        map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClient.begin(),
-                                               ite = outGlobalIndexFromClient.end(), it;  
-        const CDistributionServer::GlobalLocalMap&  globalLocalMask = srvDist.getGlobalLocalIndex();
-        CDistributionServer::GlobalLocalMap::const_iterator itSrv;
-        size_t nb = 0;
-        for (it = itb; it != ite; ++it)
-        {
-          CArray<size_t,1>& globalInd = it->second;
-          for (size_t idx = 0; idx < globalInd.numElements(); ++idx)
-          {
-            if (globalLocalMask.end() != globalLocalMask.find(globalInd(idx))) ++nb;
-          }
-        }
-        
-        CArray<int,1> indexToModify(nb);
-        nb = 0;    
-        for (it = itb; it != ite; ++it)
-        {
-          CArray<size_t,1>& globalInd = it->second;
-          for (size_t idx = 0; idx < globalInd.numElements(); ++idx)
-          {
-            itSrv = globalLocalMask.find(globalInd(idx));
-            if (globalLocalMask.end() != itSrv) 
-            {
-              indexToModify(nb) = itSrv->second;
-              ++nb;
-            }
-          }
-        }
-
-        modifyMask(indexToModify, true);
       }
 
@@ -1803 +1844 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   /*
@@ -1818 +1860 @@
                                         const std::vector<CScalar*> scalars,
                                         const CArray<int,1>& axisDomainOrder)
-  {
+  TRY
+ {
  //   globalDim.resize(domains.size()*2+axis.size()+scalars.size());
     globalDim.resize(domains.size()*2+axis.size());
@@ -1858 +1901 @@
     return positionDimensionDistributed;
   }
+  CATCH_DUMP_ATTR
 
   // Retrieve the global dimension of grid
   std::vector<int> CGrid::getGlobalDimension()
+  TRY
   {
     std::vector<int> globalDim;
@@ -1867 +1912 @@
     return globalDim;
   }
+  CATCH_DUMP_ATTR
 
   // Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
   int CGrid::getDistributedDimension()
+  TRY
   {
     std::vector<int> globalDim;
     return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);    
   }
+  CATCH_DUMP_ATTR
 
   bool CGrid::isScalarGrid() const
+  TRY
   {
     return (axisList_.empty() && domList_.empty());
   }
+  CATCH
 
   /*!
@@ -1886 +1936 @@
   */
   bool CGrid::doGridHaveDataToWrite()
+  TRY
   {
      return (0 != writtenDataSize_);
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -1897 +1949 @@
   */
   size_t CGrid::getWrittenDataSize() const
+  TRY
   {
     return writtenDataSize_;
   }
+  CATCH
 
   /*!
@@ -1906 +1960 @@
   */
   int CGrid::getNumberWrittenIndexes() const
+  TRY
   {
     return numberWrittenIndexes_;
   }
+  CATCH
 
   /*!
@@ -1915 +1971 @@
   */
   int CGrid::getTotalNumberWrittenIndexes() const
+  TRY
   {
     return totalNumberWrittenIndexes_;
   }
+  CATCH
 
   /*!
@@ -1924 +1982 @@
   */
   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
   {
     if (isScalarGrid()) return false;
@@ -1948 +2013 @@
       return isDataDistributed_;    
   }
+  CATCH_DUMP_ATTR
 
    /*!
@@ -1957 +2023 @@
    */
   bool CGrid::dispatchEvent(CEventServer& event)
+  TRY
   {
 
@@ -1990 +2057 @@
     }
   }
+  CATCH
 
    ///---------------------------------------------------------------
 
    CDomain* CGrid::addDomain(const std::string& id)
+   TRY
    {
      order_.push_back(2);
@@ -2000 +2069 @@
      return vDomainGroup_->createChild(id);
    }
+   CATCH_DUMP_ATTR
 
    CAxis* CGrid::addAxis(const std::string& id)
+   TRY
    {
      order_.push_back(1);
@@ -2008 +2079 @@
      return vAxisGroup_->createChild(id);
    }
+   CATCH_DUMP_ATTR
 
    CScalar* CGrid::addScalar(const std::string& id)
+   TRY
    {
      order_.push_back(0);
@@ -2016 +2089 @@
      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
 
    /*!
@@ -2040 +2120 @@
    */
    void CGrid::sendAddDomain(const string& id)
-   {
+   TRY
+  {
       sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN);
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -2049 +2131 @@
    */
    void CGrid::sendAddAxis(const string& id)
+   TRY
    {
       sendAddItem(id, (int)EVENT_ID_ADD_AXIS);
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -2058 +2142 @@
    */
    void CGrid::sendAddScalar(const string& id)
+   TRY
    {
       sendAddItem(id, (int)EVENT_ID_ADD_SCALAR);
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -2067 +2153 @@
    */
    void CGrid::recvAddDomain(CEventServer& event)
+   TRY
    {
 
@@ -2074 +2161 @@
       get(id)->recvAddDomain(*buffer);
    }
+   CATCH
 
    /*!
@@ -2080 +2168 @@
    */
    void CGrid::recvAddDomain(CBufferIn& buffer)
+   TRY
    {
       string id;
@@ -2085 +2174 @@
       addDomain(id);
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -2091 +2181 @@
    */
    void CGrid::recvAddAxis(CEventServer& event)
+   TRY
    {
 
@@ -2098 +2189 @@
       get(id)->recvAddAxis(*buffer);
    }
+   CATCH
 
    /*!
@@ -2104 +2196 @@
    */
    void CGrid::recvAddAxis(CBufferIn& buffer)
+   TRY
    {
       string id;
@@ -2109 +2202 @@
       addAxis(id);
    }
+   CATCH_DUMP_ATTR
 
    /*!
@@ -2115 +2209 @@
    */
    void CGrid::recvAddScalar(CEventServer& event)
+   TRY
    {
 
@@ -2122 +2217 @@
       get(id)->recvAddScalar(*buffer);
    }
+   CATCH
 
    /*!
@@ -2128 +2224 @@
    */
    void CGrid::recvAddScalar(CBufferIn& buffer)
+   TRY
    {
       string id;
@@ -2133 +2230 @@
       addScalar(id);
    }
+   CATCH_DUMP_ATTR
 
   /*!
@@ -2141 +2239 @@
   */
   void CGrid::solveDomainAxisRefInheritance(bool apply)
+  TRY
   {
     CContext* context = CContext::getCurrent();
@@ -2181 +2280 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   bool CGrid::isTransformed()
+  TRY
   {
     return isTransformed_;
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::setTransformed()
+  TRY
   {
     isTransformed_ = true;
   }
+  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
 
   /*!
@@ -2213 +2323 @@
   */
   void CGrid::completeGrid(CGrid* transformGridSrc)
+  TRY
   {
     if (0 != transformGridSrc)
@@ -2231 +2342 @@
     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)
@@ -2268 +2385 @@
     transformGridSrc->checkMaskIndex(false);
   }
+  CATCH_DUMP_ATTR
 
   bool CGrid::hasTransform()
+  TRY
   {
     if (hasTransform_) return hasTransform_;
@@ -2283 +2402 @@
     return hasTransform_;
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2289 +2409 @@
   */
   std::vector<CDomain*> CGrid::getDomains()
+  TRY
   {
     std::vector<CDomain*> domList;
@@ -2297 +2418 @@
     return domList;
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2303 +2425 @@
   */
   std::vector<CAxis*> CGrid::getAxis()
+  TRY
   {
     std::vector<CAxis*> aList;
@@ -2310 +2433 @@
     return aList;
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2316 +2440 @@
   */
   std::vector<CScalar*> CGrid::getScalars()
+  TRY
   {
     std::vector<CScalar*> sList;
@@ -2323 +2448 @@
     return sList;
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2329 +2455 @@
   */
   CDomain* CGrid::getDomain(int domainIndex)
+  TRY
   {
     std::vector<CDomain*> domainListP = this->getDomains();
@@ -2346 +2473 @@
     return domainListP[domainIndex];
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2352 +2480 @@
   */
   CAxis* CGrid::getAxis(int axisIndex)
+  TRY
   {
     std::vector<CAxis*> axisListP = this->getAxis();
@@ -2369 +2498 @@
     return axisListP[axisIndex];
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2375 +2505 @@
   */
   CScalar* CGrid::getScalar(int scalarIndex)
+  TRY
   {
     std::vector<CScalar*> scalarListP = this->getScalars();
@@ -2392 +2523 @@
     return scalarListP[scalarIndex];
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2398 +2530 @@
   */
   void CGrid::setDomainList(const std::vector<CDomain*> domains)
+  TRY
   {
     if (isDomListSet) return;
@@ -2418 +2551 @@
       isDomListSet = true;
     }
-
-  }
+  }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2426 +2559 @@
   */
   void CGrid::setAxisList(const std::vector<CAxis*> axis)
+  TRY
   {
     if (isAxisListSet) return;
@@ -2447 +2581 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2453 +2588 @@
   */
   void CGrid::setScalarList(const std::vector<CScalar*> scalars)
+  TRY
   {
     if (isScalarListSet) return;
@@ -2474 +2610 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2480 +2617 @@
   */
   std::vector<StdString> CGrid::getDomainList()
+  TRY
   {
     setDomainList();
     return domList_;
   }
+  CATCH
 
   /*!
@@ -2490 +2629 @@
   */
   std::vector<StdString> CGrid::getAxisList()
+  TRY
   {
     setAxisList();
     return axisList_;
   }
+  CATCH
 
   /*!
@@ -2500 +2641 @@
   */
   std::vector<StdString> CGrid::getScalarList()
+  TRY
   {
     setScalarList();
     return scalarList_;
   }
+  CATCH
 
   /*!
@@ -2509 +2652 @@
   */
   void CGrid::sendAllDomains()
+  TRY
   {
     std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
@@ -2518 +2662 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2523 +2668 @@
   */
   void CGrid::sendAllAxis()
+  TRY
   {
     std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
@@ -2533 +2679 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2538 +2685 @@
   */
   void CGrid::sendAllScalars()
+  TRY
   {
     std::vector<CScalar*> sList = this->getVirtualScalarGroup()->getAllChildren();
@@ -2548 +2696 @@
     }
   }
+  CATCH_DUMP_ATTR
 
   void CGrid::setContextClient(CContextClient* contextClient)
+  TRY
   {
     if (clientsSet.find(contextClient)==clientsSet.end())
@@ -2561 +2711 @@
         this->getAxis()[i]->setContextClient(contextClient);
   }
+  CATCH_DUMP_ATTR
 
   /*!
@@ -2566 +2717 @@
   */
   void CGrid::parse(xml::CXMLNode& node)
+  TRY
   {
     SuperClass::parse(node);
@@ -2606 +2758 @@
     setScalarList();
    }
+  CATCH_DUMP_ATTR
+
 } // namespace xios