Changeset 509 for XIOS/trunk/src/node

Timestamp:

11/13/14 15:09:14 (10 years ago)

Author:

mhnguyen

Message:

Implementing buffer size auto-detection for mode client -server

+) Process xml tree in client side then send all the information to server
+) Only information enabled fields in enabled files are sent to server
+) Some important change in structure of code which must be refactored

Test
+) On Curie
+) Only mode client-server
+) Passed for all tests

Location:

XIOS/trunk/src/node

Files:

• context.cpp (modified) (29 diffs)
• context.hpp (modified) (6 diffs)
• domain.cpp (modified) (49 diffs)
• domain.hpp (modified) (10 diffs)
• field.cpp (modified) (62 diffs)
• field.hpp (modified) (12 diffs)
• file.cpp (modified) (50 diffs)
• file.hpp (modified) (8 diffs)
• grid.cpp (modified) (31 diffs)
• grid.hpp (modified) (12 diffs)

XIOS/trunk/src/node/context.cpp

@@ -16 +16 @@
 
 namespace xios {
-  
+
   shared_ptr<CContextGroup> CContext::root ;
-   
+
    /// ////////////////////// Définitions ////////////////////// ///
 
    CContext::CContext(void)
       : CObjectTemplate<CContext>(), CContextAttributes()
-      , calendar(),hasClient(false),hasServer(false)
+      , calendar(),hasClient(false),hasServer(false), isPostProcessed(false), dataSize_()
    { /* Ne rien faire de plus */ }
 
    CContext::CContext(const StdString & id)
       : CObjectTemplate<CContext>(id), CContextAttributes()
-      , calendar(),hasClient(false),hasServer(false)
+      , calendar(),hasClient(false),hasServer(false), isPostProcessed(false), dataSize_()
    { /* Ne rien faire de plus */ }
 
    CContext::~CContext(void)
-   { 
+   {
      if (hasClient) delete client ;
      if (hasServer) delete server ;
@@ -38 +38 @@
 
    //----------------------------------------------------------------
-
+   //! Get name of context
    StdString CContext::GetName(void)   { return (StdString("context")); }
    StdString CContext::GetDefName(void){ return (CContext::GetName()); }
@@ -44 +44 @@
 
    //----------------------------------------------------------------
-
+   /*!
+   \brief Get context group (context root)
+   \return Context root
+   */
    CContextGroup* CContext::getRoot(void)
-   {  
+   {
       if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())) ;
-      return root.get(); 
-   }
-   
-
-   //----------------------------------------------------------------
-
+      return root.get();
+   }
+
+
+   //----------------------------------------------------------------
+   /*!
+   \brief Get calendar of a context
+   \return Calendar
+   */
    boost::shared_ptr<CCalendar> CContext::getCalendar(void) const
    {
       return (this->calendar);
    }
-   
-   //----------------------------------------------------------------
-   
+
+   //----------------------------------------------------------------
+   /*!
+   \brief Set a context with a calendar
+   \param[in] newCalendar new calendar
+   */
    void CContext::setCalendar(boost::shared_ptr<CCalendar> newCalendar)
    {
@@ -67 +76 @@
       start_date.setValue(this->calendar->getInitDate().toString());
    }
-   
-   //----------------------------------------------------------------
-
+
+   //----------------------------------------------------------------
+   //! Process all information of calendar
    void CContext::solveCalendar(void)
    {
@@ -97 +106 @@
             << "The calendar is not defined !");
    }
-   
-   //----------------------------------------------------------------
-
+
+   //----------------------------------------------------------------
+   /*!
+   \brief Parse xml file and write information into context object
+   \param [in] node xmld node corresponding in xml file
+   */
    void CContext::parse(xml::CXMLNode & node)
    {
@@ -135 +147 @@
 
             if (attributes.end() != attributes.find("id"))
-            { DEBUG(<< "Definition node has an id,"
-                    << "it will not be taking account !"); }
+            {
+              DEBUG(<< "Definition node has an id,"
+                    << "it will not be taking account !");
+            }
 
 #define DECLARE_NODE(Name_, name_)    \
@@ -155 +169 @@
 
    //----------------------------------------------------------------
-
+   //! Show tree structure of context
    void CContext::ShowTree(StdOStream & out)
    {
@@ -166 +180 @@
       out << "<? xml version=\"1.0\" ?>" << std::endl;
       out << "<"  << xml::CXMLNode::GetRootName() << " >" << std::endl;
-      
+
       for (; it != end; it++)
       {
-         CContext* context = *it;         
-         CContext::setCurrent(context->getId());         
+         CContext* context = *it;
+         CContext::setCurrent(context->getId());
          out << *context << std::endl;
       }
-      
+
       out << "</" << xml::CXMLNode::GetRootName() << " >" << std::endl;
-      CContext::setCurrent(currentContextId);  
-   }
-   
-
-   //----------------------------------------------------------------
-
+      CContext::setCurrent(currentContextId);
+   }
+
+
+   //----------------------------------------------------------------
+
+   //! Convert context object into string (to print)
    StdString CContext::toString(void) const
    {
@@ -209 +224 @@
    //----------------------------------------------------------------
 
+   /*!
+   \brief Find all inheritace among objects in a context.
+   \param [in] apply (true) write attributes of parent into ones of child if they are empty
+                     (false) write attributes of parent into a new container of child
+   \param [in] parent unused
+   */
    void CContext::solveDescInheritance(bool apply, const CAttributeMap * const UNUSED(parent))
    {
@@ -220 +241 @@
    //----------------------------------------------------------------
 
+   //! Verify if all root definition in the context have child.
    bool CContext::hasChild(void) const
    {
@@ -230 +252 @@
 }
 
-   //----------------------------------------------------------------
-
-   void CContext::solveFieldRefInheritance(bool apply)
-   {
-      if (!this->hasId()) return;
-      vector<CField*> allField = CField::getAll() ;
-//              = CObjectTemplate<CField>::GetAllVectobject(this->getId());
-      std::vector<CField*>::iterator 
-         it = allField.begin(), end = allField.end();
-            
-      for (; it != end; it++)
-      {
-         CField* field = *it;
-         field->solveRefInheritance(apply);
-      }
-   }
+//   //----------------------------------------------------------------
+//
+//   void CContext::solveFieldRefInheritance(bool apply)
+//   {
+//      if (!this->hasId()) return;
+//      vector<CField*> allField = CField::getAll() ;
+////              = CObjectTemplate<CField>::GetAllVectobject(this->getId());
+//      std::vector<CField*>::iterator
+//         it = allField.begin(), end = allField.end();
+//
+//      for (; it != end; it++)
+//      {
+//         CField* field = *it;
+//         field->solveRefInheritance(apply);
+//      }
+//   }
 
    //----------------------------------------------------------------
@@ -256 +278 @@
    }
    ///---------------------------------------------------------------
-   
+
+   //! Initialize client side
    void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm)
    {
      hasClient=true ;
      client = new CContextClient(this,intraComm, interComm) ;
-   } 
-
+   }
+
+   void CContext::setClientServerBuffer()
+   {
+     if (hasClient)
+     {
+       client->setBufferSize(getDataSize());
+     }
+   }
+
+   //! Verify whether a context is initialized
    bool CContext::isInitialized(void)
    {
      return hasClient ;
    }
-    
+
+   //! Initialize server
    void CContext::initServer(MPI_Comm intraComm,MPI_Comm interComm)
    {
      hasServer=true ;
      server = new CContextServer(this,intraComm,interComm) ;
-   } 
-
+   }
+
+   //! Server side: Put server into a loop in order to listen message from client
    bool CContext::eventLoop(void)
    {
      return server->eventLoop() ;
-   } 
-   
+   }
+
+   //! Terminate a context
    void CContext::finalize(void)
    {
@@ -290 +325 @@
       }
    }
-       
-       
- 
-   
+
+   /*!
+   \brief Close all the context defintion and do processing data
+      After everything is well defined on client side, they will be processed and sent to server
+   From the version 2.0, sever and client work no more on the same database. Moreover, client(s) will send
+   all necessary information to server, from which each server can build its own database.
+   Because the role of server is to write out field data on a specific netcdf file,
+   the only information that it needs is the enabled files
+   and the active fields (fields will be written onto active files)
+   */
    void CContext::closeDefinition(void)
    {
-      if (hasClient && !hasServer) sendCloseDefinition() ;
-      
-      solveCalendar();         
-         
-      // Résolution des héritages pour le context actuel.
-      this->solveAllInheritance();
-
-      //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
-      this->findEnabledFiles();
-
-        
-      this->processEnabledFiles() ;
-
-/*        
+     if (hasClient && !hasServer)
+     {
+       // After xml is parsed, there are some more works with post processing
+       postProcessing();
+
+       setClientServerBuffer();
+
+      // Send all attributes of current context to server
+      this->sendAllAttributesToServer();
+
+      // We have enough information to send to server
+      // First of all, send all enabled files
+       sendEnabledFiles();
+
+      // Then, send all enabled fields
+       sendEnabledFields();
+
+      // After that, send all grid (if any)
+       sendRefGrid();
+
+      // At last, we have all info of domain and axis, then send them
+       sendRefDomainsAxis();
+    }
+
+    // Now tell server that it can process all messages from client
+    if (hasClient && !hasServer) this->sendCloseDefinition();
+
+    // We have a xml tree on the server side and now, it should be also processed
+    if (hasClient && !hasServer) sendPostProcessing();
+
+    // There are some processings that should be done after all of above. For example: check mask or index
+    if (hasClient && !hasServer)
+    {
+      this->solveAllRefOfEnabledFields(true);
+      this->buildAllExpressionOfEnabledFields();
+    }
+
+//      if (hasClient)
+//      {
+//        //solveCalendar();
+//
+//        // Résolution des héritages pour le context actuel.
+////        this->solveAllInheritance();
+//
+//
+////        //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
+////        this->findEnabledFiles();
+//
+//        this->processEnabledFiles() ;
+//
+//        this->solveAllGridRef();
+//      }
+
+
+
+
+//      solveCalendar();
+//
+//      // Résolution des héritages pour le context actuel.
+//      this->solveAllInheritance();
+//
+//      //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
+//      this->findEnabledFiles();
+//
+//
+//      this->processEnabledFiles() ;
+
+/*
       //Recherche des champs à sortir (enable à true + niveau de sortie correct)
       // pour chaque fichier précédemment listé.
@@ -324 +419 @@
 */
       // Nettoyage de l'arborescence
-      CleanTree();
+      if (hasClient && !hasServer) CleanTree(); // Only on client side??
+//      if (hasClient) CleanTree();
       if (hasClient) sendCreateFileHeader() ;
    }
-   
+
    void CContext::findAllEnabledFields(void)
    {
@@ -333 +429 @@
      (void)this->enabledFiles[i]->getEnabledFields();
    }
-   
-    void CContext::processEnabledFiles(void)
-   {
-     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-     this->enabledFiles[i]->processEnabledFile();
-   }
-  
-
-   void CContext::solveAllGridRef(void)
-   {
-     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-     this->enabledFiles[i]->solveEFGridRef();
-   }
-
-   void CContext::solveAllOperation(void)
-   {
-      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-      this->enabledFiles[i]->solveEFOperation();
-   }
-
-   void CContext::solveAllExpression(void)
-   {
-      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-      this->enabledFiles[i]->solveEFExpression();
-   }
-   
+
+//    void CContext::processEnabledFiles(void)
+//   {
+//     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
+//     this->enabledFiles[i]->processEnabledFile();
+//   }
+
+
+   void CContext::solveAllRefOfEnabledFields(bool sendToServer)
+   {
+     int size = this->enabledFiles.size();
+     for (int i = 0; i < size; ++i)
+     {
+       this->enabledFiles[i]->solveAllRefOfEnabledFields(sendToServer);
+     }
+   }
+
+   void CContext::buildAllExpressionOfEnabledFields()
+   {
+     int size = this->enabledFiles.size();
+     for (int i = 0; i < size; ++i)
+     {
+       this->enabledFiles[i]->buildAllExpressionOfEnabledFields();
+     }
+   }
+
+//   void CContext::solveAllGridRef(void)
+//   {
+//     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
+//     this->enabledFiles[i]->solveEFGridRef();
+//   }
+//
+//   void CContext::solveAllOperation(void)
+//   {
+//      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
+//      this->enabledFiles[i]->solveEFOperation();
+//   }
+//
+//   void CContext::solveAllExpression(void)
+//   {
+//      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
+//      this->enabledFiles[i]->solveEFExpression();
+//   }
+
    void CContext::solveAllInheritance(bool apply)
    {
@@ -368 +482 @@
       const vector<CFile*> allFiles=CFile::getAll() ;
 
+     if (hasClient && !hasServer)
       for (unsigned int i = 0; i < allFiles.size(); i++)
          allFiles[i]->solveFieldRefInheritance(apply);
@@ -383 +498 @@
          }
          else enabledFiles.push_back(allFiles[i]); // otherwise true by default
-               
+
 
       if (enabledFiles.size() == 0)
@@ -394 +509 @@
      std::vector<CFile*>::const_iterator
             it = this->enabledFiles.begin(), end = this->enabledFiles.end();
-         
+
      for (; it != end; it++)
      {
@@ -401 +516 @@
      }
    }
