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

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.cpp (modified) (46 diffs)

XIOS/trunk/src/node/grid.cpp

@@ -26 +26 @@
       : CObjectTemplate<CGrid>(), CGridAttributes()
       , isChecked(false), isDomainAxisChecked(false)
-      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+      , vDomainGroup_(), domList_(), isDomListSet(false)
+      , vAxisGroup_(), axisList_(), isAxisListSet(false)
+      , vScalarGroup_(), scalarList_(), isScalarListSet(false)
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
@@ -36 +38 @@
      setVirtualDomainGroup();
      setVirtualAxisGroup();
+     setVirtualScalarGroup();
    }
 
@@ -41 +44 @@
       : CObjectTemplate<CGrid>(id), CGridAttributes()
       , isChecked(false), isDomainAxisChecked(false)
-      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+      , vDomainGroup_(), domList_(), isDomListSet(false)
+      , vAxisGroup_(), axisList_(), isAxisListSet(false)
+      , vScalarGroup_(), scalarList_(), isScalarListSet(false)
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
@@ -51 +56 @@
      setVirtualDomainGroup();
      setVirtualAxisGroup();
+     setVirtualScalarGroup();
    }
 
@@ -201 +207 @@
      if (this->isDomainAxisChecked) return;
 
+     this->solveScalarRef(areAttributesChecked);
      this->solveAxisRef(areAttributesChecked);
      this->solveDomainRef(areAttributesChecked);
-     computeGridGlobalDimension(getDomains(), getAxis(), axis_domain_order);
+     computeGridGlobalDimension(getDomains(), getAxis(), getScalars(), axis_domain_order);
      this->isDomainAxisChecked = areAttributesChecked;
    }
@@ -210 +217 @@
    {
      if (this->hasDomainAxisBaseRef_) return;
+     // Account for the scalar attributes
+     std::vector<CScalar*> scalarList = getScalars();
+     for (size_t i = 0; i < scalarList.size(); ++i)
+     {
+       scalarList[i]->setAttributesReference();
+     }
+
      // Account for the axis attributes
      std::vector<CAxis*> axisList = getAxis();
@@ -223 +237 @@
        domList[i]->setAttributesReference();
      }
+
      this->hasDomainAxisBaseRef_ = true;
    }
@@ -383 +398 @@
         for (int i = 0; i < axis_domain_order.numElements(); ++i)
         {
-          if (false == axis_domain_order(i))
+          int elementDimension = axis_domain_order(i);
+          if (1 == elementDimension)
           {
             axisPositionInGrid_.push_back(idx);
             ++idx;
           }
-          else idx += 2;
+          else if (2 == elementDimension) idx += 2;
         }
 
@@ -397 +413 @@
           else
             axisListP[i]->checkAttributesOnClient();
-          ++idx;
+        }
+      }
+   }
+
+   //---------------------------------------------------------------
+
+   void CGrid::solveScalarRef(bool sendAtt)
+   {
+      setScalarList();
+      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();
         }
       }
@@ -502 +534 @@
      int nbElement = axis_domain_order.numElements();
      std::vector<CArray<size_t,1> > globalIndexElement(nbElement);
-     int domainIdx = 0, axisIdx = 0;
+     int domainIdx = 0, axisIdx = 0, scalarIdx = 0;
      std::vector<size_t> elementNGlobal(nbElement);
      elementNGlobal[0] = 1;
@@ -511 +543 @@
        size_t elementSize;
        size_t elementGlobalSize = 1;
-       if (axis_domain_order(idx))
+       if (2 == axis_domain_order(idx))
        {
          elementSize = domList[domainIdx]->i_index.numElements();
@@ -522 +554 @@
          ++domainIdx;
        }
-       else
+       else if (1 == axis_domain_order(idx))
        {
          elementSize = axisList[axisIdx]->index.numElements();
@@ -532 +564 @@
          elementGlobalSize = axisList[axisIdx]->n_glo.getValue();
          ++axisIdx;
+       }
+       else
+       {
+         globalIndexElement[idx].resize(1);
+         globalIndexElement[idx](0) = 0;
+         elementGlobalSize = 1;
        }
        globalSize *= elementGlobalSize;
