Changeset 540

Timestamp:

12/16/14 12:55:53 (10 years ago)

Author:

mhnguyen

Message:

Reorganizing structure of grid

+) Grid doesn't have domain_ref and axis_ref anymore.
All domain and axis of a grid must be inside grid (These domain and axis can be defined or refer to others)
+) Grid contains list of domain and axis
+) Reorder some functions to make sure new functionlities work

Test
+) On Curie
+) Mode attached and detached
+) Only test_new_features
+) Passed

Location:

XIOS/trunk

Files:

• bld.cfg (modified) (1 diff)
• src/config/axis_attribute.conf (modified) (1 diff)
• src/config/domain_attribute.conf (modified) (1 diff)
• src/config/grid_attribute.conf (modified) (1 diff)
• src/data_output.cpp (modified) (4 diffs)
• src/data_output.hpp (modified) (1 diff)
• src/declare_ref_func.hpp (added)
• src/node/axis.cpp (modified) (4 diffs)
• src/node/axis.hpp (modified) (4 diffs)
• src/node/context.cpp (modified) (7 diffs)
• src/node/domain.cpp (modified) (1 diff)
• src/node/domain.hpp (modified) (2 diffs)
• src/node/field.cpp (modified) (6 diffs)
• src/node/field.hpp (modified) (8 diffs)
• src/node/grid.cpp (modified) (9 diffs)
• src/node/grid.hpp (modified) (7 diffs)
• src/output/nc4_data_output.cpp (modified) (3 diffs)
• src/test/test_new_features.f90 (added)

XIOS/trunk/bld.cfg

@@ -31 +31 @@
 bld::target libxios.a
 #bld::target generate_fortran_interface.exe 
-bld::target xios_server.exe test_client.exe parse_xml.exe test_complete.exe test_xios_interface.exe
+bld::target xios_server.exe test_client.exe parse_xml.exe test_complete.exe test_xios_interface.exe test_new_features.exe
 bld::exe_dep
 

XIOS/trunk/src/config/axis_attribute.conf

@@ -12 +12 @@
 DECLARE_ARRAY(double, 1, value)
 
+DECLARE_ATTRIBUTE(StdString, axis_ref)
 
+

XIOS/trunk/src/config/domain_attribute.conf

@@ -62 +62 @@
 
 DECLARE_ENUM3(type,regular,curvilinear,unstructured)
+DECLARE_ATTRIBUTE(StdString, domain_ref)
 

XIOS/trunk/src/config/grid_attribute.conf

@@ -4 +4 @@
 DECLARE_ATTRIBUTE(StdString, axis_ref)
 DECLARE_ARRAY(bool, 3 , mask)
+
+// These attributes should be used privately
+// An array contains order of axis and domains composing of the grid
+DECLARE_ARRAY(int, 1 , axisDomOrder)
+//DECLARE_ARRAY(StdString, 1 , axisList)
+//DECLARE_ARRAY(StdString, 1 , domainList)

XIOS/trunk/src/data_output.cpp

@@ -16 +16 @@
       void CDataOutput::writeGrid(CGrid* grid)
       {
-         if (grid->domain_ref.isEmpty())
-            ERROR("CDataOutput::writeGrid(grid)",
-                   << " domain is not defined !");
-
-         if (grid->axis_ref.isEmpty())
-         {
-            this->writeGrid(CDomain::get(grid->domain_ref.getValue()));
-         }
-         else
-         {
-            this->writeGrid(CDomain::get(grid->domain_ref.getValue()),
-                            CAxis::get(grid->axis_ref.getValue()));
-         }
+//         if (grid->domain_ref.isEmpty())
+//            ERROR("CDataOutput::writeGrid(grid)",
+//                   << " domain is not defined !");
+//
+//         if (grid->axis_ref.isEmpty())
+//         {
+//            this->writeGrid(CDomain::get(grid->domain_ref.getValue()));
+//         }
+//         else
+//         {
+//            this->writeGrid(CDomain::get(grid->domain_ref.getValue()),
+//                            CAxis::get(grid->axis_ref.getValue()));
+//         }
+//        this->writeGrid(grid->domain, grid->axis);
+        this->writeGrid(grid->getDomains(), grid->getAxis());
       }
 
@@ -61 +63 @@
       }
 
+      void CDataOutput::writeGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis)
+      {
+        int domSize = domains.size();
+        int aSize = axis.size();
+        for (int i = 0; i < domSize; ++i) this->writeDomain_(domains[i]);
+        for (int i = 0; i < aSize; ++i) this->writeAxis_(axis[i]);
+      }
+
       //----------------------------------------------------------------
 
@@ -79 +89 @@
          CContext* context = CContext::getCurrent() ;
          boost::shared_ptr<CCalendar> calendar = context->getCalendar();
-         
+
          this->writeField_(field);
          this->writeTimeAxis_(field, calendar);
@@ -90 +100 @@
          this->writeGrid(field->getRelGrid());
       }
-      
+
       //----------------------------------------------------------------
-      
+
       void CDataOutput::writeFieldData(CField* field)
       {
-         CGrid* grid = CGrid::get(field->grid_ref.getValue());
-         CDomain* domain = CDomain::get(grid->domain_ref.getValue());
+//         CGrid* grid = CGrid::get(field->grid_ref.getValue());
+//         CDomain* domain = CDomain::get(grid->domain_ref.getValue());
          this->writeFieldData_(field);
       }
-      
+
       ///----------------------------------------------------------------
 

XIOS/trunk/src/data_output.hpp

@@ -44 +44 @@
                            CAxis*   axis);
             void writeGrid(CDomain* domain);
+            void writeGrid(std::vector<CDomain*> domain, std::vector<CAxis*> axis);
 
             virtual void writeFile_       (CFile*     file)   = 0;

XIOS/trunk/src/node/axis.cpp