-   
+
+   /*!
+   \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 CContext::dispatchEvent(CEventServer& event)
    {
-      
+
       if (SuperClass::dispatchEvent(event)) return true ;
       else
@@ -422 +544 @@
              return true ;
              break ;
+           case EVENT_ID_POST_PROCESS:
+             recvPostProcessing(event) ;
+             return true ;
+             break ;
            default :
              ERROR("bool CContext::dispatchEvent(CEventServer& event)",
@@ -429 +555 @@
       }
    }
-   
+
+   //! Client side: Send a message to server to make it close
    void CContext::sendCloseDefinition(void)
    {
-
-     CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION) ;   
+     CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION) ;
      if (client->isServerLeader())
      {
@@ -443 +569 @@
      else client->sendEvent(event) ;
    }
-   
+
+   //! Server side: Receive a message of client announcing a context close
    void CContext::recvCloseDefinition(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
       *buffer>>id ;
-      get(id)->closeDefinition() ;
-   }
-   
+      get(id)->closeDefinition();
+   }
+
+   //! Client side: Send a message to update calendar in each time step
    void CContext::sendUpdateCalendar(int step)
    {
      if (!hasServer)
      {
-       CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR) ;   
+       CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR) ;
        if (client->isServerLeader())
        {
@@ -468 +596 @@
      }
    }
-   
+
+   //! Server side: Receive a message of client annoucing calendar update
    void CContext::recvUpdateCalendar(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -477 +606 @@
       get(id)->recvUpdateCalendar(*buffer) ;
    }
-   
+
+   //! Server side: Receive a message of client annoucing calendar update
    void CContext::recvUpdateCalendar(CBufferIn& buffer)
    {
@@ -484 +614 @@
       updateCalendar(step) ;
    }
-   
+
+   //! Client side: Send a message to create header part of netcdf file
    void CContext::sendCreateFileHeader(void)
    {
-
-     CEventClient event(getType(),EVENT_ID_CREATE_FILE_HEADER) ;   
+     CEventClient event(getType(),EVENT_ID_CREATE_FILE_HEADER) ;
      if (client->isServerLeader())
      {
@@ -498 +628 @@
      else client->sendEvent(event) ;
    }
-   
+
+   //! Server side: Receive a message of client annoucing the creation of header part of netcdf file
    void CContext::recvCreateFileHeader(CEventServer& event)
    {
-      
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -507 +637 @@
       get(id)->recvCreateFileHeader(*buffer) ;
    }
-   
+
+   //! Server side: Receive a message of client annoucing the creation of header part of netcdf file
    void CContext::recvCreateFileHeader(CBufferIn& buffer)
    {
       createFileHeader() ;
    }
-   
+
+   //! Client side: Send a message to do some post processing on server
+   void CContext::sendPostProcessing()
+   {
+     if (!hasServer)
+     {
+       CEventClient event(getType(),EVENT_ID_POST_PROCESS) ;
+       if (client->isServerLeader())
+       {
+         CMessage msg ;
+         msg<<this->getId();
+         event.push(client->getServerLeader(),1,msg) ;
+         client->sendEvent(event) ;
+       }
+       else client->sendEvent(event) ;
+     }
+   }
+
+   //! Server side: Receive a message to do some post processing
+   void CContext::recvPostProcessing(CEventServer& event)
+   {
+      CBufferIn* buffer=event.subEvents.begin()->buffer;
+      string id;
+      *buffer>>id;
+      get(id)->recvPostProcessing(*buffer);
+   }
+
+   //! Server side: Receive a message to do some post processing
+   void CContext::recvPostProcessing(CBufferIn& buffer)
+   {
+      postProcessing();
+   }
+
+   /*!
+   \brief Do some simple post processings after parsing xml file
+      After the xml file (iodef.xml) is parsed, it is necessary to build all relations among
+   created object, e.g: inhertance among fields, domain, axis. After that, all fiels as well as their parents (reference fields),
+   which will be written out into netcdf files, are processed
+   */
+   void CContext::postProcessing()
+   {
+     if (isPostProcessed) return;
+
+     this->solveCalendar();
+
+     // Solve calendar for both side: client and server
+      this->solveCalendar();
+
+      // Find all inheritance in xml structure
+      this->solveAllInheritance();
+
+      //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
+      this->findEnabledFiles();
+
+      // Find all enabled fields of each file
+      this->findAllEnabledFields();
+
+      // Search and rebuild all reference object of enabled fields
+      this->solveAllRefOfEnabledFields(false);
+      isPostProcessed = true;
+   }
+
+   std::map<int, StdSize>& CContext::getDataSize()
+   {
+     std::set<StdString> domainIds;
+
+     // Find all reference domain and axis of all active fields
+     int numEnabledFiles = this->enabledFiles.size();
+     for (int i = 0; i < numEnabledFiles; ++i)
+     {
+       std::vector<CField*> enabledFields = this->enabledFiles[i]->getEnabledFields();
+       int numEnabledFields = enabledFields.size();
+       for (int j = 0; j < numEnabledFields; ++j)
+       {
+         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
+         const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataSize();
+         if (dataSize_.empty())
+         {
+           dataSize_ = mapSize;
+           domainIds.insert(prDomAxisId.first);
+         }
+         else
+         {
+           if (domainIds.find(prDomAxisId.first) == domainIds.end())
+           {
+             std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
+             for (; it != itE; ++it)
+             {
+               if (0 < dataSize_.count(it->first)) dataSize_[it->first] += it->second;
+               else dataSize_.insert(make_pair(it->first, it->second));
+             }
+           }
+
+         }
+
+       }
+     }
+
+     return dataSize_;
+   }
+
+   //! Client side: Send infomation of active files (files are enabled to write out)
+   void CContext::sendEnabledFiles()
+   {
+     int size = this->enabledFiles.size();
+
+     // In a context, each type has a root definition, e.g: axis, domain, field.
+     // Every object must be a child of one of these root definition. In this case
+     // all new file objects created on server must be children of the root "file_definition"
+     StdString fileDefRoot("file_definition");
+     CFileGroup* cfgrpPtr = CFileGroup::get(fileDefRoot);
+
+     for (int i = 0; i < size; ++i)
+     {
+       cfgrpPtr->sendCreateChild(this->enabledFiles[i]->getId());
+       this->enabledFiles[i]->sendAllAttributesToServer();
+       this->enabledFiles[i]->sendAddAllVariables();
+     }
+   }
+
+   //! Client side: Send information of active fields (ones are written onto files)
+   void CContext::sendEnabledFields()
+   {
+     int size = this->enabledFiles.size();
+     for (int i = 0; i < size; ++i)
+     {
+       this->enabledFiles[i]->sendEnabledFields();
+     }
+   }
+
+   //! Client side: Send information of reference grid of active fields
+   void CContext::sendRefGrid()
+   {
+     std::set<StdString> gridIds;
+     int sizeFile = this->enabledFiles.size();
+     CFile* filePtr(NULL);
+
+     // Firstly, find all reference grids of all active fields
+     for (int i = 0; i < sizeFile; ++i)
+     {
+       filePtr = this->enabledFiles[i];
+       std::vector<CField*> enabledFields = filePtr->getEnabledFields();
+       int sizeField = enabledFields.size();
+       for (int numField = 0; numField < sizeField; ++numField)
+       {
+         if (0 != enabledFields[numField]->getRelGrid())
+           gridIds.insert(CGrid::get(enabledFields[numField]->getRelGrid())->getId());
+       }
+     }
+
+     // Create all reference grids on server side
+     StdString gridDefRoot("grid_definition");
+     CGridGroup* gridPtr = CGridGroup::get(gridDefRoot);
+     std::set<StdString>::const_iterator it, itE = gridIds.end();
+     for (it = gridIds.begin(); it != itE; ++it)
+     {
+       gridPtr->sendCreateChild(*it);
+       CGrid::get(*it)->sendAllAttributesToServer();
+     }
+   }
+
+
+   //! Client side: Send information of reference domain and axis of active fields
+   void CContext::sendRefDomainsAxis()
+   {
+     std::set<StdString> domainIds;
+     std::set<StdString> axisIds;
+
+     // Find all reference domain and axis of all active fields
+     int numEnabledFiles = this->enabledFiles.size();
+     for (int i = 0; i < numEnabledFiles; ++i)
+     {
+       std::vector<CField*> enabledFields = this->enabledFiles[i]->getEnabledFields();
+       int numEnabledFields = enabledFields.size();
+       for (int j = 0; j < numEnabledFields; ++j)
+       {
+         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
+         domainIds.insert(prDomAxisId.first);
+         axisIds.insert(prDomAxisId.second);
+       }
+     }
+
+     // Create all reference axis on server side
+     std::set<StdString>::iterator itDom, itAxis;
+     std::set<StdString>::const_iterator itE;
+
+     StdString axiDefRoot("axis_definition");
+     CAxisGroup* axisPtr = CAxisGroup::get(axiDefRoot);
+     itE = axisIds.end();
+     for (itAxis = axisIds.begin(); itAxis != itE; ++itAxis)
+     {
+       axisPtr->sendCreateChild(*itAxis);
+       CAxis::get(*itAxis)->sendAllAttributesToServer();
+     }
+
+     // Create all reference domains on server side
+     StdString domDefRoot("domain_definition");
+     CDomainGroup* domPtr = CDomainGroup::get(domDefRoot);
+     itE = domainIds.end();
+     for (itDom = domainIds.begin(); itDom != itE; ++itDom)
+     {
+       domPtr->sendCreateChild(*itDom);
+       CDomain::get(*itDom)->sendAllAttributesToServer();
+     }
+   }
+
+   //! Update calendar in each time step
    void CContext::updateCalendar(int step)
    {
@@ -519 +856 @@
       info(50)<<"updateCalendar : after : "<<calendar->getCurrentDate()<<endl ;
    }
- 
+
+   //! Server side: Create header of netcdf file
    void CContext::createFileHeader(void )
    {
       vector<CFile*>::const_iterator it ;
-         
+
       for (it=enabledFiles.begin(); it != enabledFiles.end(); it++)
       {
          (*it)->initFile();
       }
-   } 
-   
+   }
+
+   //! Get current context
    CContext* CContext::getCurrent(void)
    {
      return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()).get() ;
    }
-   
+
+   /*!
+   \brief Set context with an id be the current context
+   \param [in] id identity of context to be set to current
+   */
    void CContext::setCurrent(const string& id)
    {
@@ -540 +883 @@
      CGroupFactory::SetCurrentContextId(id);
    }
-   
+
+  /*!
+  \brief Create a context with specific id
+  \param [in] id identity of new context
+  \return pointer to the new context or already-existed one with identity id
+  */
   CContext* CContext::create(const StdString& id)
   {
     CContext::setCurrent(id) ;
- 
+
     bool hasctxt = CContext::has(id);
     CContext* context = CObjectFactory::CreateObject<CContext>(id).get();

XIOS/trunk/src/node/context.hpp

@@ -18 +18 @@
    class CContextClient ;
    class CContextServer ;
-   
-   
+
+
    /// ////////////////////// Déclarations ////////////////////// ///
    class CContextGroup;
@@ -33 +33 @@
 
    ///--------------------------------------------------------------
-
+  /*!
+  \class CContext
+   This class corresponds to the concrete presentation of context in xml file and in play an essential role in XIOS
+   Each object of this class contains all root definition of elements: files, fiels, domains, axis, etc, ... from which
+   we can have access to each element.
+   In fact, every thing must a be inside a particuliar context. After the xml file (iodef.xml) is parsed,
+   object of the class is created and its contains all information of other elements in the xml file.
+  */
    class CContext
       : public CObjectTemplate<CContext>
@@ -42 +49 @@
          {
            EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
-           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE
+           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
+           EVENT_ID_POST_PROCESS
          } ;
-         
+
          /// typedef ///
          typedef CObjectTemplate<CContext>   SuperClass;
@@ -70 +78 @@
 
       public :
-      
+
          /// Mutateurs ///
          void setCalendar(boost::shared_ptr<CCalendar> newCalendar);
-      
+
          /// Accesseurs ///
          boost::shared_ptr<CCalendar>      getCalendar(void) const;
 
-         /// Accesseurs statiques ///
-         static StdString GetName(void);
-         static StdString GetDefName(void);         
-         static ENodeType GetType(void);         
-
-         static CContextGroup* GetContextGroup(void);
-
-      public :
-
-         /// Traitements ///
-         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
-         void solveFieldRefInheritance(bool apply);
-         void solveCalendar(void);
-
-         /// Autres méthodes statiques ///
-         static void ShowTree(StdOStream & out = std::clog);
-         static void CleanTree(void);
-
-         /// Test ///
-         virtual bool hasChild(void) const;
-
+      public :
+         // Initialize server or client
+         void initServer(MPI_Comm intraComm, MPI_Comm interComm) ;
+         void initClient(MPI_Comm intraComm, MPI_Comm interComm) ;
+         bool isInitialized(void) ;
+
+         // Put sever or client into loop state
          bool eventLoop(void) ;
          bool serverLoop(void) ;
          void clientLoop(void) ;
-         void initServer(MPI_Comm intraComm, MPI_Comm interComm) ;
-         void initClient(MPI_Comm intraComm, MPI_Comm interComm) ;
-         bool isInitialized(void) ;
-         CContextServer* server ;
-         CContextClient* client ;
-         bool hasClient ;
-         bool hasServer ;
+
+         // Process all information of calendar
+         void solveCalendar(void);
+
+         // Finalize a context
          void finalize(void) ;
          void closeDefinition(void) ;
+
+         // Some functions to process context
          void findAllEnabledFields(void);
          void processEnabledFiles(void) ;
-         void solveAllGridRef(void);
-         void solveAllOperation(void);
-         void solveAllExpression(void);
          void solveAllInheritance(bool apply=true) ;
          void findEnabledFiles(void);
@@ -120 +111 @@
          void updateCalendar(int step) ;
          void createFileHeader(void ) ;
-      // dispatch event
-         static bool dispatchEvent(CEventServer& event) ;
+         void solveAllRefOfEnabledFields(bool sendToServer);
+         void buildAllExpressionOfEnabledFields();
+         void postProcessing();
+
+         std::map<int, StdSize>& getDataSize();
+         void setClientServerBuffer();
+
+         // Send context close definition
          void sendCloseDefinition(void) ;
+         // There are something to send on closing context defintion
          void sendUpdateCalendar(int step) ;
          void sendCreateFileHeader(void) ;
+         void sendEnabledFiles();
+         void sendEnabledFields();
+         void sendRefDomainsAxis();
+         void sendRefGrid();
+         void sendPostProcessing();
+
+         // Client side: Receive and process messages
          static void recvUpdateCalendar(CEventServer& event) ;
          void recvUpdateCalendar(CBufferIn& buffer) ;
@@ -130 +135 @@
          static void recvCreateFileHeader(CEventServer& event) ;
          void recvCreateFileHeader(CBufferIn& buffer) ;
-         static CContext* getCurrent(void) ;
-         static CContextGroup* getRoot(void) ;
-         static void setCurrent(const string& id) ;
-         static CContext* create(const string& id = "") ;
-         
-      public :
-      
-         /// Autres ///
+         static void recvSolveInheritanceContext(CEventServer& event);
+         void recvSolveInheritanceContext(CBufferIn& buffer);
+         static void recvPostProcessing(CEventServer& event);
+         void recvPostProcessing(CBufferIn& buffer);
+
+         // dispatch event
+         static bool dispatchEvent(CEventServer& event) ;
+
+      public:
+        // Get current context
+        static CContext* getCurrent(void);
+
+        // Get context root
+        static CContextGroup* getRoot(void);
+
+        // Set current context
+        static void setCurrent(const string& id);
+
+        // Create new context
+        static CContext* create(const string& id = "");
+
+        /// Accesseurs statiques ///
+        static StdString GetName(void);
+        static StdString GetDefName(void);
+        static ENodeType GetType(void);
+
+        static CContextGroup* GetContextGroup(void);
+
+        // Some functions to visualize structure of current context
+        static void ShowTree(StdOStream & out = std::clog);
+        static void CleanTree(void);
+
+      public :
+         // Parse xml node and write all info into context
          virtual void parse(xml::CXMLNode & node);
 
+         // Visualize a context
          virtual StdString toString(void) const;
-//         virtual void toBinary  (StdOStream & os) const;
-//         virtual void fromBinary(StdIStream & is);
-         
-      public :
-      
-         boost::shared_ptr<CCalendar>      calendar;
- 
+
+
+         // Solve all inheritance relation in current context
+         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
+
+         // Verify if all root definition in a context have children
+         virtual bool hasChild(void) const;
+
+      public :
+         // Calendar of context
+         boost::shared_ptr<CCalendar>   calendar;
+
+         // List of all enabled files (files on which fields are written)
          std::vector<CFile*> enabledFiles;
+
+         // Context root
          static shared_ptr<CContextGroup> root ;
 
+         // Determine context on client or not
+         bool hasClient ;
+
+         // Determine context on server or not
+         bool hasServer ;
+
+         // Concrete context server
+         CContextServer* server ;
+
+         // Concrete contex client
+         CContextClient* client ;
+
+      private:
+         bool isPostProcessed;
+         std::map<int, StdSize> dataSize_;
+
+
+      public: // Some function maybe removed in the near future
+        // virtual void toBinary  (StdOStream & os) const;
+        // virtual void fromBinary(StdIStream & is);
+        // void solveAllGridRef(void);
+        // void solveAllOperation(void);
+        // void solveAllExpression(void);
+        // void solveFieldRefInheritance(bool apply);
 
    }; // class CContext

XIOS/trunk/src/node/domain.cpp

@@ -16 +16 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Définitions ////////////////////// ///
 
    CDomain::CDomain(void)
       : CObjectTemplate<CDomain>(), CDomainAttributes()
-      , isChecked(false),  relFiles()
+      , isChecked(false), relFiles(), isClientChecked(false)
    { /* Ne rien faire de plus */ }
 
    CDomain::CDomain(const StdString & id)
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
-      , isChecked(false), relFiles()
+      , isChecked(false), relFiles(), isClientChecked(false)
          { /* Ne rien faire de plus */ }
 
    CDomain::~CDomain(void)
-   { 
+   {
    }
 
@@ -37 +37 @@
    const std::set<StdString> & CDomain::getRelFiles(void) const
    {
-      return (this->relFiles); 
-   }
-
-   //----------------------------------------------------------------
-   
+      return (this->relFiles);
+   }
+
+   //----------------------------------------------------------------
+
    bool CDomain::hasZoom(void) const
    {
-      return ((this->zoom_ni.getValue() != this->ni_glo.getValue()) && 
+      return ((this->zoom_ni.getValue() != this->ni_glo.getValue()) &&
               (this->zoom_nj.getValue() != this->nj_glo.getValue()));
    }
-   
-   //----------------------------------------------------------------
-   
+
+   //----------------------------------------------------------------
+
    bool CDomain::isEmpty(void) const
    {
-      return ((this->zoom_ni_srv == 0) || 
+      return ((this->zoom_ni_srv == 0) ||
               (this->zoom_nj_srv == 0));
    }
@@ -86 +86 @@
                << "[ Id = " << this->getId() << " ] "
                << "The global domain is badly defined,"
-               << " check the \'ni_glo\'  value !") 
+               << " check the \'ni_glo\'  value !")
          }
          nj_glo=ni_glo ;