@@ -657 +695 @@
 
    CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                            const CArray<bool,1>& axisDomainOrder)
-   {
-      return createGrid(generateId(domains, axis, axisDomainOrder), domains, axis, axisDomainOrder);
-   }
+                            const CArray<int,1>& axisDomainOrder)
+   {
+     std::vector<CScalar*> vecScalar;
+     return createGrid(generateId(domains, axis, vecScalar, axisDomainOrder), domains, axis, vecScalar, axisDomainOrder);
+   }
+
+   CGrid* CGrid::createGrid(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   {
+     return createGrid(generateId(domains, axis, scalars, axisDomainOrder), domains, axis, scalars, axisDomainOrder);
+   }
+
+//   CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
+//                            const CArray<int,1>& axisDomainOrder)
+//   {
+//      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.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);
+//
+//      // By default, domains are always the first elements of a grid
+//      if (0 == axisDomainOrder.numElements())
+//      {
+//        int size = domains.size() + axis.size();
+//        grid->axis_domain_order.resize(size);
+//        for (int i = 0; i < size; ++i)
+//        {
+//          if (i < domains.size()) grid->axis_domain_order(i) = 2;
+//          else grid->axis_domain_order(i) = 1;
+//        }
+//      }
+//      else
+//      {
+//        grid->axis_domain_order.resize(axisDomainOrder.numElements());
+//        grid->axis_domain_order = axisDomainOrder;
+//      }
+//
+//      grid->solveDomainAxisRefInheritance(true);
+//
+//      return grid;
+//   }
 
    CGrid* CGrid::createGrid(StdString id, const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                            const CArray<bool,1>& axisDomainOrder)
-   {
-      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size()))
+                            const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   {
+      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
         ERROR("CGrid* CGrid::createGrid(...)",
               << "The size of axisDomainOrder (" << axisDomainOrder.numElements()
@@ -673 +752 @@
       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();
+        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) = true;
-          else grid->axis_domain_order(i) = false;
+          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;
         }
       }
@@ -698 +787 @@
    CGrid* CGrid::cloneGrid(const StdString& idNewGrid, CGrid* gridSrc)
    {
+     std::vector<CDomain*> domainSrcTmp = gridSrc->getDomains(), domainSrc;
      std::vector<CAxis*> axisSrcTmp = gridSrc->getAxis(), axisSrc;
-     std::vector<CDomain*> domainSrcTmp = gridSrc->getDomains(), domainSrc;
+     std::vector<CScalar*> scalarSrcTmp = gridSrc->getScalars(), scalarSrc;
+
+     for (int idx = 0; idx < domainSrcTmp.size(); ++idx)
+     {
+       CDomain* domain = CDomain::createDomain();
+       domain->duplicateAttributes(domainSrcTmp[idx]);
+       domain->duplicateTransformation(domainSrcTmp[idx]);
+       domain->solveRefInheritance(true);
+       domain->solveInheritanceTransformation();
+       domainSrc.push_back(domain);
+     }
+
      for (int idx = 0; idx < axisSrcTmp.size(); ++idx)
      {
@@ -710 +811 @@
      }
 
-     for (int idx = 0; idx < domainSrcTmp.size(); ++idx)
+     for (int idx = 0; idx < scalarSrcTmp.size(); ++idx)
      {
-       CDomain* domain = CDomain::createDomain();
-       domain->duplicateAttributes(domainSrcTmp[idx]);
-       domain->duplicateTransformation(domainSrcTmp[idx]);
-       domain->solveRefInheritance(true);
-       domain->solveInheritanceTransformation();
-       domainSrc.push_back(domain);
-     }
-
-      CGrid* grid = CGrid::createGrid(idNewGrid, domainSrc, axisSrc, gridSrc->axis_domain_order);
+       CScalar* scalar = CScalar::createScalar();
+       scalar->duplicateAttributes(scalarSrcTmp[idx]);
+       scalar->duplicateTransformation(scalarSrcTmp[idx]);
+       scalar->solveRefInheritance(true);
+       scalar->solveInheritanceTransformation();
+       scalarSrc.push_back(scalar);
+     }
+
+      CGrid* grid = CGrid::createGrid(idNewGrid, domainSrc, axisSrc, scalarSrc, gridSrc->axis_domain_order);
 
       return grid;