@@ -9 +9 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Définitions ////////////////////// ///
 
    CAxis::CAxis(void)
       : CObjectTemplate<CAxis>()
-      , CAxisAttributes(), isChecked(false), relFiles()
+      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject()
    { /* Ne rien faire de plus */ }
 
    CAxis::CAxis(const StdString & id)
       : CObjectTemplate<CAxis>(id)
-      , CAxisAttributes(), isChecked(false), relFiles()
+      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject()
    { /* Ne rien faire de plus */ }
 
@@ -56 +56 @@
          ERROR("CAxis::checkAttributes(void)",<< "Attribut <size> of the axis must be specified") ;
       StdSize size = this->size.getValue();
-      
+
       StdSize zoom_begin,zoom_end, zoom_size ;
-      
+
       zoom_begin = (this->zoom_begin.isEmpty()) ?  1 : this->zoom_begin.getValue() ;
-      zoom_end = (this->zoom_end.isEmpty()) ?  size : this->zoom_end.getValue() ; 
+      zoom_end = (this->zoom_end.isEmpty()) ?  size : this->zoom_end.getValue() ;
       zoom_size = (this->zoom_size.isEmpty()) ?  size : this->zoom_size.getValue() ;
-      
+
       if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1 ;
       if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1 ;
       if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1 ;
-      
+
       if ( (zoom_begin < 1) || (zoom_begin > size) || (zoom_end<1) || (zoom_end>size) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
         ERROR("CAxis::checkAttributes(void)",<< "One or more attribut of <zoom_begin>, <zoom_end>, <zoom_size>, are not well specified") ;
@@ -72 +72 @@
       this->zoom_end.setValue(zoom_end) ;
       this->zoom_size.setValue(zoom_size) ;
-      
+
       StdSize true_size = value.numElements();
       if (size != true_size)
@@ -81 +81 @@
    }
 
+   DEFINE_REF_FUNC(Axis,axis)
+
    ///---------------------------------------------------------------
 

XIOS/trunk/src/node/axis.hpp

@@ -7 +7 @@
 
 #include "declare_group.hpp"
+#include "declare_ref_func.hpp"
 #include "attribute_array.hpp"
 #include "attribute_enum.hpp"
@@ -12 +13 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Déclarations ////////////////////// ///
 
@@ -65 +66 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-         
+
          static ENodeType GetType(void);
 
@@ -72 +73 @@
          bool isChecked;
          std::set<StdString> relFiles;
+
+         DECLARE_REF_FUNC(Axis,axis)
 
 

XIOS/trunk/src/node/context.cpp

@@ -353 +353 @@
    void CContext::closeDefinition(void)
    {
+
      if (hasClient)
      {
+       std::cout << "Current context " << *this << std::endl;
        // After xml is parsed, there are some more works with post processing
        postProcessing();
@@ -378 +380 @@
        sendEnabledFields();
 
+      // At last, we have all info of domain and axis, then send them
+       sendRefDomainsAxis();
+
       // After that, send all grid (if any)
        sendRefGrid();
 
-      // At last, we have all info of domain and axis, then send them
-       sendRefDomainsAxis();
+
     }
 
@@ -508 +512 @@
      // Résolution des héritages par référence au niveau des fichiers.
       const vector<CFile*> allFiles=CFile::getAll() ;
+      const vector<CGrid*> allGrids= CGrid::getAll();
 
      //if (hasClient && !hasServer)
       if (hasClient)
+      {
         for (unsigned int i = 0; i < allFiles.size(); i++)
           allFiles[i]->solveFieldRefInheritance(apply);
+      }
+
+      unsigned int vecSize = allGrids.size();
+      unsigned int i = 0;
+      for (i = 0; i < vecSize; ++i)
+        allGrids[i]->solveDomainAxisRefInheritance(apply);
+
    }
 
@@ -702 +715 @@
    {
       postProcessing();
+      std::cout << "server context " << *this << std::endl;
    }
 
@@ -848 +862 @@
        gridPtr->sendCreateChild(*it);
        CGrid::get(*it)->sendAllAttributesToServer();
+       CGrid::get(*it)->sendAllDomains();
+       CGrid::get(*it)->sendAllAxis();
      }
    }
@@ -881 +897 @@
      for (itAxis = axisIds.begin(); itAxis != itE; ++itAxis)
      {
-       axisPtr->sendCreateChild(*itAxis);
-       CAxis::get(*itAxis)->sendAllAttributesToServer();
+       if (!itAxis->empty())
+       {
+         axisPtr->sendCreateChild(*itAxis);
+         CAxis::get(*itAxis)->sendAllAttributesToServer();
+       }
      }
 
@@ -891 +910 @@
      for (itDom = domainIds.begin(); itDom != itE; ++itDom)
      {
-       domPtr->sendCreateChild(*itDom);
-       CDomain::get(*itDom)->sendAllAttributesToServer();
+       if (!itDom->empty()) {
+          domPtr->sendCreateChild(*itDom);
+          CDomain::get(*itDom)->sendAllAttributesToServer();
+       }
      }
    }

XIOS/trunk/src/node/domain.cpp

@@ -1024 +1024 @@
    //----------------------------------------------------------------
 
-
+   DEFINE_REF_FUNC(Domain,domain)
 
    ///---------------------------------------------------------------

XIOS/trunk/src/node/domain.hpp

@@ -7 +7 @@
 
 #include "declare_group.hpp"
+#include "declare_ref_func.hpp"
 #include "event_client.hpp"
 #include "event_server.hpp"
@@ -152 +153 @@
          bool isClientChecked; // Verify whether all attributes of domain on the client side is good
 
+         DECLARE_REF_FUNC(Domain,domain)
+
    }; // class CDomain
 

XIOS/trunk/src/node/field.cpp

@@ -288 +288 @@
    //----------------------------------------------------------------
 