@@ -111 +111 @@
          ibegin=1 ;
          iend=1 ;
-         
+
       }
       else if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) ||
@@ -119 +119 @@
                << "[ Id = " << this->getId() << " ] "
                << "The global domain is badly defined,"
-               << " check the \'ni_glo\' et \'nj_glo\' values !") 
+               << " check the \'ni_glo\' et \'nj_glo\' values !")
       }
       checkLocalIDomain() ;
       checkLocalJDomain() ;
-      
+
      if (i_index.isEmpty())
      {
        i_index.resize(ni,nj) ;
        for(int j=0;j<nj;j++)
-         for(int i=0;i<ni;i++) i_index(i,j)=i ;   
+         for(int i=0;i<ni;i++) i_index(i,j)=i ;
      }
-     
+
      if (j_index.isEmpty())
      {
         j_index.resize(ni,nj) ;
         for(int j=0;j<nj;j++)
-         for(int i=0;i<ni;i++) j_index(i,j)=j ;   
+         for(int i=0;i<ni;i++) j_index(i,j)=j ;
      }
- 
+
    }
 
@@ -211 +211 @@
                << "Domain is wrong defined,"
                << " Check the values : nj, nj_glo, jbegin, jend") ;
-               
+
      ibegin_client=ibegin ; iend_client=iend ; ni_client=ni ;
      jbegin_client=jbegin ; jend_client=jend ; nj_client=nj ;
@@ -221 +221 @@
    {
       using namespace std;
-      
+
       int ibegin_mask = 0,
           jbegin_mask = 0,
           iend_mask = iend.getValue() - ibegin.getValue(),
           jend_mask = jend.getValue() - jbegin.getValue();
-      
+
       if (!zoom_ibegin.isEmpty())
       {
          int zoom_iend = zoom_ibegin.getValue() + zoom_ni.getValue() - 1;
          int zoom_jend = zoom_jbegin.getValue() + zoom_nj.getValue() - 1;
-         
+
          ibegin_mask = max (ibegin.getValue(), zoom_ibegin.getValue());
          jbegin_mask = max (jbegin.getValue(), zoom_jbegin.getValue());
          iend_mask   = min (iend.getValue(), zoom_iend);
          jend_mask   = min (jend.getValue(), zoom_jend);
-                 
+
          ibegin_mask -= ibegin.getValue();
          jbegin_mask -= jbegin.getValue();
@@ -242 +242 @@
          jend_mask   -= jbegin.getValue();
       }
-      
+
 
       if (!mask.isEmpty())
@@ -251 +251 @@
                   <<"the mask has not the same size than the local domain"<<endl
                    <<"Local size is "<<ni<<"x"<<nj<<endl
-                  <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1));                 
+                  <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1));
          for (int i = 0; i < ni; i++)
          {
@@ -283 +283 @@
 
    void CDomain::checkDomainData(void)
-   {     
+   {
       if (!data_dim.isEmpty() &&
          !(data_dim.getValue() == 1 || data_dim.getValue() == 2))
@@ -378 +378 @@
             data_i_index.resize(dni) ;
             data_j_index.resize(dni) ;
-            
+
             data_n_index.setValue(dni);
-            
+
             for(int count = 0, j = 0; j  < data_nj.getValue(); j++)
             {
@@ -394 +394 @@
 
    //----------------------------------------------------------------
-   
+
    void CDomain::completeLonLatClient(void)
    {
@@ -402 +402 @@
       CArray<double,2> bounds_lon_temp(nvertex,ni*nj) ;
       CArray<double,2> bounds_lat_temp(nvertex,ni*nj) ;
-      
+
       if (type.isEmpty())
       {
-        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj ) 
+        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj )
         {
           type.setValue(type_attr::curvilinear) ;
           isCurvilinear=true ;
         }
-        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj ) 
+        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj )
         {
           type.setValue(type_attr::regular) ;
@@ -429 +429 @@
       {
         for(j=0;j<nj;j++)
-          for(i=0;i<ni;i++) 
+          for(i=0;i<ni;i++)
           {
             k=j*ni+i ;
@@ -436 +436 @@
             if (hasBounds)
             {
-              for(int n=0;n<nvertex;n++) 
+              for(int n=0;n<nvertex;n++)
               {
                 bounds_lon_temp(n,k)=bounds_lon(n,i) ;
@@ -444 +444 @@
           }
       }
-         
+
       StdSize dm = zoom_ni_client * zoom_nj_client;
 
       lonvalue.resize(dm);
       latvalue.resize(dm);
-         
+
       for (int i = 0; i < zoom_ni_client; i++)
       {
         for (int j = 0; j < zoom_nj_client; j++)
         {
-          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
+          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
           latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni );
           if (hasBounds)
           {
-            for(int n=0;n<nvertex;n++) 
+            for(int n=0;n<nvertex;n++)
             {
-              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni ); 
+              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
               bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni );
             }
@@ -467 +467 @@
       }
     }
- 
+
 
    //----------------------------------------------------------------
@@ -487 +487 @@
             int zoom_iend = zoom_ibegin + zoom_ni - 1;
             int zoom_jend = zoom_jbegin + zoom_nj - 1;
-                
+
             if (zoom_ibegin < 1  || zoom_jbegin < 1 || zoom_iend > ni_glo || zoom_jend > nj_glo)
                ERROR("CDomain::checkZoom(void)",
@@ -496 +496 @@
       else
       {
-         zoom_ni = ni_glo; 
+         zoom_ni = ni_glo;
          zoom_nj = nj_glo;
          zoom_ibegin = 1;
          zoom_jbegin = 1;
       }
-      
+
       // compute client zoom indices
 
@@ -510 +510 @@
       if (zoom_ni_client<0) zoom_ni_client=0 ;
 
-    
+
       int zoom_jend=zoom_jbegin+zoom_nj-1 ;
       zoom_jbegin_client = jbegin_client > zoom_jbegin ? jbegin_client : zoom_jbegin ;
@@ -518 +518 @@
 
    }
-   
+
    void CDomain::checkBounds(void)
    {
@@ -524 +524 @@
      {
        hasBounds=true ;
-       
+
      }
-     else 
+     else
      {
        hasBounds=false;
@@ -532 +532 @@
      }
    }
-            
-   //----------------------------------------------------------------
-
-   void CDomain::checkAttributes(void)
-   {
-      if (this->isChecked) return;
-      CContext* context=CContext::getCurrent() ;
+
+   //----------------------------------------------------------------
+   // Divide function checkAttributes into 2 seperate ones
+   // This function only checks all attributes of current domain
+   void CDomain::checkAttributesOnClient()
+   {
+     if (this->isClientChecked) return;
+     CContext* context=CContext::getCurrent();
 
       this->checkDomain();
       this->checkZoom();
       this->checkBounds();
-      
+
       if (context->hasClient)
       { // CÎté client uniquement
@@ -550 +551 @@
          this->checkCompression();
          this->completeLonLatClient();
+         this->computeConnectedServer() ;
       }
       else
@@ -556 +558 @@
 // ne sert plus //   this->completeLonLatServer();
       }
-    
+
+      this->isClientChecked = true;
+   }
+
+   // Send all checked attributes to server
+   void CDomain::sendCheckedAttributes()
+   {
+     if (!this->isClientChecked) checkAttributesOnClient();
+     CContext* context=CContext::getCurrent() ;
+
+     if (this->isChecked) return;
+     if (context->hasClient)
+     {
+       sendServerAttribut() ;
+       sendLonLat() ;
+     }
+
+     this->isChecked = true;
+   }
+
+   void CDomain::checkAttributes(void)
+   {
+      if (this->isChecked) return;
+      CContext* context=CContext::getCurrent() ;
+
+      this->checkDomain();
+      this->checkZoom();
+      this->checkBounds();
+
+      if (context->hasClient)
+      { // CÎté client uniquement
+         this->checkMask();
+         this->checkDomainData();
+         this->checkCompression();
+         this->completeLonLatClient();
+      }
+      else
+      { // CÎté serveur uniquement
+//         if (!this->isEmpty())
+// ne sert plus //   this->completeLonLatServer();
+      }
+
       if (context->hasClient)
       {
@@ -563 +606 @@
         sendLonLat() ;
       }
-      
+
       this->isChecked = true;
    }
-   
+
   void CDomain::sendServerAttribut(void)
   {
@@ -572 +615 @@
     int ibegin_srv=1 ;
     int iend_srv=ni_glo.getValue() ;
-     
+
     int nj_srv ;
     int jbegin_srv ;
     int jend_srv ;
-    
+
     CContext* context=CContext::getCurrent() ;
     CContextClient* client=context->client ;
     int nbServer=client->serverSize ;
     int serverRank=client->getServerLeader() ;
-    
+
     jend_srv=0 ;
     for(int i=0;i<=serverRank;i++)
@@ -590 +633 @@
       jend_srv=jbegin_srv+nj_srv-1 ;
     }
-    
-     CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT) ;   
+
+     CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT) ;
      if (client->isServerLeader())
      {
@@ -606 +649 @@
   {
     int i,j,i_ind,j_ind ;
-    
+
     ibegin_client=ibegin ; iend_client=iend ; ni_client=ni ;
     jbegin_client=jbegin ; jend_client=jend ; nj_client=nj ;
-     
+
     CContext* context = CContext::getCurrent() ;
     CContextClient* client=context->client ;
@@ -617 +660 @@
     int zoom_iend=zoom_ibegin+zoom_ni-1 ;
     int zoom_jend=zoom_jbegin+zoom_nj-1 ;
-    
+
     int blockSize=nj_glo/nbServer ;
     int ns=nj_glo%nbServer ;
     int pos=ns*(blockSize+1) ;
     int serverNum ;
-    
+
     mapConnectedServer.resize(ni,nj) ;
     vector<int> nbData(nbServer,0) ;
     vector<int> indServer(nbServer,-1) ;
     vector<bool> IsConnected(nbServer,false) ;
-    
+
     for(j=0;j<nj;j++)
       for(i=0;i<ni;i++)
@@ -633 +676 @@
         i_ind=ibegin+i_index(i,j)-1 ;
         j_ind=jbegin+j_index(i,j)-1 ;
-        
+
         if (j_ind<pos) serverNum=j_ind/(blockSize+1) ;
         else serverNum=ns+(j_ind-pos)/blockSize ;
         IsConnected[serverNum]=true ;
-                
+
         if (i_ind >= zoom_ibegin-1 && i_ind <= zoom_iend-1 && j_ind >= zoom_jbegin-1 && j_ind <= zoom_jend-1)
         {
@@ -647 +690 @@
 
 
-    for(serverNum=0 ; serverNum<nbServer ; serverNum++) 
+    for(serverNum=0 ; serverNum<nbServer ; serverNum++)
       if (IsConnected[serverNum])
       {
@@ -655 +698 @@
         nbDataSrv.push_back(nbData[serverNum]) ;
       }
-     
+
      i_indSrv.resize(connectedServer.size()) ;
      j_indSrv.resize(connectedServer.size()) ;
 
      for(j=0;j<nj;j++)
-      for(i=0;i<ni;i++) 
+      for(i=0;i<ni;i++)
       {
         if (mapConnectedServer(i,j)>=0)
@@ -670 +713 @@
         }
       }
-          
+
     int nbConnectedServer=connectedServer.size() ;
 
@@ -677 +720 @@
     int* sendBuff=new int[nbConnectedServer] ;
     valarray<int> nbClient(0,client->serverSize) ;
-    
+
     for(int n=0;n<nbConnectedServer;n++) sendBuff[n]=connectedServer[n] ;
-    
+
     // get connected server for everybody
     MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,client->intraComm) ;
-    
+
     displ[0]=0 ;
     for(int n=1;n<client->clientSize;n++) displ[n]=displ[n-1]+recvCount[n-1] ;
     int recvSize=displ[client->clientSize-1]+recvCount[client->clientSize-1] ;
     int* recvBuff=new int[recvSize] ;
- 
-    
+
+
     MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,client->intraComm) ;
     for(int n=0;n<recvSize;n++) nbClient[recvBuff[n]]++ ;
-    
+
     for(int n=0;n<nbConnectedServer;n++) nbSenders.push_back(nbClient[connectedServer[n]]) ;
-   
+
     delete [] recvCount ;
     delete [] displ ;
@@ -708 +751 @@
     // send lon lat for each connected server
     CEventClient event(getType(),EVENT_ID_LON_LAT) ;
-    
-    list<shared_ptr<CMessage> > list_msg ;    
+
+    list<shared_ptr<CMessage> > list_msg ;
     list< CArray<int,1>* > list_indi,list_indj ;
     list< CArray<double,1>* >list_lon,list_lat ;
@@ -723 +766 @@
       CArray<double,2> boundslon(nvertex,nbData) ;
       CArray<double,2> boundslat(nvertex,nbData) ;
-      
-      for(n=0;n<nbData;n++) 
+
+      for(n=0;n<nbData;n++)
       {
         i=i_indSrv[ns][n] ;
         j=j_indSrv[ns][n] ;
         ind=(i-(zoom_ibegin_client-1))+(j-(zoom_jbegin_client-1))*zoom_ni_client ;
-        
+
         lon(n)=lonvalue(ind) ;
         lat(n)=latvalue(ind) ;
@@ -743 +786 @@
         indj(n)=jbegin+j_index(i-ibegin+1,j-jbegin+1)-1  ;
       }
-    
+
       list_indi.push_back(new CArray<int,1>(indi.copy())) ;
       list_indj.push_back(new CArray<int,1>(indj.copy())) ;
@@ -761 +804 @@
 
     client->sendEvent(event) ;
-    
-    
+
+
     for(list<CArray<int,1>* >::iterator it=list_indi.begin();it!=list_indi.end();it++) delete *it;
     for(list<CArray<int,1>* >::iterator it=list_indj.begin();it!=list_indj.end();it++) delete *it;
@@ -768 +811 @@
     for(list<CArray<double,1>* >::iterator it=list_lat.begin();it!=list_lat.end();it++)   delete *it;
     if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslon.begin();it!=list_boundslon.end();it++)   delete *it;
-    if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslat.begin();it!=list_boundslat.end();it++)   delete *it;    
-    
+    if (hasBounds) for(list<CArray<double,2>* >::iterator it=list_boundslat.begin();it!=list_boundslat.end();it++)   delete *it;
+
   }
-  
-  
+
+
   bool CDomain::dispatchEvent(CEventServer& event)
    {
-      
+
       if (SuperClass::dispatchEvent(event)) return true ;
       else
@@ -796 +839 @@
       }
    }
-   
+
   void CDomain::recvServerAttribut(CEventServer& event)
   {
@@ -804 +847 @@
     get(domainId)->recvServerAttribut(*buffer) ;
   }
