Changeset 1637 for XIOS/trunk/src/distribution_client.cpp

Timestamp:

01/14/19 13:33:48 (5 years ago)

Author:

oabramkina

Message:

Merging dev to trunk. Major changes:

(1) Grid mask is applied in the source filter of clients: unmasked values are replaced by NaN. It is not reconstructed any more by servers.

(2) Domain/axis mask has been incorporated into data index, with only data index sent to servers.

File:

• XIOS/trunk/src/distribution_client.cpp (modified) (12 diffs)

XIOS/trunk/src/distribution_client.cpp

@@ -15 +15 @@
    , axisDomainOrder_()
    , nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_()
-   , dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_()
+   , dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_()
    , gridMask_(), indexMap_()
    , isDataDistributed_(true), axisNum_(0), domainNum_(0)
@@ -36 +36 @@
   GlobalLocalMap void2 ;
   std::vector<int> void3 ;
-  std::vector<int> void4 ;
+  std::vector<bool> void4 ;
 
   globalLocalDataSendToServerMap_.swap(void1) ;
@@ -61 +61 @@
   // Then check mask of grid
   int gridDim = domList.size() * 2 + axisList.size();
-  grid->checkMask();
   switch (gridDim) {
     case 0:
@@ -117 +116 @@
   axisDomainOrder_ = axisDomainOrder;
 
-  // Each domain or axis has its mask, of course
-  domainMasks_.resize(domainNum_);
-  for (int i = 0; i < domainNum_;++i)
-  {
-    domainMasks_[i].resize(domList[i]->domainMask.numElements());
-    domainMasks_[i] = domList[i]->domainMask;
-  }
-
-  axisMasks_.resize(axisNum_);
-  for (int i = 0; i < axisNum_; ++i)
-  {
-    axisMasks_[i].resize(axisList[i]->mask.numElements());
-    axisMasks_[i] = axisList[i]->mask;
-  }
-
   // Because domain and axis can be in any order (axis1, domain1, axis2, axis3, )
   // their position should be specified. In axisDomainOrder, domain == true, axis == false
@@ -282 +266 @@
 
         if ((iIdx >= nBeginLocal_[indexMap_[i]]) && (iIdx < nLocal_[indexMap_[i]]) &&
-           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]) &&
-           (domainMasks_[idxDomain](iIdx + jIdx*nLocal_[indexMap_[i]])))
+           (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]))
         {
           ++count;
@@ -325 +308 @@
       elementIndexData_[i].resize(dataNIndex_[i]);
       elementIndexData_[i] = false;
-      int iIdx = 0, count = 0, localIndex = 0;
+      int iIdx = 0, count = 0;
       for (int j = 0; j < dataNIndex_[i]; ++j)
       {
         iIdx = getAxisIndex((dataIndex_[indexMap_[i]])(j), dataBegin_[indexMap_[i]], nLocal_[indexMap_[i]]);
         if ((iIdx >= nBeginLocal_[indexMap_[i]]) &&
-           (iIdx < nLocal_[indexMap_[i]]) && (axisMasks_[idxAxis](iIdx)))
+           (iIdx < nLocal_[indexMap_[i]]) )//&& (axisMasks_[idxAxis](iIdx)))
         {
           ++count;
@@ -413 +396 @@
 
   for (int i = 0; i < numElement_; ++i) ssize *= eachElementSize[i];
-  while (idx < ssize)
-  {
-    for (int i = 0; i < numElement_-1; ++i)
-    {
-      if (idxLoop[i] == eachElementSize[i])
-      {
-        idxLoop[i] = 0;
-        ++idxLoop[i+1];
-      }
-    }
-
-    // Find out outer index
-    // Depending the inner-most element is axis or domain,
-    // The outer loop index begins correspondingly at one (1) or zero (0)
-    for (int i = 1; i < numElement_; ++i)
-    {
-      currentIndex[i] = elementLocalIndex_[i](idxLoop[i]);
-    }
-
-    // Inner most index
-    for (int i = 0; i < innerLoopSize; ++i)
-    {
-      int gridMaskIndex = 0;
-      currentIndex[0] = elementLocalIndex_[0](i);
-
-      // If defined, iterate on grid mask
-      if (!gridMask_.isEmpty())
-      {
-        for (int k = 0; k < this->numElement_; ++k)
-        {
-          gridMaskIndex += (currentIndex[k])*elementNLocal_[k];
-        }
-        if (gridMask_(gridMaskIndex)) ++indexLocalDataOnClientCount;
-      }
-      // If grid mask is not defined, iterate on elements' mask
-      else
-      {
-        bool maskTmp = true;
-        int idxDomain = 0, idxAxis = 0;
-        for (int elem = 0; elem < numElement_; ++elem)
-        {
-          if (2 == axisDomainOrder_(elem))
-          {
-            maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
-            ++idxDomain;
-          }
-          else if (1 == axisDomainOrder_(elem))
-          {
-            maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
-            ++idxAxis;
-          }
-        }
-        if (maskTmp) ++indexLocalDataOnClientCount;
-      }
-
-    }
-    idxLoop[0] += innerLoopSize;
-    idx += innerLoopSize;
-  }
-
-  // Now allocate these arrays
-  localDataIndex_.resize(indexLocalDataOnClientCount);
-  localMaskIndex_.resize(indexLocalDataOnClientCount);
-  localMaskedDataIndex_.resize(indexLocalDataOnClientCount);
-  globalDataIndex_.rehash(std::ceil(indexLocalDataOnClientCount/globalDataIndex_.max_load_factor()));
-  globalLocalDataSendToServerMap_.rehash(std::ceil(indexLocalDataOnClientCount/globalLocalDataSendToServerMap_.max_load_factor()));
+
+  localDataIndex_.resize(ssize);
+  if (!gridMask_.isEmpty()) localMaskIndex_.resize(ssize);
+  localMaskedDataIndex_.resize(ssize);
+  globalDataIndex_.rehash(std::ceil(ssize/globalDataIndex_.max_load_factor()));
+  globalLocalDataSendToServerMap_.rehash(std::ceil(ssize/globalLocalDataSendToServerMap_.max_load_factor()));
+
 
   // We need to loop with data index
@@ -535 +459 @@
         if (isCurrentIndexDataCorrect)
         {
-          int gridMaskIndex = 0;
-          for (int k = 0; k < this->numElement_; ++k)
+          bool maskTmp = true;
+          bool maskGridTmp = true;
+          size_t globalIndex = 0;
+          for (int k = 0; k < numElement_; ++k)
           {
-            gridMaskIndex += (currentIndex[k])*elementNLocal_[k];
+            globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k];
           }
-
-          bool maskTmp = true;
-          // If defined, apply grid mask
-         if (!gridMask_.isEmpty())
+          globalDataIndex_[globalIndex] = indexLocalDataOnClientCount;
+          localDataIndex_[indexLocalDataOnClientCount] = countLocalData;
+          globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount;
+          localMaskedDataIndex_[indexLocalDataOnClientCount] = indexLocalDataOnClientCount;
+
+          // Grid mask: unmasked values will be replaces by NaN and then all values will be sent
+          if (!gridMask_.isEmpty())
           {
-            maskTmp =  gridMask_(gridMaskIndex);
+            int gridMaskIndex = 0;
+            for (int k = 0; k < this->numElement_; ++k)
+            {
+              gridMaskIndex += (currentIndex[k])*elementNLocal_[k];
+            }
+            maskGridTmp =  gridMask_(gridMaskIndex);
+            if (maskGridTmp)
+              localMaskIndex_[indexLocalDataOnClientCount] = true;
+            else
+              localMaskIndex_[indexLocalDataOnClientCount] = false;
           }
-          // If grid mask is not defined, apply elements' mask
-          else
-          {
-            int idxDomain = 0, idxAxis = 0;
-            for (int elem = 0; elem < numElement_; ++elem)
-            {
-              if (2 == axisDomainOrder_(elem))
-              {
-                maskTmp = maskTmp && domainMasks_[idxDomain](currentIndex[elem]);
-                ++idxDomain;
-              }
-              else if (1 == axisDomainOrder_(elem))
-              {
-                maskTmp = maskTmp && axisMasks_[idxAxis](currentIndex[elem]);
-                ++idxAxis;
-              }
-            }
-          }
-
-          if (maskTmp)
-          {
-            size_t globalIndex = 0;
-            for (int k = 0; k < numElement_; ++k)
-            {
-              globalIndex += (currentGlobalIndex[k])*elementNGlobal_[k];
-            }
-            globalDataIndex_[globalIndex] = indexLocalDataOnClientCount;
-            localDataIndex_[indexLocalDataOnClientCount] = countLocalData;
-            globalLocalDataSendToServerMap_[globalIndex] = indexLocalDataOnClientCount;
-            localMaskIndex_[indexLocalDataOnClientCount] = gridMaskIndex;
-            localMaskedDataIndex_[indexLocalDataOnClientCount] = indexLocalDataOnClientCount;
-            ++indexLocalDataOnClientCount;
-          }
+
+          ++indexLocalDataOnClientCount;
+
         }
         ++countLocalData;
@@ -586 +494 @@
     }
     else countLocalData+=innerLoopSize ;