-   /*!
-   \brief Get pointer to direct field to which the current field refers.
-   */
-   CField* CField::getDirectFieldReference(void) const
-   {
-      if (this->field_ref.isEmpty())
-         return (this->getBaseFieldReference());
-
-      if (! CField::has(this->field_ref.getValue()))
-         ERROR("CField::getDirectFieldReference(void)",
-               << "[ ref_name = " << this->field_ref.getValue() << "]"
-               << " invalid field name !");
-
-      return (CField::get(this->field_ref.getValue()));
-   }
-
-   //----------------------------------------------------------------
-
-   CField* CField::getBaseFieldReference(void) const
-   {
-      return (baseRefObject);
-   }
-
-   //----------------------------------------------------------------
-
-   const std::vector<CField*>& CField::getAllReference(void) const
-   {
-      return (refObject);
-   }
-
-   //----------------------------------------------------------------
-
-   const StdString & CField::getBaseFieldId(void) const
-   {
-      return (this->getBaseFieldReference()->getId());
-   }
-
-   //----------------------------------------------------------------
-
    const CDuration & CField::getFreqOperation(void) const
    {
@@ -345 +306 @@
    }
 
-   //----------------------------------------------------------------
-
-   bool CField::hasDirectFieldReference(void) const
-   {
-     return (!this->field_ref.isEmpty());
-   }
 
    bool CField::isActive(void) const
@@ -431 +386 @@
        active=true;
      }
-   }
-
-   /*!
-   \brief Searching for all reference of a field
-   If a field refers to (an)other field(s), we will search for all its referenced parents.
-   Moreover, if any father, direct or indirect (e.g: two levels up), has non-empty attributes,
-   all its attributes will be added to the current field
-   \param [in] apply Flag to specify whether current field uses attributes of its father
-               in case the attribute is empty (true) or its attributes are replaced by ones of its father (false)
-   */
-   void CField::solveRefInheritance(bool apply)
-   {
-      std::set<CField *> sset;
-      CField* refer_sptr;
-      CField * refer_ptr = this;
-
-      while (refer_ptr->hasDirectFieldReference())
-      {
-         refer_sptr = refer_ptr->getDirectFieldReference();
-         refer_ptr  = refer_sptr;
-
-         if(sset.end() != sset.find(refer_ptr))
-         {
-            DEBUG (<< "Circular dependency stopped for field object on "
-                   << "\"" + refer_ptr->getId() + "\" !");
-            break;
-         }
-
-         SuperClassAttribute::setAttributes(refer_ptr, apply);
-         sset.insert(refer_ptr);
-      }
-   }
-
-
-   /*!
-   \brief Only on SERVER side. Remove all field_ref from current field
-   On creating a new field on server side, redundant "field_ref" is still kept in the attribute list
-   of the current field. This function removes this from current field
-   */
-   void CField::removeRefInheritance()
-   {
-     if (this->field_ref.isEmpty()) return;
-     this->clearAttribute("field_ref");
-   }
-
-   void CField::solveBaseReference(void)
-   {
-      std::set<CField *> sset;
-      CField* refer_sptr;
-      CField * refer_ptr = this;
-
-      if (this->hasDirectFieldReference())  baseRefObject = getDirectFieldReference();
-      else  baseRefObject = CField::get(this);
-
-      while (refer_ptr->hasDirectFieldReference())
-      {
-         refer_sptr = refer_ptr->getDirectFieldReference();
-         refer_ptr  = refer_sptr;
-
-         if(sset.end() != sset.find(refer_ptr))
-         {
-            DEBUG (<< "Circular dependency stopped for field object on "
-                   << "\"" + refer_ptr->getId() + "\" !");
-            break;
-         }
-
-         sset.insert(refer_ptr);
-      }
-
-      if (hasDirectFieldReference()) baseRefObject->addReference(this) ;
    }
 
@@ -652 +537 @@
       }
 
-      if (grid_ref.isEmpty() &&  domain_ref.isEmpty())
+      if (grid_ref.isEmpty() &&  domain_ref.isEmpty() && axis_ref.isEmpty())
       {
             ERROR("CField::solveGridReference(void)",
-                  << "The horizontal domain for this field is not defined");
-
+                  << "At least one dimension must be defined for this field.");
+      }
+
+//     if (!grid_ref.isEmpty())
+//     {
+//       domain = grid->domain;
+//       axis = grid->axis;
+//     }
+
+//     CType<string> goodDomain ;
+//     CType<string> goodAxis ;
+//     if (!grid_ref.isEmpty())
+//     {
+//       if (!grid->domain_ref.isEmpty()) goodDomain=grid->domain_ref ;
+//       if (!grid->axis_ref.isEmpty()) goodAxis=grid->axis_ref ;
+//     }
+//     if (!domain_ref.isEmpty()) goodDomain=domain_ref ;
+//     if (!axis_ref.isEmpty()) goodAxis=axis_ref ;
+
+//     CArray<std::string,1> domListTmp = grid->domainList.getValue();
+//     CArray<std::string,1> axisListTmp = grid->axisList.getValue();
+
+     std::vector<std::string> domList, axisList;
+     if (0 != grid)
+     {
+       domList = grid->getDomainList();
+       axisList = grid->getAxisList();
      }
 
-     CType<string> goodDomain ;
-     CType<string> goodAxis ;
-     if (!grid_ref.isEmpty())
+     if (domList.empty() && axisList.empty())
      {
-       if (!grid->domain_ref.isEmpty()) goodDomain=grid->domain_ref ;
-       if (!grid->axis_ref.isEmpty()) goodAxis=grid->axis_ref ;
+       std::vector<CDomain*> vecDom;
+       if (0 != domain) vecDom.push_back(domain);
+       std::vector<CAxis*> vecAxis;
+       if (0 != axis) vecAxis.push_back(axis);
+       this->grid = CGrid::createGrid(vecDom, vecAxis);
      }