-  
+
   void CDomain::recvServerAttribut(CBufferIn& buffer)
   {
@@ -811 +854 @@
 
      buffer>>ni_srv>>ibegin_srv>>iend_srv>>nj_srv>>jbegin_srv>>jend_srv;
-     
-    
+
+
     zoom_ibegin_srv = zoom_ibegin.getValue() > ibegin_srv ? zoom_ibegin.getValue() : ibegin_srv ;
     zoom_iend_srv = zoom_iend < iend_srv ? zoom_iend : iend_srv ;
     zoom_ni_srv=zoom_iend_srv-zoom_ibegin_srv+1 ;
-      
+
     zoom_jbegin_srv = zoom_jbegin.getValue() > jbegin_srv ? zoom_jbegin.getValue() : jbegin_srv ;
     zoom_jend_srv = zoom_jend < jend_srv ? zoom_jend : jend_srv ;
     zoom_nj_srv=zoom_jend_srv-zoom_jbegin_srv+1 ;
 
-    if (zoom_ni_srv<=0 || zoom_nj_srv<=0) 
+    if (zoom_ni_srv<=0 || zoom_nj_srv<=0)
     {
       zoom_ibegin_srv=1 ; zoom_iend_srv=0 ; zoom_ni_srv=0 ;
@@ -830 +873 @@
     latvalue_srv.resize(zoom_ni_srv*zoom_nj_srv) ;
     latvalue_srv = 0. ;
-    if (hasBounds) 
+    if (hasBounds)
     {
       bounds_lon_srv.resize(nvertex,zoom_ni_srv*zoom_nj_srv) ;
@@ -838 +881 @@
     }
   }
-    
+
   void CDomain::recvLonLat(CEventServer& event)
   {
@@ -850 +893 @@
     }
   }
-  
+
   void CDomain::recvLonLat(CBufferIn& buffer)
   {
@@ -859 +902 @@
     CArray<double,2> boundslon ;
     CArray<double,2> boundslat ;
-    
+
     int type_int ;
     buffer>>type_int>>isCurvilinear>>indi>>indj>>lon>>lat ;
@@ -872 +915 @@
       lonvalue_srv(ind_srv)=lon(ind) ;
       latvalue_srv(ind_srv)=lat(ind) ;
-      if (hasBounds) 
-      {
-        for(int nv=0;nv<nvertex;nv++) 
+      if (hasBounds)
+      {
+        for(int nv=0;nv<nvertex;nv++)
         {
           bounds_lon_srv(nv,ind_srv)=boundslon(nv,ind) ;
@@ -883 +926 @@
   }
    //----------------------------------------------------------------
-   
-   
-   
+
+
+
    ///---------------------------------------------------------------
 

XIOS/trunk/src/node/domain.hpp

@@ -15 +15 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Déclarations ////////////////////// ///
 
@@ -39 +39 @@
            EVENT_ID_SERVER_ATTRIBUT, EVENT_ID_LON_LAT
          } ;
-         
+
          /// typedef ///
          typedef CObjectTemplate<CDomain>   SuperClass;
@@ -58 +58 @@
          void checkAttributes(void);
 
+         void checkAttributesOnClient();
+
+         void sendCheckedAttributes();
+
       private :
 
@@ -68 +72 @@
          void checkDomainData(void);
          void checkCompression(void);
-         
+
          void checkZoom(void);
          void checkBounds(void);
@@ -74 +78 @@
 
       public :
-      
+
          /// Autres ///
 
@@ -84 +88 @@
          bool hasZoom(void) const;
          bool isEmpty(void) const;
-         
-         
+
+
          int ni_client,ibegin_client,iend_client ;
          int zoom_ni_client,zoom_ibegin_client,zoom_iend_client ;
@@ -100 +104 @@
          CArray<double, 1> lonvalue_srv, latvalue_srv ;
          CArray<double, 2> bounds_lon_srv, bounds_lat_srv ;
-         
-         
-        vector<int> connectedServer ; // list of connected server 
+
+
+        vector<int> connectedServer ; // list of connected server
         vector<int> nbSenders ; // for each communication with a server, number of communicating client
-        vector<int> nbDataSrv ; // size of data to send to each server 
+        vector<int> nbDataSrv ; // size of data to send to each server
         vector< vector<int> > i_indSrv ; // for each server, i global index to send
         vector< vector<int> > j_indSrv ; // for each server, j global index to send
-       
+
         CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target
-               
+
 //        vector<int> ib_srv, ie_srv, in_srv ;
 //        vector<int> jb_srv, je_srv, jn_srv ;
-         
+
       public :
-      
+
          /// Mutateur ///
          void addRelFile(const StdString & filename);
@@ -126 +130 @@
          void recvLonLat(CBufferIn& buffer) ;
          void recvServerAttribut(CBufferIn& buffer) ;
-         
+
          /// Destructeur ///
          virtual ~CDomain(void);
@@ -133 +137 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-         
+
          static ENodeType GetType(void);
 
@@ -144 +148 @@
          bool isChecked;
          std::set<StdString> relFiles;
+         bool isClientChecked; // Verify whether all attributes of domain on the client side is good
 
    }; // class CDomain

XIOS/trunk/src/node/field.cpp

@@ -14 +14 @@
 
 namespace xios{
-   
+
    /// ////////////////////// Définitions ////////////////////// ///
 
@@ -26 +26 @@
       , foperation(), hasInstantData(false), hasExpression(false)
       , active(false) , hasOutputFile(false),hasFieldOut(false), slotUpdateDate(NULL)
-      , processed(false)
+      , processed(false), domAxisIds_("",""), areAllReferenceSolved(false), areAllExpressionBuilt(false)
       { setVirtualVariableGroup() ; }
 
@@ -38 +38 @@
       , foperation(), hasInstantData(false), hasExpression(false)
       , active(false), hasOutputFile(false), hasFieldOut(false), slotUpdateDate(NULL)
-      , processed(false)
+      , processed(false), domAxisIds_("",""), areAllReferenceSolved(false), areAllExpressionBuilt(false)
    { setVirtualVariableGroup() ; }
 
@@ -48 +48 @@
       if (hasExpression) delete expression ;
       if (slotUpdateDate!=NULL) delete slotUpdateDate ;
-        
+
    }
 
@@ -55 +55 @@
 
    void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
-   { 
-      this->vVariableGroup = newVVariableGroup; 
-   }
- 
+   {
+      this->vVariableGroup = newVVariableGroup;
+   }
+
    void CField::setVirtualVariableGroup(void)
    {
       this->setVirtualVariableGroup(CVariableGroup::create());
    }
-  
+
    CVariableGroup* CField::getVirtualVariableGroup(void) const
    {
@@ -69 +69 @@
    }
 
- 
+
    std::vector<CVariable*> CField::getAllVariables(void) const
    {
       return (this->vVariableGroup->getAllChildren());
    }
-   
+
    void CField::solveDescInheritance(bool apply, const CAttributeMap * const parent)
    {
@@ -88 +88 @@
    {
       const CDate opeDate      = *last_operation + freq_operation;
-      const CDate writeDate    = *last_Write     + freq_write; 
-      
+      const CDate writeDate    = *last_Write     + freq_write;
+
       if (opeDate <= currDate)
       {
@@ -95 +95 @@
          {
             this->data.resize(this->grid->storeIndex[0] ->numElements());
-         }  
+         }
          CArray<double,1> input(data.numElements()) ;
-         this->grid->inputFieldServer(storedClient, input);          
+         this->grid->inputFieldServer(storedClient, input);
          (*this->foperation)(input);
          *last_operation = currDate;
@@ -106 +106 @@
          this->incrementNStep();
          *last_Write = writeDate;
-         return (true);        
+         return (true);
       }
       return (false);
    }
-   
+
    bool CField::dispatchEvent(CEventServer& event)
   {
-     
+
     if (SuperClass::dispatchEvent(event)) return true ;
     else
@@ -128 +128 @@
              return true ;
              break ;
-         
+
            case EVENT_ID_ADD_VARIABLE_GROUP :
              recvAddVariableGroup(event) ;
              return true ;
-             break ; 
- 
+             break ;
+
         default :
           ERROR("bool CField::dispatchEvent(CEventServer& event)",<<"Unknown Event") ;
@@ -140 +140 @@
     }
   }
-  
+
   void CField::sendUpdateData(void)
   {
     CContext* context = CContext::getCurrent() ;
     CContextClient* client=context->client ;
-    
+
     CEventClient event(getType(),EVENT_ID_UPDATE_DATA) ;
-    
+
     map<int,CArray<int, 1>* >::iterator it ;
     list<shared_ptr<CMessage> > list_msg ;
     list< CArray<double,1>* > list_data ;
-    
+
     for(it=grid->storeIndex_toSrv.begin();it!=grid->storeIndex_toSrv.end();it++)
     {
@@ -157 +157 @@
       CArray<int,1>& index = *(it->second) ;
       CArray<double,1> data_tmp(index.numElements()) ;
-      
+
       for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ;
       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
@@ -165 +165 @@
     }
     client->sendEvent(event) ;
-    
+
     for(list< CArray<double,1>* >::iterator it=list_data.begin();it!=list_data.end();it++) delete *it ;
   }
-  
+
   void CField::recvUpdateData(CEventServer& event)
   {
     vector<int> ranks ;
     vector<CBufferIn*> buffers ;
-      
+
     list<CEventServer::SSubEvent>::iterator it ;
     string fieldId ;
@@ -185 +185 @@
       buffers.push_back(buffer) ;
     }
-    get(fieldId)->recvUpdateData(ranks,buffers) ;   
-  }
-  
+    get(fieldId)->recvUpdateData(ranks,buffers) ;
+  }
+
   void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
   {
-    
+
     if (data_srv.empty())
     {
@@ -205 +205 @@
     const CDate & currDate = context->getCalendar()->getCurrentDate();
     const CDate opeDate      = *last_operation_srv + freq_operation_srv;
-    const CDate writeDate    = *last_Write_srv     + freq_write_srv; 
-    
-
-    
+    const CDate writeDate    = *last_Write_srv     + freq_write_srv;
+
+
+
     if (opeDate <= currDate)
     {
@@ -219 +219 @@
       *last_operation_srv = currDate;
     }
-     
+
     if (writeDate < (currDate + freq_operation_srv))
     {
@@ -226 +226 @@
         this->foperation_srv[ranks[n]]->final();
       }
-      
+
       *last_Write_srv = writeDate;
       writeField() ;
@@ -232 +232 @@
     }
   }
