Changeset 887 for XIOS/trunk/src/node/grid.hpp

Timestamp:

07/05/16 15:59:02 (8 years ago)

Author:

mhnguyen

Message:

Adding a new type of element into grid: Scalar

+) Add a new node Scalar for xml
+) Make some change on writing scalar value
+) Reorganize some codes
+) Remove some redundant codes

Test
+) On Curie
+) All tests pass

File:

• XIOS/trunk/src/node/grid.hpp (modified) (16 diffs)

XIOS/trunk/src/node/grid.hpp

@@ -9 +9 @@
 #include "domain.hpp"
 #include "axis.hpp"
+#include "scalar.hpp"
 #include "array_new.hpp"
 #include "attribute_array.hpp"
@@ -24 +25 @@
    class CDomainGroup;
    class CAxisGroup;
+   class CScalarGroup;
    class CGrid;
    class CDistributionClient;
@@ -55 +57 @@
          enum EEventId
          {
-           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS
-         };
-
-         enum EElementType
-         {
-           GRID_ONLY_AXIS, GRID_ONLY_DOMAIN, GRID_AXIS_DOMAIN
+           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS, EVENT_ID_ADD_SCALAR
          };
 
@@ -122 +119 @@
          static CGrid* createGrid(CDomain* domain, CAxis* axis);
          static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                                  const CArray<bool,1>& axisDomainOrder = CArray<bool,1>());
+                                  const CArray<int,1>& axisDomainOrder = CArray<int,1>());
+//         static CGrid* createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+//                                  const CArray<int,1>& axisDomainOrder = CArray<int,1>());
          static CGrid* createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                                  const CArray<bool,1>& axisDomainOrder = CArray<bool,1>());
+                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
+         static CGrid* createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                                  const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder);
+//         static StdString generateId(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+//                                     const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
          static StdString generateId(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                                     const CArray<bool,1>& axisDomainOrder = CArray<bool,1>());
+                                     const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder = CArray<int,1>());
          static StdString generateId(const CGrid* gridSrc, const CGrid* gridDest);
          static CGrid* cloneGrid(const StdString& idNewGrid, CGrid* gridSrc);
@@ -144 +147 @@
          void solveDomainRef(bool checkAtt);
          void solveAxisRef(bool checkAtt);
+         void solveScalarRef(bool checkAtt);
          void solveDomainAxisRefInheritance(bool apply = true);
          void solveTransformations();
@@ -150 +154 @@
          CDomain* addDomain(const std::string& id=StdString());
          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();
 
          static void recvAddDomain(CEventServer& event);
@@ -159 +166 @@
          static void recvAddAxis(CEventServer& event);
          void recvAddAxis(CBufferIn& buffer);
+         static void recvAddScalar(CEventServer& event);
+         void recvAddScalar(CBufferIn& buffer);
 
          static bool dispatchEvent(CEventServer& event);
@@ -172 +181 @@
          std::vector<StdString> getDomainList();
          std::vector<StdString> getAxisList();
+         std::vector<StdString> getScalarList();
          std::vector<CDomain*> getDomains();
          std::vector<CAxis*> getAxis();
+         std::vector<CScalar*> getScalars();
          std::vector<int> getAxisOrder();
          std::vector<int> getGlobalDimension();
@@ -218 +229 @@
          void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
                                          const std::vector<CAxis*>& axis,
-                                         const CArray<bool,1>& axisDomainOrder);
+                                         const std::vector<CScalar*>& scalars,
+                                         const CArray<int,1>& axisDomainOrder);
 
       private:
@@ -225 +237 @@
                           const std::vector<CArray<bool,1>* >& domainMasks,
                           const std::vector<CArray<bool,1>* >& axisMasks,
-                          const CArray<bool,1>& axisDomainOrder,
+                          const CArray<int,1>& axisDomainOrder,
                           bool createMask = false);
         template<int N>
@@ -234 +246 @@
         void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
         void setVirtualAxisGroup();
-
+        void setVirtualScalarGroup(CScalarGroup* newVScalarGroup);
+        void setVirtualScalarGroup();
+
+        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
         void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
-        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
-
+        void setScalarList(const std::vector<CScalar*> scalars = std::vector<CScalar*>());
+
+        CDomainGroup* getVirtualDomainGroup() const;
         CAxisGroup* getVirtualAxisGroup() const;
-        CDomainGroup* getVirtualDomainGroup() const;
+        CScalarGroup* getVirtualScalarGroup() const;
 
         void checkAttributesAfterTransformation();
@@ -246 +262 @@
                                    CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
 
-
       private:
         CDomainGroup* vDomainGroup_;
         CAxisGroup* vAxisGroup_;
-        std::vector<std::string> axisList_, domList_;
-        bool isAxisListSet, isDomListSet;
+        CScalarGroup* vScalarGroup_;
+        std::vector<std::string> axisList_, domList_, scalarList_;
+        bool isAxisListSet, isDomListSet, isScalarListSet;
 
         CDistributionClient* clientDistribution_;
@@ -275 +291 @@
         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<bool> order_;
+        std::vector<int> order_;
    }; // class CGrid
 
@@ -306 +322 @@
                              const std::vector<CArray<bool,1>* >& domainMasks,
                              const std::vector<CArray<bool,1>* >& axisMasks,
-                             const CArray<bool,1>& axisDomainOrder,
+                             const CArray<int,1>& axisDomainOrder,
                              bool createMask)
    {
@@ -320 +336 @@
     {
       indexMap[i] = idx;
-      if (true == axisDomainOrder(i)) {
+      if (2 == axisDomainOrder(i)) {
           eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
           eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
           idx += 2; ++idxDomain;
       }
-      else {
+      else if (1 == axisDomainOrder(i)) {
         eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
         ++idx; ++idxAxis;
       }
+      else ++idx;
     }
 
@@ -365 +382 @@
       for (int i = 0; i < numElement; ++i)
       {
-        if (axisDomainOrder(i))
+        if (2 == axisDomainOrder(i))
         {
           maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]);
           ++idxDomain;
         }
-        else
+        else if (1 == axisDomainOrder(i))
         {
           maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);