-     if (!domain_ref.isEmpty()) goodDomain=domain_ref ;
-     if (!axis_ref.isEmpty()) goodAxis=axis_ref ;
-
-
-     if (goodDomain.isEmpty())
-     {
-       ERROR("CField::solveGridReference(void)", << "The horizontal domain for this field is not defined");
-     }
-     else
-     {
-       if (CDomain::has(goodDomain)) domain = CDomain::get(goodDomain) ;
-       else ERROR("CField::solveGridReference(void)",<< "Reference to the domain \'"<<goodDomain.get() << "\' is wrong") ;
-     }
-
-     if (!goodAxis.isEmpty())
-     {
-       if (CAxis::has(goodAxis))  axis = CAxis::get(goodAxis) ;
-       else  ERROR("CField::solveGridReference(void)", << "Reference to the axis \'"
-                  << goodAxis.get() <<"\' is wrong") ;
-     }
-
-     bool nothingToDo=false ;
-
-     if (!grid_ref.isEmpty())
-     {
-       if (!grid->domain_ref.isEmpty() && goodDomain.get() == grid->domain_ref.get())
-         if (goodAxis.isEmpty()) nothingToDo=true ;
-         else if (!grid->axis_ref.isEmpty())
-                 if (grid->axis_ref.get()==goodAxis.get()) nothingToDo=true ;
-     }
-
-     if (!nothingToDo)
-     {
-       if (!goodAxis.isEmpty())
-       {
-         this->grid = CGrid::createGrid(domain, axis) ;
-         this->grid_ref.setValue(this->grid->getId());
-       }
-       else
-       {
-         this->grid = CGrid::createGrid(domain) ;
-         this->grid_ref.setValue(this->grid->getId());
-       }
-     }
+
+//     std::string goodDomain = domListTmp[0];
+//     std::string goodAxis = axisListTmp[0];
+
+//     if (goodDomain.isEmpty())
+//     if (goodDomain.empty())
+//     {
+//       ERROR("CField::solveGridReference(void)", << "The horizontal domain for this field is not defined");
+//     }
+//     else
+//     {
+//       if (CDomain::has(goodDomain)) domain = CDomain::get(goodDomain) ;
+//       else ERROR("CField::solveGridReference(void)",<< "Reference to the domain \'"
+//                  <<goodDomain << "\' is wrong") ;
+////                  <<goodDomain.get() << "\' is wrong") ;
+//     }
+//
+////     if (!goodAxis.isEmpty())
+//     if (!goodAxis.empty())
+//     {
+//       if (CAxis::has(goodAxis))  axis = CAxis::get(goodAxis) ;
+//       else  ERROR("CField::solveGridReference(void)", << "Reference to the axis \'"
+//                  << goodAxis <<"\' is wrong") ;
+//                  << goodAxis.get() <<"\' is wrong") ;
+//     }
+
+//     bool nothingToDo=false ;
+//
+//     if (!grid_ref.isEmpty())
+//     {
+//       if (!grid->domain_ref.isEmpty() && goodDomain.get() == grid->domain_ref.get())
+//         if (goodAxis.isEmpty()) nothingToDo=true ;
+//         else if (!grid->axis_ref.isEmpty())
+//                 if (grid->axis_ref.get()==goodAxis.get()) nothingToDo=true ;
+//     }
+//
+//     nothingToDo = true;
+//     if (!nothingToDo)
+//     {
+//       if (!goodAxis.isEmpty())
+//       {
+//         this->grid = CGrid::createGrid(domain, axis) ;
+//         this->grid_ref.setValue(this->grid->getId());
+//       }
+//       else
+//       {
+//         this->grid = CGrid::createGrid(domain) ;
+//         this->grid_ref.setValue(this->grid->getId());
+//       }
+//     }
 
 //     grid->solveReference() ;
@@ -803 +720 @@
     }
     return &instantData ;
-  }
-
-  void CField::addReference(CField* field)
-  {
-    refObject.push_back(field) ;
   }
 
@@ -1047 +959 @@
    }
 