@@ -726 +827 @@
 
    StdString CGrid::generateId(const std::vector<CDomain*>& domains, const std::vector<CAxis*>& axis,
-                               const CArray<bool,1>& axisDomainOrder)
-   {
-      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size()))
+                               const std::vector<CScalar*>& scalars, const CArray<int,1>& axisDomainOrder)
+   {
+      if (axisDomainOrder.numElements() > 0 && axisDomainOrder.numElements() != (domains.size() + axis.size() + scalars.size()))
         ERROR("CGrid* CGrid::generateId(...)",
               << "The size of axisDomainOrder (" << axisDomainOrder.numElements()
@@ -735 +836 @@
       std::ostringstream id;
 
-      if (domains.empty() && axis.empty())
-        id << "__scalar_grid__";
-      else
+      if (domains.empty() && axis.empty() && !scalars.empty())
+        id << "__scalar_";
+
+      if (0 != (domains.size() + axis.size() + scalars.size()))
       {
         id << "__grid";
@@ -745 +847 @@
           for (size_t i = 0; i < domains.size(); ++i) id << "_" << domains[i]->getId();
           for (size_t i = 0; i < axis.size(); ++i) id << "_" << axis[i]->getId();
+          for (size_t i = 0; i < scalars.size(); ++i) id << "_" << scalars[i]->getId();
         }
         else
         {
-          size_t iDomain = 0, iAxis = 0;
+          size_t iDomain = 0, iAxis = 0, iScalar = 0;
           for (size_t i = 0; i < axisDomainOrder.numElements(); ++i)
           {
-            if (axisDomainOrder(i))
+            if (2 == axisDomainOrder(i))
               id << "_" << domains[iDomain++]->getId();
+            else if (1 == axisDomainOrder(i))
+              id << "_" << axis[iAxis++]->getId();
             else
-              id << "_" << axis[iAxis++]->getId();
+              id << "_" << scalars[iScalar++]->getId();
           }
         }
@@ -785 +890 @@
    {
      return this->vAxisGroup_;
+   }
+
+   CScalarGroup* CGrid::getVirtualScalarGroup() const
+   {
+     return this->vScalarGroup_;
    }
 
@@ -1037 +1147 @@
   void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains,
                                          const std::vector<CAxis*>& axis,
-                                         const CArray<bool,1>& axisDomainOrder)
-  {
-    globalDim_.resize(domains.size()*2+axis.size());
-    int idx = 0, idxDomain = 0, idxAxis = 0;
+                                         const std::vector<CScalar*>& scalars,
+                                         const CArray<int,1>& axisDomainOrder)
+  {
+    globalDim_.resize(domains.size()*2+axis.size()+scalars.size());
+    int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0;
     for (int i = 0; i < axisDomainOrder.numElements(); ++i)
     {
-      if (axisDomainOrder(i))
+      if (2 == axisDomainOrder(i))
       {
         if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured))
@@ -1060 +1171 @@
         idx += 2;
       }
-      else
+      else if (1 == axisDomainOrder(i))
       {
         globalDim_[idx] = axis[idxAxis]->n_glo.getValue();
         ++idxAxis;
+        ++idx;
+      }
+      else
+      {
+        globalDim_[idx] = 1;
+        ++idxScalar;
         ++idx;
       }
@@ -1179 +1296 @@
         {
           indexMap[i] = idx;
-          if (true == axis_domain_order(i))
+          if (2 == axis_domain_order(i))
           {
             ++ssize;
@@ -1188 +1305 @@
         }
 
-        int axisId = 0, domainId = 0;
+        int axisId = 0, domainId = 0, scalarId = 0;
         std::vector<CDomain*> domainList = getDomains();
         std::vector<CAxis*> axisList = getAxis();
@@ -1194 +1311 @@
         for (int i = 0; i < numElement; ++i)
         {
-          if (axis_domain_order(i))
+          if (2 == axis_domain_order(i)) //domain
           {
             nZoomBegin[indexMap[i]] = domainList[domainId]->zoom_ibegin_srv;
@@ -1207 +1324 @@
             ++domainId;
           }
-          else
+          else if (1 == axis_domain_order(i)) // axis
           {
             nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv;
@@ -1214 +1331 @@
             nGlob[indexMap[i]] = axisList[axisId]->n_glo;
             ++axisId;
+          }
+          else // scalar
+          {
+            nZoomBegin[indexMap[i]] = 0;
+            nZoomSize[indexMap[i]]  = 1;
+            nZoomBeginGlobal[indexMap[i]] = 0;
+            nGlob[indexMap[i]] = 1;
+            ++scalarId;
           }
         }
@@ -1281 +1406 @@
            return true;
            break;
+
+         case EVENT_ID_ADD_SCALAR :
+           recvAddScalar(event);
+           return true;
+           break;
         default :
           ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
@@ -1293 +1423 @@
    CDomain* CGrid::addDomain(const std::string& id)
    {
-     order_.push_back(true);
+     order_.push_back(2);
      axis_domain_order.resize(order_.size());
      for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
@@ -1301 +1431 @@
    CAxis* CGrid::addAxis(const std::string& id)
    {
-     order_.push_back(false);
+     order_.push_back(1);
      axis_domain_order.resize(order_.size());
      for (int idx = 0; idx < order_.size(); ++idx) axis_domain_order(idx)=order_[idx];
@@ -1307 +1437 @@
    }
 
+   CScalar* CGrid::addScalar(const std::string& id)
+   {
+     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);
+   }
+
    //! Change virtual field group to a new one
    void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
@@ -1317 +1455 @@
    {
       this->vAxisGroup_ = newVAxisGroup;
+   }
+
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualScalarGroup(CScalarGroup* newVScalarGroup)
+   {
+      this->vScalarGroup_ = newVScalarGroup;
    }
 
@@ -1330 +1474 @@
    {
       this->setVirtualAxisGroup(CAxisGroup::create());
+   }
+
+   //! Create virtual variable group, which is done normally on initializing file
+   void CGrid::setVirtualScalarGroup(void)
+   {
+      this->setVirtualScalarGroup(CScalarGroup::create());
    }
 
@@ -1387 +1537 @@
 
    /*!
+   \brief Send a message to create a scalar on server side
+   \param[in] id String identity of scalar that will be created on server
+   */
+   void CGrid::sendAddScalar(const string& id)
+   {
+    CContext* context=CContext::getCurrent();
+
+    if (! context->hasServer )
+    {
+       CContextClient* client=context->client;
+
+       CEventClient event(this->getType(),EVENT_ID_ADD_SCALAR);
+       if (client->isServerLeader())
+       {
+         CMessage msg;
+         msg<<this->getId();
+         msg<<id;
+         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);
+    }
+   }
+
+   /*!
    \brief Receive a message annoucing the creation of a domain on server side
    \param[in] event Received event
@@ -1432 +1609 @@
       buffer >> id;
       addAxis(id);
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of an scalar on server side
+   \param[in] event Received event
+   */
+   void CGrid::recvAddScalar(CEventServer& event)
+   {
+
+      CBufferIn* buffer = event.subEvents.begin()->buffer;
+      string id;
+      *buffer >> id;
+      get(id)->recvAddScalar(*buffer);
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of an scalar on server side
+   \param[in] buffer Buffer containing message
+   */
+   void CGrid::recvAddScalar(CBufferIn& buffer)
+   {
+      string id;
+      buffer >> id;
+      addScalar(id);
    }
 
@@ -1468 +1669 @@
       }
     }
+
+    setScalarList();
+    it = scalarList_.begin(); itE = scalarList_.end();
+    for (; it != itE; ++it)
+    {
+      CScalar* pScalar = CScalar::get(*it);
+      if (context->hasClient)
+      {
+        pScalar->solveRefInheritance(apply);
+        pScalar->solveInheritanceTransformation();
+      }
+    }
   }
 
