Changeset 1078 for XIOS/trunk/src/node

Timestamp:

03/17/17 16:02:40 (7 years ago)

Author:

mhnguyen

Message:

Adding rectilinear and curvilinear domain for expand_domain transformation
-) Rectilinear/curvilinear is expanded not only locally but also globally, its global size ni_glo, nj_glo become ni_glo+2 and nj_glo+2
-) Two attributes i_periodic, j_periodic are only used for rectilinear/curvilinear to process priodic condition

+) Do some minor modification

Test
+) Add test_connectivity_expand
+) On Curie
+) Work (but need more real tests)

Location:

XIOS/trunk/src/node

Files:

• domain.cpp (modified) (7 diffs)
• domain.hpp (modified) (2 diffs)
• expand_domain.cpp (modified) (1 diff)
• grid.cpp (modified) (11 diffs)
• grid.hpp (modified) (5 diffs)

XIOS/trunk/src/node/domain.cpp

@@ -31 +31 @@
       : CObjectTemplate<CDomain>(), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
@@ -41 +41 @@
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
@@ -844 +844 @@
          for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
      }
-     computeNGlobDomain();
+     
      checkZoom();
      
@@ -1550 +1550 @@
     int nbServer = client->serverSize;
 
-    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    CServerDistributionDescription serverDescription(getNbGlob(), nbServer);
     if (isUnstructed_) serverDescription.computeServerDistribution(false, 0);
     else serverDescription.computeServerDistribution(false, 1);
@@ -1587 +1587 @@
   }
 
-  void CDomain::computeNGlobDomain()
-  {
-    nGlobDomain_.resize(2);
-    nGlobDomain_[0] = ni_glo.getValue();
-    nGlobDomain_[1] = nj_glo.getValue();
+  std::vector<int> CDomain::getNbGlob()
+  {
+     std::vector<int> nbGlob(2);
+     nbGlob[0] = ni_glo.getValue();
+     nbGlob[1] = nj_glo.getValue();
+
+     return nbGlob;
   }
 
@@ -1685 +1687 @@
     size_t globalSizeIndex = 1, indexBegin, indexEnd;
     int range, clientSize = client->clientSize;
-    for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
+    for (int i = 0; i < getNbGlob().size(); ++i) globalSizeIndex *= getNbGlob()[i];
     indexBegin = 0;
     if (globalSizeIndex <= clientSize)
@@ -1704 +1706 @@
     }
 
-    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    CServerDistributionDescription serverDescription(getNbGlob(), nbServer);
     if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
     else serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);

XIOS/trunk/src/node/domain.hpp

@@ -123 +123 @@
         vector< vector<int> > j_indSrv ; // for each server, j global index to send
 
+         std::vector<int> getNbGlob();
       public:
          /// Mutateur ///
@@ -210 +211 @@
          bool isCompressible_;
          bool isRedistributed_;
-         TransMapTypes transformationMap_;
-         std::vector<int> nGlobDomain_;
+         TransMapTypes transformationMap_;         
          bool isUnstructed_;
        

XIOS/trunk/src/node/expand_domain.cpp

@@ -38 +38 @@
   void CExpandDomain::checkValid(CDomain* domainDst)
   {
-    if (CDomain::type_attr::unstructured != domainDst->type)
-    {
-      ERROR("CExpandDomain::checkValid(CDomain* domainDst)",
-            << "Domain extension is only supported for unstructured" << std::endl
-            << "Check type of domain destination, id = " << domainDst->getId());
-    }
+    // if (CDomain::type_attr::unstructured != domainDst->type)
+    // {
+    //   ERROR("CExpandDomain::checkValid(CDomain* domainDst)",
+    //         << "Domain extension is only supported for unstructured" << std::endl
+    //         << "Check type of domain destination, id = " << domainDst->getId());
+    // }
 
     if (this->type.isEmpty()) this->type.setValue(CExpandDomain::type_attr::edge);

XIOS/trunk/src/node/grid.cpp

@@ -31 +31 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
    {
@@ -49 +49 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
    {
@@ -74 +74 @@
 
 
-   StdSize CGrid::getDimension(void) const
-   {
-      return globalDim_.size();
+   StdSize CGrid::getDimension(void)
+   {
+      return getGlobalDimension().size();
    }
 
@@ -185 +185 @@
         for (int i = 0; i < axisListP.size(); ++i)
         {
-          axisListP[i]->checkAttributesOnClientAfterTransformation(globalDim_,axisPositionInGrid_[i]);
+          axisListP[i]->checkAttributesOnClientAfterTransformation(getGlobalDimension(),axisPositionInGrid_[i]);
         }
       }
@@ -232 +232 @@
      this->solveScalarRef(areAttributesChecked);
      this->solveAxisRef(areAttributesChecked);
-     this->solveDomainRef(areAttributesChecked);
-     computeGridGlobalDimension(getDomains(), getAxis(), getScalars(), axis_domain_order);
+     this->solveDomainRef(areAttributesChecked);     
      this->isDomainAxisChecked = areAttributesChecked;
    }
@@ -463 +462 @@
         {
           if (sendAtt)
-            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionInGrid_[i]);
+            axisListP[i]->sendCheckedAttributes(getGlobalDimension(),axisPositionInGrid_[i]);
           else
             axisListP[i]->checkAttributesOnClient();
@@ -533 +532 @@
      // Compute mapping between client and server
      std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
-     CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize);
+     CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize);
      serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement,
                                                                 client->clientRank,
                                                                 client->clientSize,
                                                                 axis_domain_order,