-
-
+   DEFINE_REF_FUNC(Field,field)
+
+//  void CField::addReference(CField* field)
+//  {
+//    refObject.push_back(field) ;
+//  }
+//
+//   //----------------------------------------------------------------
+//
+//   bool CField::hasDirectFieldReference(void) const
+//   {
+//     return (!this->field_ref.isEmpty());
+//   }
+//
+//   //----------------------------------------------------------------
+//
+//   const StdString & CField::getBaseFieldId(void) const
+//   {
+//      return (this->getBaseFieldReference()->getId());
+//   }
+//
+//
+//   //----------------------------------------------------------------
+//
+//   /*!
+//   \brief Get pointer to direct field to which the current field refers.
+//   */
+//   CField* CField::getDirectFieldReference(void) const
+//   {
+//      if (this->field_ref.isEmpty())
+//         return (this->getBaseFieldReference());
+//
+//      if (! CField::has(this->field_ref.getValue()))
+//         ERROR("CField::getDirectFieldReference(void)",
+//               << "[ ref_name = " << this->field_ref.getValue() << "]"
+//               << " invalid field name !");
+//
+//      return (CField::get(this->field_ref.getValue()));
+//   }
+//
+//   //----------------------------------------------------------------
+//
+//   CField* CField::getBaseFieldReference(void) const
+//   {
+//      return (baseRefObject);
+//   }
+//
+//   //----------------------------------------------------------------
+//
+//   const std::vector<CField*>& CField::getAllReference(void) const
+//   {
+//      return (refObject);
+//   }
+//
+//
+//   /*!
+//   \brief Searching for all reference of a field
+//   If a field refers to (an)other field(s), we will search for all its referenced parents.
+//   Moreover, if any father, direct or indirect (e.g: two levels up), has non-empty attributes,
+//   all its attributes will be added to the current field
+//   \param [in] apply Flag to specify whether current field uses attributes of its father
+//               in case the attribute is empty (true) or its attributes are replaced by ones of its father (false)
+//   */
+//   void CField::solveRefInheritance(bool apply)
+//   {
+//      std::set<CField *> sset;
+//      CField* refer_sptr;
+//      CField * refer_ptr = this;
+//
+//      while (refer_ptr->hasDirectFieldReference())
+//      {
+//         refer_sptr = refer_ptr->getDirectFieldReference();
+//         refer_ptr  = refer_sptr;
+//
+//         if(sset.end() != sset.find(refer_ptr))
+//         {
+//            DEBUG (<< "Circular dependency stopped for field object on "
+//                   << "\"" + refer_ptr->getId() + "\" !");
+//            break;
+//         }
+//
+//         SuperClassAttribute::setAttributes(refer_ptr, apply);
+//         sset.insert(refer_ptr);
+//      }
+//   }
+//
+//   /*!
+//   \brief Only on SERVER side. Remove all field_ref from current field
+//   On creating a new field on server side, redundant "field_ref" is still kept in the attribute list
+//   of the current field. This function removes this from current field
+//   */
+//   void CField::removeRefInheritance()
+//   {
+//     if (this->field_ref.isEmpty()) return;
+//     this->clearAttribute("field_ref");
+//   }
+//
+//   void CField::solveBaseReference(void)
+//   {
+//      std::set<CField *> sset;
+//      CField* refer_sptr;
+//      CField * refer_ptr = this;
+//
+//      if (this->hasDirectFieldReference())  baseRefObject = getDirectFieldReference();
+//      else  baseRefObject = CField::get(this);
+//
+//      while (refer_ptr->hasDirectFieldReference())
+//      {
+//         refer_sptr = refer_ptr->getDirectFieldReference();
+//         refer_ptr  = refer_sptr;
+//
+//         if(sset.end() != sset.find(refer_ptr))
+//         {
+//            DEBUG (<< "Circular dependency stopped for field object on "
+//                   << "\"" + refer_ptr->getId() + "\" !");
+//            break;
+//         }
+//
+//         sset.insert(refer_ptr);
+//      }
+//
+//      if (hasDirectFieldReference()) baseRefObject->addReference(this) ;
+//   }
+//
 
 } // namespace xios

XIOS/trunk/src/node/field.hpp

@@ -14 +14 @@
 #include "attribute_array.hpp"
 #include "expr_node.hpp"
-//#include "context.hpp"
+#include "declare_ref_func.hpp"
 
 
@@ -64 +64 @@
 
          /// Accesseurs ///
-         CField* getDirectFieldReference(void) const;
-         CField* getBaseFieldReference(void)   const;
-         void addReference(CField* field) ;
-         const std::vector<CField*> & getAllReference(void) const;
 
          CGrid* getRelGrid(void) const ;
@@ -86 +82 @@
          CArray<double, 1> getData(void) const;
 
-         const StdString & getBaseFieldId(void) const;
+
 
          /// Mutateur ///
@@ -104 +100 @@
 
        public :
-
-         /// Test ///
-         bool hasDirectFieldReference(void) const;
          bool isActive(void) const;
          bool active ;
@@ -114 +107 @@
          /// Traitements ///
          void processEnabledField(void) ;
-         void solveRefInheritance(bool apply);
-         void solveBaseReference(void);
+
          void solveGridReference(void);
          void solveOperation(void);
@@ -122 +114 @@
          void buildAllExpressionEnabledField();
          void solveGridDomainAxisRef(bool checkAtt);
-         void removeRefInheritance();  // Remove all reference of current field (it refers to itself)
+
 
 //         virtual void fromBinary(StdIStream & is);
@@ -166 +158 @@
         const std::pair<StdString, StdString>& getDomainAxisIds();
       public :
-
          /// Propriétés privées ///
          CVariableGroup* vVariableGroup ;
 
-         std::vector<CField*> refObject;
-         CField* baseRefObject;
          CGrid*  grid ;
          CFile*  file;
@@ -208 +197 @@
          bool areAllExpressionBuilt;
          std::pair<StdString,StdString> domAxisIds_;
+         DECLARE_REF_FUNC(Field,field)
+//       public:
+//         bool hasDirectFieldReference(void) const;
+//         CField* getDirectFieldReference(void) const;
+//         CField* getBaseFieldReference(void) const;
+//         void addReference(CField* field);
+//         const std::vector<CField*> & getAllReference(void) const;
+//void solveRefInheritance(bool apply);
+//void solveBaseReference(void);
+//         void removeRefInheritance();
+//         const StdString & getBaseFieldId(void) const;
+//
+//         std::vector<CField*> refObject;
+//         CField* baseRefObject;
+
 
    }; // class CField

XIOS/trunk/src/node/grid.cpp

@@ -21 +21 @@
       , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain()
       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
-   { /* Ne rien faire de plus */ }
+      , vDomainGroup_(), vAxisGroup_(), axisOrder_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+   {
+     setVirtualDomainGroup();
+     setVirtualAxisGroup();
+   }
 
    CGrid::CGrid(const StdString & id)
@@ -27 +31 @@
       , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain()
       , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
-   { /* Ne rien faire de plus */ }
+      , vDomainGroup_(), vAxisGroup_(), axisOrder_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+   {
+     setVirtualDomainGroup();
+     setVirtualAxisGroup();
+   }
 
    CGrid::~CGrid(void)