-  
+
   void CField::writeField(void)
   {
@@ -246 +246 @@
 
    void CField::setRelFile(CFile* _file)
-   { 
+   {
       this->file = _file;
-      hasOutputFile=true ; 
+      hasOutputFile=true ;
    }
 
@@ -260 +260 @@
 
    CGrid* CField::getRelGrid(void) const
-   { 
-      return (this->grid); 
+   {
+      return (this->grid);
    }
 
@@ -267 +267 @@
 
    CFile* CField::getRelFile(void) const
-   { 
+   {
       return (this->file);
    }
-   
+
    StdSize CField::getNStep(void) const
    {
       return (this->nstep);
    }
-   
+
    void CField::incrementNStep(void)
    {
       this->nstep++;
    }
- 
+
    void CField::resetNStep(void)
    {
@@ -288 +288 @@
    //----------------------------------------------------------------
 
+   /*!
+   \brief Get pointer to direct field to which the current field refers.
+   */
    CField* CField::getDirectFieldReference(void) const
    {
@@ -304 +307 @@
 
    CField* CField::getBaseFieldReference(void) const
-   { 
-      return (baseRefObject); 
-   }
-
-   //----------------------------------------------------------------
-
-   const std::vector<CField*>& CField::getAllReference(void) const 
-   { 
+   {
+      return (baseRefObject);
+   }
+
+   //----------------------------------------------------------------
+
+   const std::vector<CField*>& CField::getAllReference(void) const
+   {
       return (refObject);
    }
@@ -318 +321 @@
 
    const StdString & CField::getBaseFieldId(void) const
-   { 
+   {
       return (this->getBaseFieldReference()->getId());
    }
-   
-   //----------------------------------------------------------------
-   
+
+   //----------------------------------------------------------------
+
    const CDuration & CField::getFreqOperation(void) const
    {
       return (this->freq_operation);
    }
-   
+
    //----------------------------------------------------------------
    const CDuration & CField::getFreqWrite(void) const
@@ -334 +337 @@
       return (this->freq_write);
    }
-   
-   //----------------------------------------------------------------
-         
+
+   //----------------------------------------------------------------
+
    boost::shared_ptr<func::CFunctor> CField::getFieldOperation(void) const
    {
@@ -345 +348 @@
 
    bool CField::hasDirectFieldReference(void) const
-   { 
-     return (!this->field_ref.isEmpty()); 
-   }
-   
+   {
+     return (!this->field_ref.isEmpty());
+   }
+
    bool CField::isActive(void) const
-   { 
-      return (!this->refObject.empty()); 
-   }
-   //----------------------------------------------------------------
-   
+   {
+      return (!this->refObject.empty());
+   }
+   //----------------------------------------------------------------
+
    CArray<double, 1> CField::getData(void) const
    {
@@ -376 +379 @@
    //----------------------------------------------------------------
 
-   void CField::processEnabledField(void)
-   {
-      if (!processed)
-      {
-        processed=true ;
-        solveRefInheritance(true) ;
-        solveBaseReference() ;
-        solveOperation() ;
-        solveGridReference() ;
-      
-        if (hasDirectFieldReference()) baseRefObject->processEnabledField() ;
-        buildExpression(); 
-        active=true;
-      }
-    }
-
+//   void CField::processEnabledField(void)
+//   {
+//      if (!processed)
+//      {
+//        processed=true ;
+//        solveRefInheritance(true) ;
+//        solveBaseReference() ;
+//        solveOperation() ;
+//        solveGridReference() ;
+//
+//        if (hasDirectFieldReference()) baseRefObject->processEnabledField() ;
+//        buildExpression();
+//        active=true;
+//      }
+//    }
+
+   void CField::solveAllReferenceEnabledField(bool doSending2Sever)
+   {
+     CContext* context = CContext::getCurrent();
+     if (!areAllReferenceSolved)
+     {
+        areAllReferenceSolved = true;
+        if (!context->hasServer)
+        {
+          solveRefInheritance(true);
+          solveBaseReference();
+        }
+
+        solveOperation();
+        solveGridReference();
+     }
+     solveGridDomainAxisRef(doSending2Sever);
+     solveCheckMaskIndex(doSending2Sever);
+   }
+
+   std::map<int, StdSize> CField::getGridDataSize()
+   {
+     return grid->getConnectedServerDataSize();
+   }
+
+   void CField::buildAllExpressionEnabledField()
+   {
+     if (!areAllReferenceSolved) solveAllReferenceEnabledField(true);
+     if (!areAllExpressionBuilt)
+     {
+       areAllExpressionBuilt = true;
+//       solveCheckMaskIndex(true);
+//       solveCheckMaskIndex();
+       if (hasDirectFieldReference()) baseRefObject->buildAllExpressionEnabledField();
+       buildExpression();
+       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)
    {
@@ -397 +446 @@
       CField* refer_sptr;
       CField * refer_ptr = this;
-     
+
       while (refer_ptr->hasDirectFieldReference())
       {
@@ -413 +462 @@
          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");
    }
 
@@ -421 +481 @@
       CField* refer_sptr;
       CField * refer_ptr = this;
-      
+
       if (this->hasDirectFieldReference())  baseRefObject = getDirectFieldReference();
       else  baseRefObject = CField::get(this);
-      
+
       while (refer_ptr->hasDirectFieldReference())
       {
@@ -439 +499 @@
          sset.insert(refer_ptr);
       }
-      
+
       if (hasDirectFieldReference()) baseRefObject->addReference(this) ;
    }
-   
+
    //----------------------------------------------------------------
 
@@ -448 +508 @@
    {
       using namespace func;
-      
+
       if (!hasOutputFile && !hasFieldOut) return ;
-      
+
       StdString id ;
       if (hasId()) id=getId();
       else if (!name.isEmpty()) id=name ;
       else if (hasDirectFieldReference()) id=baseRefObject->getId() ;
-      
+
       CContext* context = CContext::getCurrent();
-      
+
       if (freq_op.isEmpty()) freq_op=string("1ts") ;
-      
+
       if (operation.isEmpty() )
       {
@@ -466 +526 @@
                << "Impossible to define an operation for this field !");
       }
-      
+
       CDuration freq_offset_ = NoneDu;
       if (!freq_offset.isEmpty())
@@ -475 +535 @@
       {
          freq_offset.setValue(NoneDu.toString());
-      }  
+      }
 
 //      if (CXIOSManager::GetStatus() == CXIOSManager::LOC_SERVER)
       if (context->hasServer)
       {
-         if (hasOutputFile) 
+         if (hasOutputFile)
          {
            this->freq_operation_srv =CDuration::FromString(this->file->output_freq.getValue());
@@ -493 +553 @@
 //         this->foperation_srv     =
 //             boost::shared_ptr<func::CFunctor>(new CInstant(this->data_srv));
-             
-         if (hasOutputFile) 
+
+         if (hasOutputFile)
          {
-           const CDuration toffset = this->freq_operation_srv - freq_offset_ - context->getCalendar()->getTimeStep(); 
+           const CDuration toffset = this->freq_operation_srv - freq_offset_ - context->getCalendar()->getTimeStep();
            *this->last_operation_srv   = *this->last_operation_srv - toffset;
          }
       }
-      
+
 //      if (context->hasClient)
-//      {                  
+//      {
          this->freq_operation = CDuration::FromString(freq_op.getValue());
          if (hasOutputFile) this->freq_write     = CDuration::FromString(this->file->output_freq.getValue());
-         if (hasFieldOut) 
+         if (hasFieldOut)
          {
            this->freq_write = CDuration::FromString(this->fieldOut->freq_op.getValue());
@@ -513 +573 @@
          this->last_operation = boost::shared_ptr<CDate>
                         (new CDate(context->getCalendar()->getInitDate()));
-                        
-         const CDuration toffset = this->freq_operation - freq_offset_ - context->getCalendar()->getTimeStep(); 
-         *this->last_operation   = *this->last_operation - toffset;  
-      
+
+         const CDuration toffset = this->freq_operation - freq_offset_ - context->getCalendar()->getTimeStep();
+         *this->last_operation   = *this->last_operation - toffset;
+
         if (operation.get()=="once") isOnceOperation=true ;
         else isOnceOperation=false;
         isFirstOperation=true;
-        
-          
+
+
 #define DECLARE_FUNCTOR(MType, mtype)              \
    if  (operation.getValue().compare(#mtype) == 0) \
@@ -537 +597 @@
       return;                                      \
    }
-   
+
 #include "functor_type.conf"
-         
+
          ERROR("CField::solveOperation(void)",
                << "[ operation = " << operation.getValue() << "]"
                << "The operation is not defined !");
 //      }
-      
-
-   }
-   
+
+
+   }
+
    //----------------------------------------------------------------
 /*
@@ -598 +658 @@
                   << grid_ref.getValue() << "\' is wrong");
       }
-      
+
       if (grid_ref.isEmpty() &&  domain_ref.isEmpty())
       {
@@ -605 +665 @@
 
      }
-     
+
      CType<string> goodDomain ;
      CType<string> goodAxis ;
@@ -615 +675 @@
      if (!domain_ref.isEmpty()) goodDomain=domain_ref ;
      if (!axis_ref.isEmpty()) goodAxis=axis_ref ;
-     
-     
-     if (goodDomain.isEmpty()) 
+
+
+     if (goodDomain.isEmpty())
      {
        ERROR("CField::solveGridReference(void)", << "The horizontal domain for this field is not defined");
      }
-     else 
+     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())
      {
@@ -632 +692 @@
        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()) 
+         else if (!grid->axis_ref.isEmpty())
                  if (grid->axis_ref.get()==goodAxis.get()) nothingToDo=true ;
      }
-     
+
      if (!nothingToDo)
      {
@@ -655 +715 @@
          this->grid = CGrid::createGrid(domain) ;
          this->grid_ref.setValue(this->grid->getId());
-       }    
+       }
      }
 
-     grid->solveReference() ;
-
-   }
-
+//     grid->solveReference() ;
+//     grid->solveDomainAxisRef();
+//     grid->checkMaskIndex();
+   }
+
+   void CField::solveGridDomainAxisRef(bool checkAtt)
+   {
+     grid->solveDomainAxisRef(checkAtt);
+   }
+
+   void CField::solveCheckMaskIndex(bool doSendingIndex)
+   {
+     grid->checkMaskIndex(doSendingIndex);
+   }
 
    ///-------------------------------------------------------------------
@@ -680 +750 @@
 
       std::vector<CField*> allChildren  = group->getAllChildren();
-      std::vector<CField*>::iterator 
+      std::vector<CField*>::iterator
          it = allChildren.begin(), end = allChildren.end();
-      
+
       for (; it != end; it++)
       {
          CField* child = *it;
          if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId()) ;
-            
-      }
-   }
-   
+
+      }
+   }
+
    void CField::scaleFactorAddOffset(double scaleFactor, double addOffset)
    {
@@ -696 +766 @@
      for(it=data_srv.begin();it!=data_srv.end();it++) *it->second = (*it->second -addOffset) * 1./scaleFactor  ;
    }
-   
+
    void CField::outputField(CArray<double,3>& fieldOut)
    {
@@ -702 +772 @@
       for(it=data_srv.begin();it!=data_srv.end();it++)
          grid->outputField(it->first,*it->second, fieldOut) ;
-      
-   }
-   
+
+   }
+
    void CField::outputField(CArray<double,2>& fieldOut)
    {
@@ -719 +789 @@
    {
       SuperClass::parse(node);
-      if (! node.getContent(this->content)) 
+      if (! node.getContent(this->content))
       {
         if (node.goToChildElement())
@@ -731 +801 @@
       }
     }
-    
+
   CArray<double,1>* CField::getInstantData(void)
   {
-    if (!hasInstantData) 
+    if (!hasInstantData)
     {
       instantData.resize(grid->storeIndex_client.numElements()) ;
@@ -741 +811 @@
     return &instantData ;
   }
-  
+
   void CField::addReference(CField* field)
   {
     refObject.push_back(field) ;
   }
-  
+
   void CField::addDependency(CField* field, int slotId)
   {
     fieldDependency.push_back(pair<CField*,int>(field,slotId)) ;
   }
-  
+
   void CField::buildExpression(void)
   {
-    if (content.size() > 0) 
+    if (content.size() > 0)
     {
       CSimpleNodeExpr* simpleExpr=parseExpr(content+'\0') ;
@@ -762 +832 @@
       map<string,CField*> associatedInstantFieldIds ;
       expression->getInstantFieldIds(instantFieldIds) ;
-      for (set<string>::iterator it=instantFieldIds.begin() ; it!=instantFieldIds.end();++it) 
-      {
-        if (*it!="this") 
+      for (set<string>::iterator it=instantFieldIds.begin() ; it!=instantFieldIds.end();++it)
+      {
+        if (*it!="this")
         {
-          if (CField::has(*it)) 
+          if (CField::has(*it))
           {
             CField* field=CField::get(*it) ;
-            field->processEnabledField() ;
+//            field->processEnabledField() ;
+            field->buildAllExpressionEnabledField();
             associatedInstantFieldIds[*it]=field ;
           }
@@ -775 +846 @@
         }
       }
-      
+
       set<string> averageFieldIds ;
       map<string,CField*> associatedAverageFieldIds ;
 
       expression->getAverageFieldIds(averageFieldIds) ;
-      for (set<string>::iterator it=averageFieldIds.begin() ; it!=averageFieldIds.end();++it) 
-      {      
-        if (CField::has(*it)) 
+      for (set<string>::iterator it=averageFieldIds.begin() ; it!=averageFieldIds.end();++it)
+      {
+        if (CField::has(*it))
         {
            CFieldGroup* root=CFieldGroup::get("field_definition") ;
@@ -791 +862 @@
            averageField->fieldOut=instantField ;
            instantField->freq_op=freq_op ;
-           averageField-> processEnabledField() ;
+//           averageField-> processEnabledField() ;
+           averageField->buildAllExpressionEnabledField();
            instantField->SuperClassAttribute::setAttributes(averageField, true);
            instantField->field_ref.reset() ;
            instantField->operation.reset() ;
 
-           instantField-> processEnabledField() ;
+//           instantField-> processEnabledField() ;
+           instantField->buildAllExpressionEnabledField();
            associatedAverageFieldIds[*it]=instantField  ;
         }
@@ -810 +883 @@
       expression->getFields(fields) ;
       for (set<CField*>::iterator it=fields.begin() ; it!=fields.end();++it,++slotId) (*it)->addDependency(this,slotId) ;
-      hasExpression=true; 
-    }
-  }
-  
+      hasExpression=true;
+    }
+  }
+
   void CField::resetSlots(void)
   {
     for(vector<bool>::iterator it=slots.begin();it!=slots.end();++it) *it=false ;
   }
-  
+
   bool CField::slotsFull(void)
   {
@@ -826 +899 @@
   }
 
-  
+
   void CField::setSlot(int slotId)
   {
     CContext* context = CContext::getCurrent() ;
     const CDate & currDate = context->getCalendar()->getCurrentDate();
-    if (slotUpdateDate==NULL || currDate!=*slotUpdateDate) 
+    if (slotUpdateDate==NULL || currDate!=*slotUpdateDate)
     {
       resetSlots() ;
@@ -841 +914 @@
     {
       CArray<double,1> expr(expression->compute()) ;
-      
-      if (hasInstantData) 
+
+      if (hasInstantData)
       {
         instantData=expr ;
-        for(list< pair<CField *,int> >::iterator it=fieldDependency.begin(); it!=fieldDependency.end(); ++it)  
+        for(list< pair<CField *,int> >::iterator it=fieldDependency.begin(); it!=fieldDependency.end(); ++it)
           if (it->first!=this) it->first->setSlot(it->second) ;
       }
-      
+
       if (hasOutputFile) updateDataFromExpression(expr) ;
-      
-    }
-  }
-
-
+
+    }
+  }
+
+   /*!
+     This function retrieves Id of corresponding domain_ref and axis_ref (if any)
+   of a field. In some cases, only domain exists but axis doesn't
+   \return pair of Domain and Axis id
+   */
+   const std::pair<StdString,StdString>& CField::getDomainAxisIds()
+   {
+     CGrid* cgPtr = getRelGrid();
+     if (NULL != cgPtr)
+     {
+       if (NULL != cgPtr->getRelDomain()) domAxisIds_.first = cgPtr->getRelDomain()->getId();
+       if (NULL != cgPtr->getRelAxis()) domAxisIds_.second = cgPtr->getRelAxis()->getId();
+     }
+
+     return (domAxisIds_);
+   }
 
    CVariable* CField::addVariable(const string& id)
@@ -867 +955 @@
 
 
+   void CField::sendAddAllVariables()
+   {
+     if (!getAllVariables().empty())
+     {
+       // Firstly, it's necessary to add virtual variable group
+       sendAddVariableGroup(getVirtualVariableGroup()->getId());
+
+       // Okie, now we can add to this variable group
+       std::vector<CVariable*> allVar = getAllVariables();
+       std::vector<CVariable*>::const_iterator it = allVar.begin();
+       std::vector<CVariable*>::const_iterator itE = allVar.end();
+
+       for (; it != itE; ++it)
+       {
+         std::cout << "Variable Fields " << (*it)->getId() << std::endl;
+         this->sendAddVariable((*it)->getId());
+         (*it)->sendAllAttributesToServer();
+         (*it)->sendValue();
+       }
+     }
+   }
+
    void CField::sendAddVariable(const string& id)
    {
     CContext* context=CContext::getCurrent() ;
-    
+
     if (! context->hasServer )
     {
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE) ;
        if (client->isServerLeader())
        {
@@ -886 +996 @@
        else client->sendEvent(event) ;
     }
-      
-   }
- 
-   
+
+   }
+
+
    void CField::sendAddVariableGroup(const string& id)
    {
@@ -897 +1007 @@
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP) ;
        if (client->isServerLeader())
        {
@@ -908 +1018 @@
        else client->sendEvent(event) ;
     }
-      
-   }
-   
+
+   }
+
    void CField::recvAddVariable(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -919 +1029 @@
       get(id)->recvAddVariable(*buffer) ;
    }
-   
-   
+
+
    void CField::recvAddVariable(CBufferIn& buffer)
    {
@@ -930 +1040 @@
    void CField::recvAddVariableGroup(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -936 +1046 @@
       get(id)->recvAddVariableGroup(*buffer) ;
    }
-   
-   
+
+
    void CField::recvAddVariableGroup(CBufferIn& buffer)
    {
@@ -947 +1057 @@
 
 
-  
+
 } // namespace xios

XIOS/trunk/src/node/field.hpp

@@ -18 +18 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Déclarations ////////////////////// ///
 
@@ -56 +56 @@
            EVENT_ID_UPDATE_DATA, EVENT_ID_ADD_VARIABLE, EVENT_ID_ADD_VARIABLE_GROUP
          } ;
-         
+
          /// Constructeurs ///
          CField(void);
@@ -83 +83 @@
 
          boost::shared_ptr<func::CFunctor> getFieldOperation(void) const;
-         
+
          CArray<double, 1> getData(void) const;
 
@@ -95 +95 @@
          template <int N> bool updateData(const CArray<double, N>&   data);
          bool updateDataFromExpression(const CArray<double, 1>&   data);
-         void setDataFromExpression(const CArray<double, 1>& _data) ;         
-         
+         void setDataFromExpression(const CArray<double, 1>& _data) ;
+
          bool updateDataServer
                (const CDate & currDate,
                 const std::deque< CArray<double, 1>* > storedClient);
- 
+
+         std::map<int, StdSize> getGridDataSize();
+
        public :
 
@@ -116 +118 @@
          void solveGridReference(void);
          void solveOperation(void);
+         void solveCheckMaskIndex(bool doSendingIndex);
+         void solveAllReferenceEnabledField(bool doSending2Sever);
+         void buildAllExpressionEnabledField();
+         void solveGridDomainAxisRef(bool checkAtt);
+         void removeRefInheritance();  // Remove all reference of current field (it refers to itself)
 
 //         virtual void fromBinary(StdIStream & is);
@@ -125 +132 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-         
+
          static ENodeType GetType(void);
-         
+
         template <int N> void setData(const CArray<double, N>& _data) ;
         static bool dispatchEvent(CEventServer& event) ;
@@ -139 +146 @@
         void parse(xml::CXMLNode & node) ;
         CArray<double,1>* getInstantData(void)  ;
-        
+
         void setVirtualVariableGroup(CVariableGroup* newVVariableGroup);
         void setVirtualVariableGroup(void);
@@ -145 +152 @@
         vector<CVariable*> getAllVariables(void) const;
         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
- 
+
         CVariable* addVariable(const string& id="") ;
         CVariableGroup* addVariableGroup(const string& id="") ;
@@ -154 +161 @@
         static void recvAddVariableGroup(CEventServer& event) ;
         void recvAddVariableGroup(CBufferIn& buffer) ;
-       
+        void sendAddAllVariables();
+
+
+        const std::pair<StdString, StdString>& getDomainAxisIds();
       public :
 
          /// Propriétés privées ///
          CVariableGroup* vVariableGroup ;
-                 
+
          std::vector<CField*> refObject;
          CField* baseRefObject;
@@ -172 +182 @@
          boost::shared_ptr<CDate>    last_Write, last_operation;
          boost::shared_ptr<CDate>    lastlast_Write_srv,last_Write_srv, last_operation_srv;
-         
+
          boost::shared_ptr<func::CFunctor> foperation;
          map<int,boost::shared_ptr<func::CFunctor> > foperation_srv;
-         
+
          CArray<double, 1> data;
          CArray<double, 1> instantData;
@@ -183 +193 @@
          bool isFirstOperation ;
          string content ;
-         
+
          list< pair<CField *,int> > fieldDependency ;
          void buildExpression(void) ;
@@ -195 +205 @@
          void setSlot(int slotId);
          bool processed ;
+         bool areAllReferenceSolved;
+         bool areAllExpressionBuilt;
+         std::pair<StdString,StdString> domAxisIds_;
 
    }; // class CField

XIOS/trunk/src/node/file.cpp

@@ -18 +18 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Définitions ////////////////////// ///
 
@@ -24 +24 @@
       : CObjectTemplate<CFile>(), CFileAttributes()
       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
-   { 
+   {
      setVirtualFieldGroup() ;
      setVirtualVariableGroup() ;
@@ -32 +32 @@
       : CObjectTemplate<CFile>(id), CFileAttributes()
       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL)
-    { 
+    {
       setVirtualFieldGroup() ;
       setVirtualVariableGroup() ;
@@ -41 +41 @@
 
    ///---------------------------------------------------------------
-
+  //! Get name of file
    StdString CFile::GetName(void)   { return (StdString("file")); }
    StdString CFile::GetDefName(void){ return (CFile::GetName()); }
@@ -47 +47 @@
 
    //----------------------------------------------------------------
-
+   /*!
+   \brief Get data that will be written out.
+   Each enabled file in xml represents a physical netcdf file.
+   This function allows to access to data to be written out into netcdf file
+   \return data written out.
+   */
    boost::shared_ptr<CDataOutput> CFile::getDataOutput(void) const
    {
@@ -53 +58 @@
    }
 
+   /*!
+   \brief Get virtual field group
+      In each file, there always exists a field group which is the ancestor of all
+   fields in the file. This is considered be virtual because it is created automatically during
+   file initialization and it normally doesn't appear on xml file
+   \return Pointer to field group
+   */
    CFieldGroup* CFile::getVirtualFieldGroup(void) const
    {
@@ -58 +70 @@
    }
 
+   /*!
+   \brief Get virtual variable group
+      In each file, there always exists a variable group which is the ancestor of all
+   variable in the file. This is considered be virtual because it is created automatically during
+   file initialization and it normally doesn't appear on xml file
+   \return Pointer to variable group
+   */
    CVariableGroup* CFile::getVirtualVariableGroup(void) const
    {
@@ -63 +82 @@
    }
 
+   //! Get all fields of a file
    std::vector<CField*> CFile::getAllFields(void) const
    {
       return (this->vFieldGroup->getAllChildren());
    }
- 
+
+   //! Get all variables of a file
    std::vector<CVariable*> CFile::getAllVariables(void) const
    {
@@ -74 +95 @@
 
    //----------------------------------------------------------------
-
-   std::vector<CField*> CFile::getEnabledFields(int default_outputlevel, 
+   /*!
+   \brief Get all enabled fields of file
+      A field is considered to be enabled if it fullfil these conditions: it is enabled, inside a enabled file
+   and its own level is not larger than file output level.
+   \param [in] default_outputlevel default value output level of file
+   \param [in] default_level default value level of field
+   \param [in] default_enabled flag determine by default if field is enabled
+   \return Vector of pointers of enabled fields
+   */
+   std::vector<CField*> CFile::getEnabledFields(int default_outputlevel,
                                                 int default_level,
                                                 bool default_enabled)
@@ -88 +117 @@
 
       std::vector<CField*> newEnabledFields;
-      
+
       for ( it = this->enabledFields.begin() ; it != this->enabledFields.end(); it++ )
       {
@@ -112 +141 @@
 //            { it--; this->enabledFields.erase(it+1); continue; }
          }
- 
+
 //         CField* field_tmp=(*it).get() ;
 //         shared_ptr<CField> sptfield=*it ;
@@ -130 +159 @@
 
    //----------------------------------------------------------------
-
+   //! Change virtual field group to a new one
    void CFile::setVirtualFieldGroup(CFieldGroup* newVFieldGroup)
-   { 
-      this->vFieldGroup = newVFieldGroup; 
-   }
-
+   {
+      this->vFieldGroup = newVFieldGroup;
+   }
+
+   //! Change virtual variable group to new one
    void CFile::setVirtualVariableGroup(CVariableGroup* newVVariableGroup)
-   { 
-      this->vVariableGroup = newVVariableGroup; 
-   }
-
-   //----------------------------------------------------------------
-
+   {
+      this->vVariableGroup = newVVariableGroup;
+   }
+
+   //----------------------------------------------------------------
+   //! Create virtual field group, which is done normally on initializing file
    void CFile::setVirtualFieldGroup(void)
    {
@@ -148 +178 @@
    }
 
+   //! Create virtual variable group, which is done normally on initializing file
    void CFile::setVirtualVariableGroup(void)
    {
@@ -168 +199 @@
       return false ;
     }
-    
+
+   //! Initialize a file in order to write into it
    void CFile::initFile(void)
    {
@@ -174 +206 @@
       CDate& currentDate=context->calendar->getCurrentDate() ;
       CContextServer* server=context->server ;
-            
+
       if (! sync_freq.isEmpty()) syncFreq = CDuration::FromString(sync_freq.getValue());
       if (! split_freq.isEmpty()) splitFreq = CDuration::FromString(split_freq.getValue());
@@ -194 +226 @@
       nbDomain=setDomain.size() ;
 
-      // create sub communicator for file  
+      // create sub communicator for file
       int color=allDomainEmpty?0:1 ;
       MPI_Comm_split(server->intraComm,color,server->intraCommRank,&fileComm) ;
       if (allDomainEmpty) MPI_Comm_free(&fileComm) ;
       //
-      
-    }
-    
+
+    }
+
+    //! Verify state of a file
     void CFile::checkFile(void)
     {
@@ -208 +241 @@
       checkSplit() ;
     }
-      
-     
+
+
+    /*!
+    \brief Verify if synchronisation should be done
+        If syn option is enabled, syn frequence and current time will be used to
+    calculate the moment to syn file(s)
+    \return True if it is the moment to synchronize file, otherwise false
+    */
    bool CFile::checkSync(void)
    {
@@ -225 +264 @@
       return false ;
     }
-    
-    
+
+    /*!
+    \brief Verify if splitting should be done
+        If split option is enabled, split frequence and current time will be used to
+    calculate the moment to split file
+    \return True if it is the moment to split file, otherwise false
+    */
     bool CFile::checkSplit(void)
     {
@@ -235 +279 @@
         if (currentDate > *lastSplit+splitFreq)
         {
-          *lastSplit=*lastSplit+splitFreq ;    
+          *lastSplit=*lastSplit+splitFreq ;
           std::vector<CField*>::iterator it, end = this->enabledFields.end();
           for (it = this->enabledFields.begin() ;it != end; it++)  (*it)->resetNStep() ;
@@ -244 +288 @@
       return false ;
     }
-    
+
+   /*!
+   \brief Create header of netcdf file
+   There are some information to fill in header of each netcdf.
+   */
    void CFile::createHeader(void)
    {
       CContext* context = CContext::getCurrent() ;
       CContextServer* server=context->server ;
-     
+
       if (!allDomainEmpty)
       {
@@ -273 +321 @@
            oss<<"_"<<lastSplit->getStr(splitFormat)<<"-"<< (*lastSplit+(splitFreq-1*Second)).getStr(splitFormat);
          }
-           
+
          bool multifile=true ;
          if (!type.isEmpty())
@@ -280 +328 @@
            else if (type==type_attr::multiple_file) multifile=true ;
 
-         } 
+         }
 #ifndef USING_NETCDF_PAR
          if (!multifile)
@@ -288 +336 @@
           }
 #endif
-         if (multifile) 
+         if (multifile)
          {
             int commSize, commRank ;
             MPI_Comm_size(fileComm,&commSize) ;
             MPI_Comm_rank(fileComm,&commRank) ;
-            
-            if (server->intraCommSize > 1) 
+
+            if (server->intraCommSize > 1)
             {
               oss << "_"  ;
               int width=0 ; int n=commSize-1 ;
               while(n != 0) { n=n/10 ; width++ ;}
-              if (!min_digits.isEmpty()) 
+              if (!min_digits.isEmpty())
                 if (width<min_digits) width=min_digits ;
               oss.width(width) ;
@@ -314 +362 @@
            if (par_access.getValue()=="independent") isCollective=false ;
            else if (par_access.getValue()=="collective") isCollective=true ;
-           else 
+           else
            {
              ERROR("void Context::createDataOutput(void)",
@@ -332 +380 @@
          }
          this->data_out->writeTimeDimension();
-         
+
          for (it = this->enabledFields.begin() ;it != end; it++)
          {
@@ -338 +386 @@
             this->data_out->writeField(field);
          }
-         
+
          vector<CVariable*> listVars = getAllVariables() ;
          for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) this-> data_out-> writeAttribute(*it) ;
-         
+
          this->data_out->definition_end();
       }
    }
 
+   //! Close file
    void CFile::close(void)
    {
@@ -351 +400 @@
      delete lastSplit ;
      if (!allDomainEmpty)
-       if (isOpen) 
+       if (isOpen)
        {
          this->data_out->closeFile();
@@ -359 +408 @@
    //----------------------------------------------------------------
 
+   /*!
+   \brief Parse xml file and write information into file object
+   \param [in] node xmld node corresponding in xml file
+   */
    void CFile::parse(xml::CXMLNode & node)
    {
       SuperClass::parse(node);
-      
+
       if (node.goToChildElement())
       {
@@ -376 +429 @@
    //----------------------------------------------------------------
 
+   /*!
+   \brief Represent a file in form of string with all its info
+   \return String
+   */
    StdString CFile::toString(void) const
    {
@@ -391 +448 @@
 
    //----------------------------------------------------------------
-   
+
+   /*!
+   \brief Find all inheritace among objects in a file.
+   \param [in] apply (true) write attributes of parent into ones of child if they are empty
+                     (false) write attributes of parent into a new container of child
+   \param [in] parent
+   */
    void CFile::solveDescInheritance(bool apply, const CAttributeMap * const parent)
    {
       SuperClassAttribute::setAttributes(parent,apply);
-      this->getVirtualFieldGroup()->solveDescInheritance(apply, NULL); 
+      this->getVirtualFieldGroup()->solveDescInheritance(apply, NULL);
       this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL);
    }
@@ -401 +464 @@
    //----------------------------------------------------------------
 
-   void CFile::processEnabledFile(void)
-   {
-     if (output_freq.isEmpty()) ERROR("void CFile::processEnabledFile(void)",
-                                       <<"File attribute <<output_freq>> is undefined"); 
-     solveFieldRefInheritance(true) ;
-     getEnabledFields() ;
-     processEnabledFields() ;
-   }
-   
-   void CFile::processEnabledFields(void)
-   {
-      for (unsigned int i = 0; i < this->enabledFields.size(); i++)
-      {
-        this->enabledFields[i]->processEnabledField() ;
-      }
-    }
-    
+//   void CFile::processEnabledFile(void)
+//   {
+//     if (output_freq.isEmpty()) ERROR("void CFile::processEnabledFile(void)",
+//                                       <<"File attribute <<output_freq>> is undefined");
+//     solveFieldRefInheritance(true) ;
+//     getEnabledFields() ;
+//     processEnabledFields() ;
+//   }
+
+//   void CFile::processEnabledFields(void)
+//   {
+//      for (unsigned int i = 0; i < this->enabledFields.size(); i++)
+//      {
+//        this->enabledFields[i]->processEnabledField() ;
+//      }
+//   }
+
+   /*!
+   \brief Resolve all reference of active fields.
+      In order to know exactly which data each active field has, a search for all its
+   reference to find its parents or/and its base reference object must be done. Moreover
+   during this search, there are some information that can only be sent to server AFTER
+   all information of active fields are created on server side, e.g: checking mask or index
+   \param [in] sendToServer: Send all info to server (true) or only a part of it (false)
+   */
+   void CFile::solveAllRefOfEnabledFields(bool sendToServer)
+   {
+     int size = this->enabledFields.size();
+     for (int i = 0; i < size; ++i)
+     {
+       this->enabledFields[i]->solveAllReferenceEnabledField(sendToServer);
+     }
+   }
+
+   /*!
+   \brief Contruct all expression related to active fields.
+      Each field can do some expressions which appear on the xml file, and itself can be
+   a result of an expression among some other fields. This function builds all possible expression
+   relating to active fields.
+   */
+   void CFile::buildAllExpressionOfEnabledFields()
+   {
+     int size = this->enabledFields.size();
+     for (int i = 0; i < size; ++i)
+     {
+       this->enabledFields[i]->buildAllExpressionEnabledField();
+     }
+   }
+
    void CFile::solveFieldRefInheritance(bool apply)
    {
@@ -441 +536 @@
          this->enabledFields[i]->solveOperation();
    }
- 
+
    void CFile::solveEFExpression(void)
    {
       for (unsigned int i = 0; i < this->enabledFields.size(); i++)
          this->enabledFields[i]->buildExpression();
-   }   
- 
-
+   }
+
+   /*!
+   \brief Add a field into file.
+      A field is added into file and it will be written out if the file is enabled and
+   level of this field is smaller than level_output. A new field won't be created if one
+   with id has already existed
+   \param [in] id String identity of new field
+   \return Pointer to added (or already existed) field
+   */
    CField* CFile::addField(const string& id)
    {
@@ -454 +556 @@
    }
 
+   /*!
+   \brief Add a field group into file.
+      A field group is added into file and it will play a role as parents for fields.
+   A new field group won't be created if one with id has already existed
+   \param [in] id String identity of new field group
+   \return Pointer to added (or already existed) field group
+   */
    CFieldGroup* CFile::addFieldGroup(const string& id)
    {
      return vFieldGroup->createChildGroup(id) ;
    }
- 
+
+   /*!
+   \brief Add a variable into file.
+      A variable is added into file and if one with id has already existed, pointer to
+   it will be returned.
+      Variable as long as attributes are information container of file.
+   However, whereas attributes are "fixed" information, variables provides a more flexible way to user
+   to fill in (extra) information for a file.
+   \param [in] id String identity of new variable
+   \return Pointer to added (or already existed) variable
+   */
    CVariable* CFile::addVariable(const string& id)
    {
@@ -464 +583 @@
    }
 
+   /*!
+   \brief Add a variable group into file.
+      A variable group is added into file and it will play a role as parents for variables.
+   A new variable group won't be created if one with id has already existed
+   \param [in] id String identity of new variable group
+   \return Pointer to added (or already existed) variable group
+   */
    CVariableGroup* CFile::addVariableGroup(const string& id)
    {
      return vVariableGroup->createChildGroup(id) ;
    }
-   
-  
+
+   /*!
+   \brief Send a message to create a field on server side
+   \param[in] id String identity of field that will be created on server
+   */
    void CFile::sendAddField(const string& id)
    {
     CContext* context=CContext::getCurrent() ;
-    
+
     if (! context->hasServer )
     {
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_FIELD) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_FIELD) ;
        if (client->isServerLeader())
        {
@@ -489 +618 @@
        else client->sendEvent(event) ;
     }
-      
-   }
-   
+
+   }
+
+   /*!
+   \brief Send a message to create a field group on server side
+   \param[in] id String identity of field group that will be created on server
+   */
    void CFile::sendAddFieldGroup(const string& id)
    {
@@ -499 +632 @@
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_FIELD_GROUP) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_FIELD_GROUP) ;
        if (client->isServerLeader())
        {
@@ -510 +643 @@
        else client->sendEvent(event) ;
     }
-      
-   }
-   
+
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of a field on server side
+   \param[in] event Received event
+   */
    void CFile::recvAddField(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -521 +658 @@
       get(id)->recvAddField(*buffer) ;
    }
-   
-   
+
+   /*!
+   \brief Receive a message annoucing the creation of a field on server side
+   \param[in] buffer Buffer containing message
+   */
    void CFile::recvAddField(CBufferIn& buffer)
    {
@@ -530 +670 @@
    }
 
+   /*!
+   \brief Receive a message annoucing the creation of a field group on server side
+   \param[in] event Received event
+   */
    void CFile::recvAddFieldGroup(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -538 +682 @@
       get(id)->recvAddFieldGroup(*buffer) ;
    }
-   
-   
+
+   /*!
+   \brief Receive a message annoucing the creation of a field group on server side
+   \param[in] buffer Buffer containing message
+   */
    void CFile::recvAddFieldGroup(CBufferIn& buffer)
    {
@@ -546 +693 @@
       addFieldGroup(id) ;
    }
-   
-
-
-
-
-
-
-
-
-
-
+
+   /*!
+   \brief Send messages to duplicate all variables on server side
+      Because each variable has also its attributes. So first thing to do is replicate
+   all these attributes on server side. Because variable can have a value, the second thing
+   is to duplicate this value on server, too.
+   */
+   void CFile::sendAddAllVariables()
+   {
+     if (!getAllVariables().empty())
+     {
+       // Firstly, it's necessary to add virtual variable group
+       sendAddVariableGroup(getVirtualVariableGroup()->getId());
+
+       // Okie, now we can add to this variable group
+       std::vector<CVariable*> allVar = getAllVariables();
+       std::vector<CVariable*>::const_iterator it = allVar.begin();
+       std::vector<CVariable*>::const_iterator itE = allVar.end();
+
+       for (; it != itE; ++it)
+       {
+         std::cout << "Variable Files " << (*it)->getId() << std::endl;
+         this->sendAddVariable((*it)->getId());
+         (*it)->sendAllAttributesToServer();
+         (*it)->sendValue();
+       }
+     }
+   }
+
+   /*!
+   \brief Send a message to create a variable on server side
+      A variable always belongs to a variable group
+   \param[in] id String identity of variable that will be created on server
+   */
    void CFile::sendAddVariable(const string& id)
    {
     CContext* context=CContext::getCurrent() ;
-    
+
     if (! context->hasServer )
     {
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE) ;
        if (client->isServerLeader())
        {
@@ -576 +746 @@
        else client->sendEvent(event) ;
     }
-      
-   }
-   
+
+   }
+
+   /*!
+   \brief Send a message to create a variable group on server side
+   \param[in] id String identity of variable group that will be created on server
+   */
    void CFile::sendAddVariableGroup(const string& id)
    {
@@ -586 +760 @@
        CContextClient* client=context->client ;
 
-       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP) ;   
+       CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP) ;
        if (client->isServerLeader())
        {
@@ -597 +771 @@
        else client->sendEvent(event) ;
     }
-      
-   }
-   
+
+   }
+
+   /*!
+   \brief Receive a message annoucing the creation of a variable on server side
+   \param[in] event Received event
+   */
    void CFile::recvAddVariable(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -608 +786 @@
       get(id)->recvAddVariable(*buffer) ;
    }
-   
-   
+
+   /*!
+   \brief Receive a message annoucing the creation of a variable on server side
+   \param[in] buffer Buffer containing message
+   */
    void CFile::recvAddVariable(CBufferIn& buffer)
    {
@@ -617 +798 @@
    }
 
+   /*!
+   \brief Receive a message annoucing the creation of a variable group on server side
+   \param[in] event Received event
+   */
    void CFile::recvAddVariableGroup(CEventServer& event)
    {
-      
+
       CBufferIn* buffer=event.subEvents.begin()->buffer;
       string id;
@@ -625 +810 @@
       get(id)->recvAddVariableGroup(*buffer) ;
    }
-   
-   
+
+   /*!
+   \brief Receive a message annoucing the creation of a variable group on server side
+   \param[in] buffer Buffer containing message
+   */
    void CFile::recvAddVariableGroup(CBufferIn& buffer)
    {
@@ -634 +822 @@
    }
 
-
-
-
-
+   /*!
+     \brief Sending all active (enabled) fields from client to server.
+   Each field is identified uniquely by its string identity. Not only should we
+   send the id to server but also we need to send ids of reference domain and reference axis.
+   With these two id, it's easier to make reference to grid where all data should be written.
+   Remark: This function must be called AFTER all active (enabled) files have been created on the server side
+   */
+   void CFile::sendEnabledFields()
+   {
+     int size = this->enabledFields.size();
+     CField* fieldPtr(0);
+     for (int i = 0; i < size; ++i)
+     {
+       fieldPtr = this->enabledFields[i];
+       if (fieldPtr->name.isEmpty()) fieldPtr->name.setValue(fieldPtr->getBaseFieldReference()->getId());
+       std::cout << "Enabled Fields " << i << " " << CField::get(fieldPtr)->getId() << std::endl;
+       this->sendAddField(fieldPtr->getId());
+       fieldPtr->sendAllAttributesToServer();
+       fieldPtr->sendAddAllVariables();
+     }
+   }
+
+   /*!
+   \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 CFile::dispatchEvent(CEventServer& event)
    {
@@ -649 +862 @@
              return true ;
              break ;
-         
+
            case EVENT_ID_ADD_FIELD_GROUP :
              recvAddFieldGroup(event) ;
              return true ;
-             break ;       
- 
+             break ;
+
             case EVENT_ID_ADD_VARIABLE :
              recvAddVariable(event) ;
              return true ;
              break ;
-         
+
            case EVENT_ID_ADD_VARIABLE_GROUP :
              recvAddVariableGroup(event) ;
              return true ;
-             break ;               
+             break ;
            default :
               ERROR("bool CFile::dispatchEvent(CEventServer& event)", <<"Unknown Event") ;
@@ -670 +883 @@
       }
    }
-   
-   
-   
-   
+
+
+
+
    ///---------------------------------------------------------------
 

XIOS/trunk/src/node/file.hpp

@@ -15 +15 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Déclarations ////////////////////// ///
 
@@ -31 +31 @@
    ///--------------------------------------------------------------
 
+   /*!
+   \class CFile
+   This class corresponds to file component of the xml.
+   The class contains all the nessceary information to write data into a netcdf file: The most important thing
+   is the field(s) which will be written into file. Besides, there are some options to write
+   data into file, e.g: writting into only one file or multiple file; splitting a running into several files.
+   Moreover, there are some other attributes of netcdf file which are also stored in this class
+   */
    class CFile
       : public CObjectTemplate<CFile>
@@ -38 +46 @@
          typedef CObjectTemplate<CFile>   SuperClass;
          typedef CFileAttributes SuperClassAttribute;
-      
+
       public :
          enum EEventId
          {
-           EVENT_ID_ADD_FIELD=0,EVENT_ID_ADD_FIELD_GROUP, EVENT_ID_ADD_VARIABLE,EVENT_ID_ADD_VARIABLE_GROUP
+           EVENT_ID_ADD_FIELD=0,EVENT_ID_ADD_FIELD_GROUP, EVENT_ID_ADD_VARIABLE,
+           EVENT_ID_ADD_VARIABLE_GROUP, EVENT_ID_CREATE_ENABLED_FIELDS
          } ;
-         
+
          typedef CFileAttributes RelAttributes;
          typedef CFileGroup      RelGroup;
@@ -54 +63 @@
          CFile(const CFile * const file); // Not implemented yet.
 
+         /// Destructeur ///
+         virtual ~CFile(void);
+
+      public:
          /// Accesseurs ///
          boost::shared_ptr<CDataOutput> getDataOutput(void) const;
@@ -66 +79 @@
 
       public :
-
-         /// Mutateurs ///
-         void setVirtualFieldGroup(CFieldGroup* newVFieldGroup);
-         void setVirtualFieldGroup(void);
-         void setVirtualVariableGroup(CVariableGroup* newVVariableGroup);
-         void setVirtualVariableGroup(void);
-         void processEnabledFile(void) ;
-         void processEnabledFields(void) ;
-         void createHeader(void);
-         void close(void) ;
-         
-         /// Traitements ///
-         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
-         void solveFieldRefInheritance(bool apply);
-         void solveEFGridRef(void);
-         void solveEFOperation(void);
-         void solveEFExpression(void);
-
-         /// Destructeur ///
-         virtual ~CFile(void);
-
-         /// Autres ///
-         virtual void parse(xml::CXMLNode & node);
-         virtual StdString toString(void) const;
-         
-//         virtual void toBinary  (StdOStream & os) const;
-//         virtual void fromBinary(StdIStream & is);
-
-         /// Accesseurs statiques ///
-         static StdString GetName(void);
-         static StdString GetDefName(void);
-         
-         static ENodeType GetType(void);
-         
-         bool allDomainEmpty ;
-         CField* addField(const string& id="") ;
-         CFieldGroup* addFieldGroup(const string& id="") ;
-         CVariable* addVariable(const string& id="") ;
-         CVariableGroup* addVariableGroup(const string& id="") ;
-         void sendAddField(const string& id="") ;
-         void sendAddFieldGroup(const string& id="") ;
-         static void recvAddField(CEventServer& event) ;
-         void recvAddField(CBufferIn& buffer) ;
-         static void recvAddFieldGroup(CEventServer& event) ;
-         void recvAddFieldGroup(CBufferIn& buffer) ;
-         
-         void sendAddVariable(const string& id="") ;
-         void sendAddVariableGroup(const string& id="") ;
-         static void recvAddVariable(CEventServer& event) ;
-         void recvAddVariable(CBufferIn& buffer) ;
-         static void recvAddVariableGroup(CEventServer& event) ;
-         void recvAddVariableGroup(CBufferIn& buffer) ;
-         static bool dispatchEvent(CEventServer& event) ;
-         
+         // Some functions to verify state of file
          bool isSyncTime(void) ;
          bool checkSplit(void) ;
@@ -125 +85 @@
          void checkFile(void) ;
          void initFile(void) ;
+
+         /// Mutateurs ///
+         // Set some root definitions in a file
+         void setVirtualFieldGroup(CFieldGroup* newVFieldGroup);
+         void setVirtualFieldGroup(void);
+         void setVirtualVariableGroup(CVariableGroup* newVVariableGroup);
+         void setVirtualVariableGroup(void);
+
+         void createHeader(void);
+         void close(void) ;
+
+         // Some processing on file
+         void solveFieldRefInheritance(bool apply);
+         void solveEFGridRef(void);
+         void solveEFOperation(void);
+         void solveEFExpression(void);
+         void processEnabledFile(void) ;
+         void processEnabledFields(void) ;
+         void solveAllRefOfEnabledFields(bool sendToServer);
+         void buildAllExpressionOfEnabledFields();
+
+         // Add component into file
+         CField* addField(const string& id="") ;
+         CFieldGroup* addFieldGroup(const string& id="") ;
+         CVariable* addVariable(const string& id="") ;
+         CVariableGroup* addVariableGroup(const string& id="") ;
+
+         // Send info to serever
+         void sendEnabledFields();
+         void sendAddField(const string& id="") ;
+         void sendAddFieldGroup(const string& id="") ;
+         void sendAddAllVariables();
+         void sendAddVariable(const string& id="") ;
+         void sendAddVariableGroup(const string& id="") ;
+
+         // Receive info from client
+         static void recvAddField(CEventServer& event) ;
+         void recvAddField(CBufferIn& buffer) ;
+         static void recvAddFieldGroup(CEventServer& event) ;
+         void recvAddFieldGroup(CBufferIn& buffer) ;
+         static void recvAddVariable(CEventServer& event) ;
+         void recvAddVariable(CBufferIn& buffer) ;
+         static void recvAddVariableGroup(CEventServer& event) ;
+         void recvAddVariableGroup(CBufferIn& buffer) ;
+
+         // Dispatch event
+         static bool dispatchEvent(CEventServer& event) ;
+
+      public:
+         /// Accesseurs statiques ///
+         static StdString GetName(void);
+         static StdString GetDefName(void);
+
+         static ENodeType GetType(void);
+      public:
+         /// Traitements ///
+         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
+
+          /// Autres ///
+         virtual void parse(xml::CXMLNode & node);
+         virtual StdString toString(void) const;
+      public:
+
          CDate* lastSync ;
          CDate* lastSplit ;
@@ -132 +155 @@
          int nbDomain ;
          bool isOpen ;
+         bool allDomainEmpty ;
          MPI_Comm fileComm ;
+
       private :
-
          /// Propriétés privées ///
          CFieldGroup* vFieldGroup;
@@ -140 +164 @@
          boost::shared_ptr<CDataOutput> data_out;
          std::vector<CField*> enabledFields;
+
+      public:
+        //         virtual void toBinary  (StdOStream & os) const;
+        //         virtual void fromBinary(StdIStream & is);
 
    }; // class CFile

XIOS/trunk/src/node/grid.cpp

@@ -19 +19 @@
    CGrid::CGrid(void)
       : CObjectTemplate<CGrid>(), CGridAttributes()
-      , withAxis(false), isChecked(false), axis(), domain()
-      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1)
+      , 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 */ }
 
    CGrid::CGrid(const StdString & id)
       : CObjectTemplate<CGrid>(id), CGridAttributes()
-      , withAxis(false), isChecked(false), axis(), domain()
-      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1)
+      , 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 */ }
 
    CGrid::~CGrid(void)