-                                                                positionDimensionDistributed_);
+                                                                getDistributedDimension());
      computeIndexByElement(indexServerOnElement, globalIndexOnServer_);
 
@@ -1323 +1322 @@
   }
 
-  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains,
-                                         const std::vector<CAxis*>& axis,
-                                         const std::vector<CScalar*>& scalars,
-                                         const CArray<int,1>& axisDomainOrder)
-  {
-    globalDim_.resize(domains.size()*2+axis.size()+scalars.size());
+  /*
+     Compute on the fly the global dimension of a grid with its elements
+     \param[in/out] globalDim global dimension of grid
+     \param[in] domains list of its domains
+     \param[in] axiss list of its axis
+     \param[in] scalars list of its scalars
+     \param[in] axisDomainOrder the order of element in a grid (e.g: scalar then axis)
+     \return The dimension of which we do distribution (often for server)
+  */
+  int CGrid::computeGridGlobalDimension(std::vector<int>& globalDim,
+                                        const std::vector<CDomain*> domains,
+                                        const std::vector<CAxis*> axis,
+                                        const std::vector<CScalar*> scalars,
+                                        const CArray<int,1>& axisDomainOrder)
+  {
+    globalDim.resize(domains.size()*2+axis.size()+scalars.size());
+    int positionDimensionDistributed = 1;
     int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0;
     for (int i = 0; i < axisDomainOrder.numElements(); ++i)
@@ -1336 +1346 @@
         if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured))
         {
-          positionDimensionDistributed_ = idx;
+          positionDimensionDistributed = idx;
         }
         else
         {
-          positionDimensionDistributed_ = idx +1;
-        }
-
-        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue();
-        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue();
+          positionDimensionDistributed = idx +1;
+        }
+
+        globalDim[idx]   = domains[idxDomain]->ni_glo.getValue();
+        globalDim[idx+1] = domains[idxDomain]->nj_glo.getValue();
 
         ++idxDomain;
@@ -1351 +1361 @@
       else if (1 == axisDomainOrder(i))
       {
-        globalDim_[idx] = axis[idxAxis]->n_glo.getValue();
+        globalDim[idx] = axis[idxAxis]->n_glo.getValue();
         ++idxAxis;
         ++idx;
@@ -1357 +1367 @@
       else
       {
-        globalDim_[idx] = 1;
+        globalDim[idx] = 1;
         ++idxScalar;
         ++idx;
       }
     }
-  }
-
+
+    return positionDimensionDistributed;
+  }
+
+  // Retrieve the global dimension of grid
   std::vector<int> CGrid::getGlobalDimension()
   {
-    return globalDim_;
+    std::vector<int> globalDim;
+    computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);
+
+    return globalDim;
+  }
+
+  // Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
+  int CGrid::getDistributedDimension()
+  {
+    std::vector<int> globalDim;
+    return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);    
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -87 +87 @@
 
          /// Accesseurs ///
-         StdSize getDimension(void) const;
+         StdSize getDimension(void);
 
          StdSize  getDataSize(void) const;
@@ -229 +229 @@
          void modifyMask(const CArray<int,1>& indexToModify);
 
-         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>
@@ -261 +256 @@
                                    CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
 
+        int computeGridGlobalDimension(std::vector<int>& globalDim,
+                                       const std::vector<CDomain*> domains,
+                                       const std::vector<CAxis*> axis,
+                                       const std::vector<CScalar*> scalars,
+                                       const CArray<int,1>& axisDomainOrder);
+
+        int getDistributedDimension();
       private:
         CDomainGroup* vDomainGroup_;
@@ -276 +278 @@
         std::vector<int> connectedServerRank_;
         bool isDataDistributed_;
-        int positionDimensionDistributed_;
+        
          //! True if and only if the data defined on the grid can be outputted in a compressed way
         bool isCompressible_;
@@ -285 +287 @@
         std::vector<int> axisPositionInGrid_;
         CGridTransformation* transformations_;
-        bool hasDomainAxisBaseRef_;
-        std::vector<int> globalDim_;
+        bool hasDomainAxisBaseRef_;        
         std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
         bool hasTransform_;