@@ -317 +325 @@
    void CGrid::solveDomainRef(bool sendAtt)
    {
-      if (!domain_ref.isEmpty())
-      {
-         if (CDomain::has(domain_ref.getValue()))
-         {
-            this->domain = CDomain::get(domain_ref.getValue()) ;
-            if (sendAtt) domain->sendCheckedAttributes();
-            else domain->checkAttributesOnClient() ;
-         }
-         else ERROR("CGrid::solveDomainRef(void)",
-                     << "Wrong domain reference") ;
+//      if (!domain_ref.isEmpty())
+//      {
+//         if (CDomain::has(domain_ref.getValue()))
+//         {
+//            this->domain = CDomain::get(domain_ref.getValue()) ;
+//            if (sendAtt) domain->sendCheckedAttributes();
+//            else domain->checkAttributesOnClient() ;
+//         }
+//         else ERROR("CGrid::solveDomainRef(void)",
+//                     << "Wrong domain reference") ;
+//      }
+//      else ERROR("CGrid::solveDomainRef(void)",
+//                  << "Domain reference is not defined") ;
+      setDomainList();
+      this->domain = CDomain::get(domList_.at(0));
+      if (0 != this->domain)
+      {
+//        this->domain = this->getDomain();
+        if (sendAtt) domain->sendCheckedAttributes();
+        else domain->checkAttributesOnClient() ;
       }
       else ERROR("CGrid::solveDomainRef(void)",
@@ -336 +354 @@
    void CGrid::solveAxisRef(bool checkAtt)
    {
-      if (!axis_ref.isEmpty())
-      {
-         this->withAxis = true ;
-         if (CAxis::get(axis_ref.getValue()))
-         {
-            this->axis = CAxis::get(axis_ref.getValue()) ;
-            axis->checkAttributes() ;
-         }
-         else ERROR("CGrid::solveAxisRef(void)",
-                    << "Wrong axis reference") ;
-      }
+//      if (!axis_ref.isEmpty())
+//      {
+//         this->withAxis = true ;
+//         if (CAxis::get(axis_ref.getValue()))
+//         {
+//            this->axis = CAxis::get(axis_ref.getValue()) ;
+//            axis->checkAttributes() ;
+//         }
+//         else ERROR("CGrid::solveAxisRef(void)",
+//                    << "Wrong axis reference") ;
+//      }
+//      else withAxis = false ;
+//      getAllAxis();
+      setAxisList();
+      if (!axisList_.empty())
+      {
+        int sizeList = axisList_.size();
+        for (int i = 0; i < sizeList; ++i)
+        {
+          CAxis::get(axisList_.at(i))->checkAttributes();
+          this->axis = CAxis::get(axisList_.at(i));
+        }
+        withAxis = true;
+
+      }
+//      if (!axis_ref.isEmpty())
+//      {
+//         this->withAxis = true ;
+//         if (CAxis::get(axis_ref.getValue()))
+//         {
+//            this->axis = CAxis::get(axis_ref.getValue()) ;
+//            axis->checkAttributes() ;
+//         }
+//         else ERROR("CGrid::solveAxisRef(void)",
+//                    << "Wrong axis reference") ;
+//      }
       else withAxis = false ;
    }
@@ -445 +488 @@
       StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
       CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
-      grid->domain_ref.setValue(domain->getId());
+
+      std::vector<CDomain*> vecDom(1,domain);
+      grid->setDomainList(vecDom);
+//      grid->domain_ref.setValue(domain->getId());
       return (grid);
    }
@@ -454 +500 @@
                          StdString("_") + axis->getId() + StdString("__") ;
       CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
-      grid->domain_ref.setValue(domain->getId());
-      grid->axis_ref.setValue(axis->getId());
+
+      std::vector<CDomain*> vecDom(1,domain);
+      std::vector<CAxis*> vecAxis(1,axis);
+      grid->setDomainList(vecDom);
+      grid->setAxisList(vecAxis);
+//      grid->domain_ref.setValue(domain->getId());
+//      grid->axis_ref.setValue(axis->getId());
       return (grid);
+   }
+
+   CGrid* CGrid::createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis)
+   {
+      StdString new_id = StdString("__");
+      if (!domains.empty()) for (int i = 0; i < domains.size(); ++i) new_id += domains[i]->getId() + StdString("_");
+      if (!axis.empty()) for (int i = 0; i < axis.size(); ++i) new_id += axis[i]->getId() + StdString("_") ;
+      new_id += StdString("_");
+
+      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
+      grid->setDomainList(domains);
+      grid->setAxisList(axis);
+      return (grid);
+   }
+
+   CDomainGroup* CGrid::getVirtualDomainGroup() const
+   {
+     return (this->vDomainGroup_);
+   }
+
+   CAxisGroup* CGrid::getVirtualAxisGroup() const
+   {
+     return (this->vAxisGroup_);
    }
 
@@ -679 +753 @@
   }
 