-   { 
+   {
  //     this->axis.reset() ;
 //      this->domain.reset() ;
     deque< CArray<int, 1>* >::iterator it ;
-    
+
     for(deque< CArray<int,1>* >::iterator it=storeIndex.begin(); it!=storeIndex.end();it++)  delete *it ;
     for(deque< CArray<int,1>* >::iterator it=out_i_index.begin();it!=out_i_index.end();it++) delete *it ;
@@ -55 +55 @@
 
    const std::deque< CArray<int,1>* > & CGrid::getStoreIndex(void) const
-   { 
+   {
       return (this->storeIndex );
    }
@@ -62 +62 @@
 
    const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const
-   { 
-      return (this->out_i_index ); 
+   {
+      return (this->out_i_index );
    }
 
@@ -69 +69 @@
 
    const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const
-   { 
-      return (this->out_j_index ); 
+   {
+      return (this->out_j_index );
    }
 
@@ -76 +76 @@
 
    const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const
-   { 
-      return (this->out_l_index ); 
+   {
+      return (this->out_l_index );
    }
 
@@ -83 +83 @@
 
    const CAxis*   CGrid::getRelAxis  (void) const
-   { 
-      return (this->axis ); 
+   {
+      return (this->axis );
    }
 
@@ -90 +90 @@
 
    const CDomain* CGrid::getRelDomain(void) const
-   { 
-      return (this->domain ); 
-   }
-
-   //---------------------------------------------------------------
-
-   bool CGrid::hasAxis(void) const 
-   { 
-      return (this->withAxis); 
+   {
+      return (this->domain );
+   }
+
+   //---------------------------------------------------------------
+
+   bool CGrid::hasAxis(void) const
+   {
+      return (this->withAxis);
    }
 
@@ -122 +122 @@
 */
    //---------------------------------------------------------------
-   
+
 /*
    StdSize CGrid::getLocalSize(void) const
@@ -147 +147 @@
    //---------------------------------------------------------------
 
-/*   
+/*
    StdSize CGrid::getGlobalSize(void) const
    {
@@ -166 +166 @@
    }
 
-   //---------------------------------------------------------------
-
-   void CGrid::solveReference(void)
-   {
-      if (this->isChecked) return;
-      CContext* context = CContext::getCurrent() ;
-      CContextClient* client=context->client ;
-      
-      this->solveDomainRef() ;
-      this->solveAxisRef() ;
-        
-      if (context->hasClient)
-      {
-         checkMask() ;
-         this->computeIndex() ;
-
-         this->storeIndex.push_front(new CArray<int,1>() );
-         this->out_i_index.push_front(new CArray<int,1>());
-         this->out_j_index.push_front(new CArray<int,1>());
-         this->out_l_index.push_front(new CArray<int,1>());
-      }
+   std::map<int, StdSize> CGrid::getConnectedServerDataSize()
+   {
+     std::map<int, StdSize> ret;
+     std::map<int, int>::const_iterator it = domConnectedServerSide_.begin(),
+                                       itE = domConnectedServerSide_.end();
+     StdSize retVal = StdSize(0.0);
+     for (; it != itE; ++it)
+     {
+       retVal = it->second;
+       if (this->withAxis) retVal *= this->axis->size.getValue();
+       retVal *= sizeof(double);
+       ret.insert(make_pair(it->first, retVal));
+     }
+     return ret;
+   }
+
+
+   //---------------------------------------------------------------
+
+//   void CGrid::solveReference(void)
+//   {
+//      if (this->isChecked) return;
+//      CContext* context = CContext::getCurrent() ;
+//      CContextClient* client=context->client ;
+//
+//      this->solveDomainRef() ;
+//      this->solveAxisRef() ;
+//
+//      if (context->hasClient)
+//      {
+//         checkMask() ;
+//         this->computeIndex() ;
+//
+//         this->storeIndex.push_front(new CArray<int,1>() );
+//         this->out_i_index.push_front(new CArray<int,1>());
+//         this->out_j_index.push_front(new CArray<int,1>());
+//         this->out_l_index.push_front(new CArray<int,1>());
+//      }
+////      this->computeIndexServer();
+//      this->isChecked = true;
+//   }
+
+   void CGrid::solveDomainAxisRef(bool areAttributesChecked)
+   {
+     if (this->isDomainAxisChecked) return;
+
+     this->solveDomainRef(areAttributesChecked);
+     this->solveAxisRef(areAttributesChecked);
+
+     this->isDomainAxisChecked = areAttributesChecked;
+   }
+
+   void CGrid::checkMaskIndex(bool doSendingIndex)
+   {
+     CContext* context = CContext::getCurrent() ;
+     CContextClient* client=context->client ;
+
+     if (context->hasClient)
+      if (this->isChecked && doSendingIndex) sendIndex();
+
+     if (this->isChecked) return;
+
+     if (context->hasClient)
+     {
+        checkMask() ;
+        this->computeIndex() ;
+
+        this->storeIndex.push_front(new CArray<int,1>() );
+        this->out_i_index.push_front(new CArray<int,1>());
+        this->out_j_index.push_front(new CArray<int,1>());
+        this->out_l_index.push_front(new CArray<int,1>());
+     }
 //      this->computeIndexServer();
-      this->isChecked = true;
+     this->isChecked = true;
    }
 
@@ -206 +257 @@
              (mask.extent(2) != nlu))
              ERROR("CGrid::checkAttributes(void)",
-                  <<"The mask has not the same size than the local grid"<<endl 
+                  <<"The mask has not the same size than the local grid"<<endl
                   <<"Local size is "<<niu<<"x"<<nju<<"x"<<nlu<<endl
                   <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1)<<"x"<<mask.extent(2));
       }
-      else 
+      else
       {
         mask.resize(niu,nju,nlu) ;
         mask=true  ;
       }
-     
+
       CArray<bool,2>& domainMask = domain->mask ;
       for (int l=0; l < nlu ; l++)
         for (int j=0; j < nju ; j++)
           for(int i=0; i<niu ; i++) mask(i,j,l) = mask(i,j,l) && domainMask(i,j) ;
-        
-      
-   }
-   
-   //---------------------------------------------------------------
-
-   void CGrid::solveDomainRef(void)
+
+
+   }
+
+   //---------------------------------------------------------------
+
+//   void CGrid::solveDomainRef(void)
+//   {
+//      if (!domain_ref.isEmpty())
+//      {
+//         if (CDomain::has(domain_ref.getValue()))
+//         {
+//            this->domain = CDomain::get(domain_ref.getValue()) ;
+//            domain->checkAttributes() ;
+//         }
+//         else ERROR("CGrid::solveDomainRef(void)",
+//                     << "Wrong domain reference") ;
+//      }
+//      else ERROR("CGrid::solveDomainRef(void)",
+//                  << "Domain reference is not defined") ;
+//   }
+//
+//   //---------------------------------------------------------------
+//
+//   void CGrid::solveAxisRef(void)
+//   {
+//      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 ;
+//   }
+
+
+   void CGrid::solveDomainRef(bool sendAtt)
    {
       if (!domain_ref.isEmpty())
@@ -233 +319 @@
          {
             this->domain = CDomain::get(domain_ref.getValue()) ;
-            domain->checkAttributes() ;
+            if (sendAtt) domain->sendCheckedAttributes();
+            else domain->checkAttributesOnClient() ;
          }
          else ERROR("CGrid::solveDomainRef(void)",
@@ -244 +331 @@
    //---------------------------------------------------------------
 
-   void CGrid::solveAxisRef(void)
+   void CGrid::solveAxisRef(bool checkAtt)
    {
       if (!axis_ref.isEmpty())
@@ -263 +350 @@
 
    void CGrid::computeIndex(void)
-   {    
-   
+   {
+
       const int ni   = domain->ni.getValue() ,
                 nj   = domain->nj.getValue() ,
@@ -280 +367 @@
       CArray<int,1> data_i_index = domain->data_i_index ;
       CArray<int,1> data_j_index = domain->data_j_index ;
-      
+
 
       int indexCount = 0;
@@ -302 +389 @@
          }
       }
-      
+
       storeIndex[0]  = new CArray<int,1>(indexCount) ;
       out_i_index[0] = new CArray<int,1>(indexCount) ;
       out_j_index[0] = new CArray<int,1>(indexCount) ;
       out_l_index[0] = new CArray<int,1>(indexCount) ;
-      
+
       storeIndex_client.resize(indexCount) ;
       out_i_client.resize(indexCount) ;
       out_j_client.resize(indexCount) ;
       out_l_client.resize(indexCount) ;
-      
-      
+
+
       for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
       {
@@ -334 +421 @@
                (*out_i_index[0])(indexCount) = i ;
                (*out_j_index[0])(indexCount) = j ;
-               
+
                storeIndex_client(indexCount) = count ;
                out_i_client(indexCount)=i+domain->ibegin_client-1 ;
@@ -343 +430 @@
          }
       }
-      sendIndex() ;
+      computeDomConServer();
+//      sendIndex() ;
 
 
@@ -370 +458 @@
    //----------------------------------------------------------------
 
-   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 3>& field) 
+   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 3>& field)
    {
       CArray<int,1>& out_i=*out_i_fromClient[rank] ;
       CArray<int,1>& out_j=*out_j_fromClient[rank] ;
       CArray<int,1>& out_l=*out_l_fromClient[rank] ;
-      
+
       for(StdSize n = 0; n < stored.numElements(); n++)
          field(out_i(n), out_j(n), out_l(n)) = stored(n) ;
    }
 
-   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 2>& field) 
+   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 2>& field)
    {
       CArray<int,1>& out_i=*out_i_fromClient[rank] ;
       CArray<int,1>& out_j=*out_j_fromClient[rank] ;
-      
+
       for(StdSize n = 0; n < stored.numElements(); n++)
          field(out_i(n), out_j(n)) = stored(n) ;   }
@@ -393 +481 @@
    {
       CArray<int,1>& out_i=*out_i_fromClient[rank] ;
- 
+
       for(StdSize n = 0; n < stored.numElements(); n++)
          field(out_i(n)) = stored(n) ;
@@ -399 +487 @@
 
    //----------------------------------------------------------------
-  
+
 
    void CGrid::storeField_arr
@@ -409 +497 @@
       for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)] ;
    }
-   
-   //---------------------------------------------------------------
+
+   //---------------------------------------------------------------
+
+//  void CGrid::sendIndex(void)
+//  {
+//    CContext* context = CContext::getCurrent() ;
+//    CContextClient* client=context->client ;
+//
+//    CEventClient event(getType(),EVENT_ID_INDEX) ;
+//    int rank ;
+//    list<shared_ptr<CMessage> > list_msg ;
+//    list< CArray<int,1>* > list_out_i,list_out_j,list_out_l ;
+//
+//    for(int ns=0;ns<domain->connectedServer.size();ns++)
+//    {
+//       rank=domain->connectedServer[ns] ;
+//
+//       int i,j ;
+//       int nb=0 ;
+//       for(int k=0;k<storeIndex_client.numElements();k++)
+//       {
+//         i=out_i_client(k)- domain->ibegin +1;
+//         j=out_j_client(k)- domain->jbegin +1;
+//         if (domain->mapConnectedServer(i,j)==ns)  nb++ ;
+//       }
+//
+//       CArray<int,1> storeIndex(nb) ;
+//       CArray<int,1> out_i(nb) ;
+//       CArray<int,1> out_j(nb) ;
+//       CArray<int,1> out_l(nb) ;
+//
+//
+//       nb=0 ;
+//       for(int k=0;k<storeIndex_client.numElements();k++)
+//       {
+//         i=out_i_client(k)- domain->ibegin +1 ;
+//         j=out_j_client(k)- domain->jbegin +1 ;
+//         if (domain->mapConnectedServer(i,j)==ns)
+//         {
+//            storeIndex(nb)=k ;
+//            out_i(nb)=domain->i_index(i,j) + domain->ibegin-1;
+//            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1;
+//            out_l(nb)=out_l_client(k) ;
+//            nb++ ;
+//         }
+//       }
+//
+//       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ;
+//       nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ;
+//       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
+//       list_out_i.push_back(new CArray<int,1>(out_i)) ;
+//       list_out_j.push_back(new CArray<int,1>(out_j)) ;
+//       list_out_l.push_back(new CArray<int,1>(out_l)) ;
+//
+//       *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ;
+//       event.push(rank,domain->nbSenders[ns],*list_msg.back()) ;
+//    }
+//    client->sendEvent(event) ;
+//
+//    for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ;
+//    for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ;
+//    for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ;
+//
+//  }
+
+  void CGrid::computeDomConServer()
+  {
+    if (!isDomConServerComputed_)
+    {
+      for(int ns=0;ns<domain->connectedServer.size(); ++ns)
+      {
+         int rank=domain->connectedServer[ns] ;
+
+         int i,j ;
+         int nb=0 ;
+         for(int k=0;k<storeIndex_client.numElements();++k)
+         {
+           i=out_i_client(k)- domain->ibegin +1;
+           j=out_j_client(k)- domain->jbegin +1;
+           if (domain->mapConnectedServer(i,j)==ns)  ++nb ;
+         }
+
+         domConnectedServerSide_.insert(std::make_pair(rank, nb));
+      }
+      isDomConServerComputed_ = true;
+    }
+  }
+
+
+  std::map<int, int> CGrid::getDomConServerSide()
+  {
+    return domConnectedServerSide_;
+  }
 
   void CGrid::sendIndex(void)
@@ -416 +595 @@
     CContext* context = CContext::getCurrent() ;
     CContextClient* client=context->client ;
-    
+
     CEventClient event(getType(),EVENT_ID_INDEX) ;
     int rank ;
     list<shared_ptr<CMessage> > list_msg ;
     list< CArray<int,1>* > list_out_i,list_out_j,list_out_l ;
-     
+
+    if (!isDomConServerComputed_) computeDomConServer();
+
     for(int ns=0;ns<domain->connectedServer.size();ns++)
     {
        rank=domain->connectedServer[ns] ;
-       
-       int i,j ;
-       int nb=0 ;
-       for(int k=0;k<storeIndex_client.numElements();k++)
-       {
-         i=out_i_client(k)- domain->ibegin +1;
-         j=out_j_client(k)- domain->jbegin +1;
-         if (domain->mapConnectedServer(i,j)==ns)  nb++ ;
-       }
-       
+
+       int nb = domConnectedServerSide_.find(rank)->second;
        CArray<int,1> storeIndex(nb) ;
        CArray<int,1> out_i(nb) ;
        CArray<int,1> out_j(nb) ;
        CArray<int,1> out_l(nb) ;
- 
-       
+
+       int i, j;
        nb=0 ;
        for(int k=0;k<storeIndex_client.numElements();k++)
@@ -450 +623 @@
             storeIndex(nb)=k ;
             out_i(nb)=domain->i_index(i,j) + domain->ibegin-1;
-            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1; 
+            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1;
             out_l(nb)=out_l_client(k) ;
             nb++ ;
          }
        }
-       
+
        storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ;
        nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ;
@@ -471 +644 @@
     for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ;
     for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ;
-    
+
   }
-  
+
   void CGrid::recvIndex(CEventServer& event)
   {
@@ -486 +659 @@
     }
   }
-  
+
   void CGrid::recvIndex(int rank, CBufferIn& buffer)
   {
@@ -492 +665 @@
     CArray<int,1> out_j ;
     CArray<int,1> out_l ;
-    
+
     buffer>>out_i>>out_j>>out_l ;
-    
+
     out_i -= domain->zoom_ibegin_srv-1 ;
     out_j -= domain->zoom_jbegin_srv-1 ;
-    
+
     out_i_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_i) )) ;
     out_j_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_j) )) ;
@@ -505 +678 @@
   bool CGrid::dispatchEvent(CEventServer& event)
   {
-     
+
     if (SuperClass::dispatchEvent(event)) return true ;
     else
@@ -515 +688 @@
           return true ;
           break ;
- 
+
         default :
           ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
@@ -532 +705 @@
                 << "Data from clients are missing!") ;
       storedServer.resize(storeIndex[0]->numElements());
-         
+
       for (StdSize i = 0, n = 0; i < storedClient.size(); i++)
          for (StdSize j = 0; j < storedClient[i]->numElements(); j++)
@@ -543 +716 @@
      int nb=index.numElements() ;
      fieldOut.resize(nb) ;
-     
+
      for(int k=0;k<nb;k++) fieldOut(k)=fieldIn(index(k)) ;
     }

XIOS/trunk/src/node/grid.hpp

@@ -13 +13 @@
 
 namespace xios {
-   
+
    /// ////////////////////// Déclarations ////////////////////// ///
 
@@ -46 +46 @@
            EVENT_ID_INDEX
          } ;
-         
+
          /// Constructeurs ///
          CGrid(void);
@@ -54 +54 @@
 
          /// Traitements ///
-         void solveReference(void);
+//         void solveReference(void);
+
+         void solveDomainAxisRef(bool areAttributesChecked);
+
+         void checkMaskIndex(bool doCalculateIndex);
 
  //        virtual void toBinary  (StdOStream & os) const;
@@ -74 +78 @@
 
          StdSize getDimension(void) const;
-         
+
 //         StdSize getLocalSize(void) const;
 //         StdSize getGlobalSize(void) const;
@@ -84 +88 @@
          template <int n>
             void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
-            
+
          void inputFieldServer(const std::deque< CArray<double, 1>* > storedClient,
                                CArray<double, 1>&  storedServer) const;
@@ -90 +94 @@
          void outputField(int rank, const CArray<double,1>& stored,  CArray<double,3>& field)  ;
          void outputField(int rank, const CArray<double,1>& stored,  CArray<double,2>& field)  ;
-         void outputField(int rank, const CArray<double,1>& stored,  CArray<double,1>& field)  ; 
-   
+         void outputField(int rank, const CArray<double,1>& stored,  CArray<double,1>& field)  ;
+
          /// Destructeur ///
          virtual ~CGrid(void);
@@ -100 +104 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-         
+
          static ENodeType GetType(void);
 
@@ -115 +119 @@
          void computeIndexServer(void);
          void computeIndex(void);
-         void solveDomainRef(void);
-         void solveAxisRef(void);
+//         void solveDomainRef(void);  //TODO temporarily comment
+//         void solveAxisRef(void);   // TODO: temporarily comment
+
+         void solveDomainRef(bool checkAtt);
+         void solveAxisRef(bool checkAtt);
 
          static bool dispatchEvent(CEventServer& event) ;
@@ -123 +130 @@
          void recvIndex(int rank, CBufferIn& buffer) ;
          void sendIndex(void) ;
-         
+
+         void computeDomConServer();
+         std::map<int, int> getDomConServerSide();
+         std::map<int, StdSize> getConnectedServerDataSize();
       public:
 
@@ -129 +139 @@
          bool withAxis ;
          bool isChecked;
+         bool isDomainAxisChecked;
 
          CAxis*   axis ;
@@ -137 +148 @@
          std::deque< CArray<int, 1>* > out_j_index ;
          std::deque< CArray<int, 1>* > out_l_index ;
-         
+
         CArray<int, 1>  storeIndex_client ;
         CArray<int, 1>  out_i_client ;
         CArray<int, 1>  out_j_client ;
         CArray<int, 1>  out_l_client ;
-         
+
          map<int, CArray<int, 1>* >  storeIndex_toSrv ;
          map<int,int> nbSenders ;
@@ -148 +159 @@
 //         std::deque<ARRAY(int, 1)> out_j_toSrv ;
 //         std::deque<ARRAY(int, 1)> out_l_toSrv ;
-         
+
          map<int, CArray<int, 1>* > out_i_fromClient ;
          map<int, CArray<int, 1>* > out_j_fromClient ;
          map<int, CArray<int, 1>* > out_l_fromClient ;
          void checkMask(void) ;
+
+         std::map<int, int> domConnectedServerSide_;
+         bool isDomConServerComputed_;
    }; // class CGrid