-    
+
     idxLoop[0] += innerLoopSize;
     idx += innerLoopSize;
@@ -614 +522 @@
                                         const int& dataDim, const int& ni, int& j)
 {
+  int i;
   int tempI = dataIIndex + dataIBegin,
       tempJ = (dataJIndex + dataJBegin);
   if (ni == 0)
   {
-    int i = 0;
-    j = 0;
+    i = -1;
+    j = -1;
     return i;
   }
-  int i = (dataDim == 1) ? (tempI) % ni
-                         : (tempI) ;
-  j = (dataDim == 1) ? (tempI) / ni
-                     : (tempJ) ;
-
+  if ((tempI < 0) || (tempJ < 0))
+  {
+    i = -1;
+    j = -1;
+    return i;
+  }
+  else
+  {
+    i = (dataDim == 1) ? (tempI) % ni : (tempI) ;
+    j = (dataDim == 1) ? (tempI) / ni : (tempJ) ;
+  }
   return i;
 }
@@ -643 +558 @@
     return -1;
   }
-  int tempI = dataIndex + dataBegin;
+  int tempI = dataIndex;
   if ((tempI < 0) || (tempI > ni))
     return -1;
@@ -677 +592 @@
   Return local mask index of client
 */
-const std::vector<int>& CDistributionClient::getLocalMaskIndexOnClient()
+const std::vector<bool>& CDistributionClient::getLocalMaskIndexOnClient()
 {
   if (!isComputed_) createGlobalIndexSendToServer();