+   /*!
+   \brief Dispatch event received from client
+      Whenever a message is received in buffer of server, it will be processed depending on
+   its event type. A new event type should be added in the switch list to make sure
+   it processed on server side.
+   \param [in] event: Received message
+   */
   bool CGrid::dispatchEvent(CEventServer& event)
   {
@@ -692 +773 @@
           break ;
 
+         case EVENT_ID_ADD_DOMAIN :
+           recvAddDomain(event) ;
+           return true ;
+           break ;
+
+         case EVENT_ID_ADD_AXIS :
+           recvAddAxis(event) ;
+           return true ;
+           break ;
         default :
           ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
@@ -724 +814 @@
    ///---------------------------------------------------------------
 
+   CDomain* CGrid::addDomain(const std::string& id)
+   {
+     return vDomainGroup_->createChild(id) ;
+   }
+
+   CAxis* CGrid::addAxis(const std::string& id)
+   {
+     return vAxisGroup_->createChild(id) ;
+   }
+
+   //! Change virtual field group to a new one
+   void CGrid::setVirtualDomainGroup(CDomainGroup* newVDomainGroup)
+   {
+      this->vDomainGroup_ = newVDomainGroup;
+   }
+
+   //! Change virtual variable group to new one
+   void CGrid::setVirtualAxisGroup(CAxisGroup* newVAxisGroup)
+   {
+      this->vAxisGroup_ = newVAxisGroup;
+   }
+
+   //----------------------------------------------------------------
+   //! Create virtual field group, which is done normally on initializing file
+   void CGrid::setVirtualDomainGroup(void)
+   {
+      this->setVirtualDomainGroup(CDomainGroup::create());
+   }
+
+   //! Create virtual variable group, which is done normally on initializing file
+   void CGrid::setVirtualAxisGroup(void)
+   {
+      this->setVirtualAxisGroup(CAxisGroup::create());
+   }
+
+   /*!
+   \brief Send a message to create a domain on server side
+   \param[in] id String identity of domain that will be created on server
+   */
+   void CGrid::sendAddDomain(const string& id)
+   {
+    CContext* context=CContext::getCurrent() ;
+
+    if (! context->hasServer )
+    {
+       CContextClient* client=context->client ;
+
+       CEventClient event(this->getType(),EVENT_ID_ADD_DOMAIN) ;
+       if (client->isServerLeader())
+       {
+         CMessage msg ;
+         msg<<this->getId() ;
+         msg<<id ;
+         event.push(client->getServerLeader(),1,msg) ;
+         client->sendEvent(event) ;
+       }
+       else client->sendEvent(event) ;
+    }
+   }
+
+   /*!
+   \brief Send a message to create an axis on server side
+   \param[in] id String identity of axis that will be created on server
+   */
+   void CGrid::sendAddAxis(const string& id)
+   {
+    CContext* context=CContext::getCurrent() ;
+
+    if (! context->hasServer )
+    {
+       CContextClient* client=context->client ;
+
+       CEventClient event(this->getType(),EVENT_ID_ADD_AXIS) ;
+       if (client->isServerLeader())
+       {
+         CMessage msg ;
+         msg<<this->getId() ;
+         msg<<id ;
+         event.push(client->getServerLeader(),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
+   */
+   void CGrid::recvAddDomain(CEventServer& event)
+   {
+
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id ;
+      get(id)->recvAddDomain(*buffer) ;
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of a domain on server side
+   \param[in] buffer Buffer containing message
+   */
+   void CGrid::recvAddDomain(CBufferIn& buffer)
+   {
+      string id ;
+      buffer>>id ;
+      addDomain(id) ;
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of an axis on server side
+   \param[in] event Received event
+   */
+   void CGrid::recvAddAxis(CEventServer& event)
+   {
+
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id ;
+      get(id)->recvAddAxis(*buffer) ;
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of an axis on server side
+   \param[in] buffer Buffer containing message
+   */
+   void CGrid::recvAddAxis(CBufferIn& buffer)
+   {
+      string id ;
+      buffer>>id ;
+      addAxis(id) ;
+   }
+
+  void CGrid::solveDomainAxisRefInheritance(bool apply)
+  {
+    CContext* context = CContext::getCurrent();
+    unsigned int vecSize, i;
+    std::vector<StdString>::iterator it, itE;
+    setDomainList();
+    it = domList_.begin(); itE = domList_.end();
+    for (; it != itE; ++it)
+    {
+      CDomain* pDom = CDomain::get(*it);
+      if (context->hasClient)
+      {
+        pDom->solveRefInheritance(apply);
+        pDom->solveBaseReference();
+        if ((!pDom->domain_ref.isEmpty()) && (pDom->name.isEmpty()))
+          pDom->name.setValue(pDom->getBaseDomainReference()->getId());
+
+      }
+    }
+
+    setAxisList();
+    it = axisList_.begin(); itE = axisList_.end();
+    for (; it != itE; ++it)
+    {
+      CAxis* pAxis = CAxis::get(*it);
+      if (context->hasClient)
+      {
+        pAxis->solveRefInheritance(apply);
+        pAxis->solveBaseReference();
+        if ((!pAxis->axis_ref.isEmpty()) && (pAxis->name.isEmpty()))
+          pAxis->name.setValue(pAxis->getBaseAxisReference()->getId());
+      }
+    }
+  }
+
+  std::vector<CDomain*> CGrid::getDomains()
+  {
+    std::vector<CDomain*> domList;
+    if (!domList_.empty())
+    {
+      for (int i = 0; i < domList_.size(); ++i) domList.push_back(CDomain::get(domList_[i]));
+    }
+    return domList;
+  }
+
+  std::vector<CAxis*> CGrid::getAxis()
+  {
+    std::vector<CAxis*> aList;
+    if (!axisList_.empty())
+      for (int i =0; i < axisList_.size(); ++i) aList.push_back(CAxis::get(axisList_[i]));
+
+    return aList;
+  }
+
+  void CGrid::setDomainList(const std::vector<CDomain*> domains)
+  {
+    if (isDomListSet) return;
+    std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
+    if (!domains.empty() && domList.empty()) domList = domains;
+    if (!domList.empty())
+    {
+      int sizeDom = domList.size();
+      domList_.resize(sizeDom);
+      for (int i = 0 ; i < sizeDom; ++i)
+      {
+        domList_[i] = domList[i]->getId();
+      }
+      isDomListSet = true;
+    }
+
+  }
+
+  void CGrid::setAxisList(const std::vector<CAxis*> axis)
+  {
+    if (isAxisListSet) return;
+    std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
+    if (!axis.empty() && aList.empty()) aList = axis;
+    if (!aList.empty())
+    {
+      int sizeAxis = aList.size();
+      axisList_.resize(sizeAxis);
+      for (int i = 0; i < sizeAxis; ++i)
+      {
+        axisList_[i] = aList[i]->getId();
+      }
+      isAxisListSet = true;
+    }
+  }
+
+  std::vector<StdString> CGrid::getDomainList()
+  {
+    setDomainList();
+    return domList_;
+  }
+
+  std::vector<StdString> CGrid::getAxisList()
+  {
+    setAxisList();
+    return axisList_;
+  }
+
+  void CGrid::sendAllDomains()
+  {
+    std::vector<CDomain*> domList = this->getVirtualDomainGroup()->getAllChildren();
+    int dSize = domList.size();
+    for (int i = 0; i < dSize; ++i)
+    {
+      sendAddDomain(domList[i]->getId());
+      domList[i]->sendAllAttributesToServer();
+    }
+  }
+
+  void CGrid::sendAllAxis()
+  {
+    std::vector<CAxis*> aList = this->getVirtualAxisGroup()->getAllChildren();
+    int aSize = aList.size();
+
+    for (int i = 0; i < aSize; ++i)
+    {
+      sendAddAxis(aList[i]->getId());
+      aList[i]->sendAllAttributesToServer();
+    }
+  }
+
+  void CGrid::parse(xml::CXMLNode & node)
+  {
+    SuperClass::parse(node);
+
+    if (node.goToChildElement())
+    {
+      int domainIdx = -1;
+      int posAxis = 0;
+      StdString domainName("domain");
+      StdString axisName("axis");
+      do
+      {
+        if (node.getElementName() == domainName) {
+          axisOrder_.push_back(domainIdx);
+          this->getVirtualDomainGroup()->parseChild(node);
+        }
+        if (node.getElementName() == axisName) {
+          axisOrder_.push_back(posAxis);
+          ++posAxis;
+          this->getVirtualAxisGroup()->parseChild(node);
+        }
+      } while (node.goToNextElement()) ;
+      node.goToParentElement();
+    }
+
+    if (!axisOrder_.empty())
+    {
+      int sizeOrd = axisOrder_.size();
+      axisDomOrder.resize(sizeOrd);
+      for (int i = 0; i < sizeOrd; ++i)
+      {
+        axisDomOrder(i) = axisOrder_[i];
+      }
+    }
+
+    setDomainList();
+    setAxisList();
+   }
+
 } // namespace xios

XIOS/trunk/src/node/grid.hpp

@@ -18 +18 @@
    class CGridGroup;
    class CGridAttributes;
+   class CDomainGroup;
+   class CAxisGroup;
    class CGrid;
 
@@ -44 +46 @@
          enum EEventId
          {
-           EVENT_ID_INDEX
+           EVENT_ID_INDEX, EVENT_ID_ADD_DOMAIN, EVENT_ID_ADD_AXIS
          } ;
 
@@ -96 +98 @@
          void outputField(int rank, const CArray<double,1>& stored,  CArray<double,1>& field)  ;
 
+         virtual void parse(xml::CXMLNode & node);
+
          /// Destructeur ///
          virtual ~CGrid(void);
@@ -110 +114 @@
          static CGrid* createGrid(CDomain* domain);
          static CGrid* createGrid(CDomain* domain, CAxis* axis);
+         static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis);
 
       public :
@@ -124 +129 @@
          void solveDomainRef(bool checkAtt);
          void solveAxisRef(bool checkAtt);
+         void solveDomainAxisRefInheritance(bool apply = true);
+
+         void sendAddDomain(const std::string& id="");
+         void sendAddAxis(const std::string& id="");
+         void sendAllDomains();
+         void sendAllAxis();
+
+         static void recvAddDomain(CEventServer& event) ;
+         void recvAddDomain(CBufferIn& buffer) ;
+         static void recvAddAxis(CEventServer& event) ;
+         void recvAddAxis(CBufferIn& buffer) ;
 
          static bool dispatchEvent(CEventServer& event) ;
@@ -134 +150 @@
          std::map<int, int> getDomConServerSide();
          std::map<int, StdSize> getConnectedServerDataSize();
+         std::vector<StdString> getDomainList();
+         std::vector<StdString> getAxisList();
+         std::vector<CDomain*> getDomains();
+         std::vector<CAxis*> getAxis();
+
       public:
 
@@ -167 +188 @@
          std::map<int, int> domConnectedServerSide_;
          bool isDomConServerComputed_;
+
+      private:
+        void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
+        void setVirtualDomainGroup();
+        void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
+        void setVirtualAxisGroup();
+//        void setAxisList();
+        void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
+//        void setDomainList();
+        void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
+
+        CDomain* addDomain(const std::string& id);
+        CAxis* addAxis(const std::string& id);
+
+        CAxisGroup* getVirtualAxisGroup() const;
+        CDomainGroup* getVirtualDomainGroup() const;
+      private:
+        CDomainGroup* vDomainGroup_;
+        CAxisGroup* vAxisGroup_;
+        std::vector<std::string> axisList_, domList_;
+        bool isAxisListSet, isDomListSet;
+
+        // List order of axis in a grid, if there is a domain, it will take value -1
+        std::vector<int> axisOrder_;
    }; // class CGrid
 

XIOS/trunk/src/output/nc4_data_output.cpp

@@ -489 +489 @@
          std::vector<StdString> dims;
          StdString axisid = (!axis->name.isEmpty())
-                           ? axis->name.getValue() : axis->getId();
+                             ? axis->name.getValue() : axis->getId();
          try
          {
@@ -504 +504 @@
 
                  SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid);
+
+                 if (!axis->name.isEmpty())
+                    SuperClassWriter::addAttribute
+                       ("name", axis->name.getValue(), &axisid);
 
                  if (!axis->standard_name.isEmpty())
@@ -644 +648 @@
          }
 
-         if (!grid->axis_ref.isEmpty())
-         {
-            CAxis* axis = grid->axis ;
-            StdString axisid = (!axis->name.isEmpty()) ? axis->name.getValue() : axis->getId();
-            dims.push_back(axisid);
-            coodinates.push_back(axisid);
+         std::vector<StdString> axisList = grid->getAxisList();
+         if (!axisList.empty())
+         {
+           std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end();
+           for (; itAxis != iteAxis; ++itAxis)
+           {
+             CAxis* axis = CAxis::get(*itAxis);
+             StdString axisid = (!axis->name.isEmpty())
+                                ? axis->name.getValue() : axis->getId();
+
+             dims.push_back(axisid);
+             coodinates.push_back(axisid);
+           }
          }