@@ -1513 +1726 @@
       else
       {
-        int ssize = axis_domain_order.numElements();
-        for (int i = 0; i < ssize; ++i)
-          if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i))
-            ERROR("CGrid::completeGrid(CGrid* transformGridSrc)",
-                  << "Grids " << this->getId() << " and " << transformGridSrc->getId()
-                  << " don't have elements in the same order");
+//        int ssize = axis_domain_order.numElements();
+//        for (int i = 0; i < ssize; ++i)
+//          if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i))
+//            ERROR("CGrid::completeGrid(CGrid* transformGridSrc)",
+//                  << "Grids " << this->getId() << " and " << transformGridSrc->getId()
+//                  << " don't have elements in the same order");
       }
     }
@@ -1543 +1756 @@
     else
     {
-      int ssize = axis_domain_order.numElements();
-      for (int i = 0; i < ssize; ++i)
-        if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i))
-          ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
-                << "Grids " << this->getId() << " and " << transformGridSrc->getId()
-                << " don't have elements in the same order");
+//      int ssize = axis_domain_order.numElements();
+//      for (int i = 0; i < ssize; ++i)
+//        if (axis_domain_order(i) != (transformGridSrc->axis_domain_order)(i))
+//          ERROR("CGrid::transformGrid(CGrid* transformGridSrc)",
+//                << "Grids " << this->getId() << " and " << transformGridSrc->getId()
+//                << " don't have elements in the same order");
     }
 
@@ -1592 +1805 @@
 
   /*!
+  \brief Get the list of  axis pointers
+  \return list of axis pointers
+  */
+  std::vector<CScalar*> CGrid::getScalars()
+  {
+    std::vector<CScalar*> sList;
+    if (!scalarList_.empty())
+      for (int i =0; i < scalarList_.size(); ++i) sList.push_back(CScalar::get(scalarList_[i]));
+
+    return sList;
+  }
+
+  /*!
   \brief Set domain(s) of a grid from a list
   \param[in] domains list of domains
@@ -1647 +1873 @@
 
   /*!
+  \brief Set scalar(s) of a grid from a list
+  \param[in] scalars list of scalars
+  */
+  void CGrid::setScalarList(const std::vector<CScalar*> scalars)
+  {
+    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;
+    }
+  }
+
+  /*!
   \brief Get list of id of domains
   \return id list of domains
@@ -1666 +1919 @@
   }
 
+  /*!
+  \brief Get list of id of scalar
+  \return id list of scalar
+  */
+  std::vector<StdString> CGrid::getScalarList()
+  {
+    setScalarList();
+    return scalarList_;
+  }
+
+  /*!
+    Send all attributes of domains from client to server
+  */
   void CGrid::sendAllDomains()
   {
@@ -1677 +1943 @@
   }
 
+  /*!
+    Send all attributes of axis from client to server
+  */
   void CGrid::sendAllAxis()
   {
@@ -1689 +1958 @@
   }
 
+  /*!
+    Send all attributes of scalars from client to server
+  */
+  void CGrid::sendAllScalars()
+  {
+    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();
+    }
+  }
+
+  /*!
+    Parse a grid, for now, it contains only domain, axis and scalar
+  */
   void CGrid::parse(xml::CXMLNode& node)
   {
@@ -1697 +1984 @@
       StdString domainName("domain");
       StdString axisName("axis");
+      StdString scalarName("scalar");
       do
       {
         if (node.getElementName() == domainName) {
-          order_.push_back(true);
+          order_.push_back(2);
           this->getVirtualDomainGroup()->parseChild(node);
         }
         if (node.getElementName() == axisName) {
-          order_.push_back(false);
+          order_.push_back(1);
           this->getVirtualAxisGroup()->parseChild(node);
+        }
+        if (node.getElementName() == scalarName) {
+          order_.push_back(0);
+          this->getVirtualScalarGroup()->parseChild(node);
         }
       } while (node.goToNextElement());
@@ -1723 +2015 @@
     setDomainList();
     setAxisList();
+    setScalarList();
    }
 } // namespace xios