Changeset 1158 for XIOS/dev/dev_olga/src/node

Timestamp:

06/06/17 17:58:16 (7 years ago)

Author:

oabramkina

Message:

Two server levels: merging with trunk r1137.
There are bugs.

Location:

XIOS/dev/dev_olga/src/node

Files:

• axis.cpp (modified) (12 diffs)
• axis.hpp (modified) (5 diffs)
• calendar_wrapper.cpp (modified) (1 diff)
• context.cpp (modified) (13 diffs)
• domain.cpp (modified) (15 diffs)
• domain.hpp (modified) (7 diffs)
• expand_domain.cpp (modified) (1 diff)
• field.cpp (modified) (22 diffs)
• field.hpp (modified) (4 diffs)
• file.cpp (modified) (14 diffs)
• file.hpp (modified) (1 diff)
• grid.cpp (modified) (18 diffs)
• grid.hpp (modified) (4 diffs)
• interpolate_domain.cpp (modified) (3 diffs)
• mesh.cpp (modified) (32 diffs)
• scalar.cpp (modified) (1 diff)
• scalar.hpp (modified) (1 diff)
• variable.cpp (modified) (2 diffs)
• variable.hpp (modified) (1 diff)

XIOS/dev/dev_olga/src/node/axis.cpp

@@ -27 +27 @@
       , hasBounds_(false), isCompressible_(false)
       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), doZoomByIndex_(false)
+      , transformationMap_(), hasValue(false), doZoomByIndex_(false), hasLabel(false)
       , computedWrittenIndex_(false)
    {
@@ -38 +38 @@
       , hasBounds_(false), isCompressible_(false)
       , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , transformationMap_(), hasValue(false), doZoomByIndex_(false)
+      , transformationMap_(), hasValue(false), doZoomByIndex_(false), hasLabel(false)
       , computedWrittenIndex_(false)
    {
@@ -58 +58 @@
 
    ///---------------------------------------------------------------
+
+   const std::set<StdString> & CAxis::getRelFiles(void) const
+   {
+      return (this->relFiles);
+   }
+
    bool CAxis::IsWritten(const StdString & filename) const
    {
@@ -70 +76 @@
    bool CAxis::isDistributed(void) const
    {
-      return (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) ||
-             (!this->n.isEmpty() && (this->n != this->n_glo));;
+      bool distributed = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) ||
+             (!this->n.isEmpty() && (this->n != this->n_glo));
+      // A same stupid condition to make sure that if there is only one client, axis
+      // should be considered to be distributed. This should be a temporary solution     
+      distributed |= (1 == CContext::getCurrent()->client->clientSize);
+      return distributed;
    }
 
@@ -132 +142 @@
    std::map<int, StdSize> CAxis::getAttributesBufferSize()
    {
-//     CContextClient* client = CContext::getCurrent()->client;
      // For now the assumption is that secondary server pools consist of the same number of procs.
      // CHANGE the line below if the assumption changes.
@@ -172 +181 @@
          if (hasBounds_)
            sizeValEvent += CArray<double,2>::size(2 * it->second.size());
+ 
+         if (hasLabel)
+           sizeValEvent += CArray<StdString,1>::size(it->second.size());
 
          size_t size = CEventClient::headerSize + getId().size() + sizeof(size_t) + std::max(sizeIndexEvent, sizeValEvent);
@@ -255 +267 @@
       this->checkZoom();
       this->checkMask();
-      this->checkBounds();      
+      this->checkBounds();
+      this->checkLabel();
    }
 
@@ -339 +352 @@
    }
 
-   void CAxis::checkEligibilityForCompressedOutput()
-   {
-     // We don't check if the mask is valid here, just if a mask has been defined at this point.
-     isCompressible_ = !mask.isEmpty();
-   }
+  void CAxis::checkLabel()
+  {
+    if (!label.isEmpty())
+    {
+      if (label.extent(0) != n)
+        ERROR("CAxis::checkLabel(void)",
+              << "The label array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension of axis size." << std::endl
+              << "Axis size is " << n.getValue() << "." << std::endl
+              << "label size is "<< label.extent(0)<<  " .");
+      hasLabel = true;
+    }
+    else hasLabel = false;
+  }
+  void CAxis::checkEligibilityForCompressedOutput()
+  {
+    // We don't check if the mask is valid here, just if a mask has been defined at this point.
+    isCompressible_ = !mask.isEmpty();
+  }
 
    bool CAxis::dispatchEvent(CEventServer& event)
@@ -437 +463 @@
     CContext* context = CContext::getCurrent();
 
-    // int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1;
     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1;
     for (int p = 0; p < nbSrvPools; ++p)
@@ -729 +754 @@
     CContext* context = CContext::getCurrent();
 
-    // int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1;
     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 1) : 1;
     for (int p = 0; p < nbSrvPools; ++p)
@@ -1071 +1095 @@
       }
     }
+
+    if (hasLabel)
+    {
+      //label_srv(ind_srv) = labelVal( ind);
+    }
   }
 
@@ -1114 +1143 @@
   }
 
+  /*!
+    Compare two axis objects. 
+    They are equal if only if they have identical attributes as well as their values.
+    Moreover, they must have the same transformations.
+  \param [in] axis Compared axis
+  \return result of the comparison
+  */
+  bool CAxis::isEqual(CAxis* obj)
+  {
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("axis_ref");
+
+    bool objEqual = SuperClass::isEqual(obj, excludedAttr);    
+    if (!objEqual) return objEqual;
+
+    TransMapTypes thisTrans = this->getAllTransformations();
+    TransMapTypes objTrans  = obj->getAllTransformations();
+
+    TransMapTypes::const_iterator it, itb, ite;
+    std::vector<ETranformationType> thisTransType, objTransType;
+    for (it = thisTrans.begin(); it != thisTrans.end(); ++it)
+      thisTransType.push_back(it->first);
+    for (it = objTrans.begin(); it != objTrans.end(); ++it)
+      objTransType.push_back(it->first);
+
+    if (thisTransType.size() != objTransType.size()) return false;
+    for (int idx = 0; idx < thisTransType.size(); ++idx)
+      objEqual &= (thisTransType[idx] == objTransType[idx]);
+
+    return objEqual;
+  }
 
   CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id)

XIOS/dev/dev_olga/src/node/axis.hpp

@@ -68 +68 @@
 
          static CAxis* createAxis();
-     
+
+         /// Accesseurs ///
+         const std::set<StdString> & getRelFiles(void) const;
+
          int getNumberWrittenIndexes() const;
          int getTotalNumberWrittenIndexes() const;
@@ -115 +118 @@
          void duplicateTransformation(CAxis*);
          CTransformation<CAxis>* addTransformation(ETranformationType transType, const StdString& id="");
+         bool isEqual(CAxis* axis);
 
       public:
@@ -121 +125 @@
         CArray<double,1> value_srv;
         CArray<double,2> bound_srv;
+        CArray<StdString,1> label_srv;
         bool hasValue;
         CArray<int,1> globalDimGrid;
@@ -131 +136 @@
          void checkMask();
          void checkZoom();
-         void checkBounds();         
+         void checkBounds();
+         void checkLabel();
          void sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
                              CServerDistributionDescription::ServerDistributionType distType);
@@ -166 +172 @@
          std::map<int, CArray<int,1> > indiSrv_;
          bool hasBounds_;
-
+         bool hasLabel;
          bool doZoomByIndex_;
          bool computedWrittenIndex_;

XIOS/dev/dev_olga/src/node/calendar_wrapper.cpp

@@ -83 +83 @@
   {
     // Create the calendar if possible
-    if (0 != calendar)
+    if (calendar)
     {
       ERROR("CCalendarWrapper::createCalendar(void)",

XIOS/dev/dev_olga/src/node/context.cpp

@@ -14 +14 @@
 #include "type.hpp"
 #include "xios_spl.hpp"
+#include "timer.hpp"
+#include "memtrack.hpp"
 
 #include "server.hpp"
@@ -372 +374 @@
        comms.push_back(interCommClient);
      }
-     client = new CContextClient(this,intraCommClient,interCommClient,cxtClient);
+     client = new CContextClient(this,intraCommClient,interCommClient, cxtClient);
    }
 
@@ -615 +617 @@
    void CContext::closeDefinition(void)
    {
+    CTimer::get("Context : close definition").resume() ;
     postProcessingGlobalAttributes();
 
@@ -640 +643 @@
       if (!hasServer) startPrefetchingOfEnabledReadModeFiles();
     }
+    CTimer::get("Context : close definition").suspend() ;
    }
 
@@ -690 +694 @@
        this->enabledFiles[i]->generateNewTransformationGridDest();
      }
-
    }
 
@@ -783 +786 @@
    {
       const std::vector<CFile*> allFiles = CFile::getAll();
+      const CDate& initDate = calendar->getInitDate();
 
       for (unsigned int i = 0; i < allFiles.size(); i++)
@@ -788 +792 @@
          {
             if (allFiles[i]->enabled.getValue()) // Si l'attribut 'enabled' est fixé à vrai.
+            {
+              if ((initDate + allFiles[i]->output_freq.getValue()) < (initDate + this->getCalendar()->getTimeStep()))
+              {
+                error(0)<<"WARNING: void CContext::findEnabledFiles()"<<endl
+                    << "Output frequency in file \""<<allFiles[i]->getFileOutputName()
+                    <<"\" is less than the time step. File will not be written."<<endl;
+              }
+              else
                enabledFiles.push_back(allFiles[i]);
+            }
          }
-         else enabledFiles.push_back(allFiles[i]); // otherwise true by default
-
+         else
+         {
+           if ( (initDate + allFiles[i]->output_freq.getValue()) < (initDate + this->getCalendar()->getTimeStep()))
+           {
+             error(0)<<"WARNING: void CContext::findEnabledFiles()"<<endl
+                 << "Output frequency in file \""<<allFiles[i]->getFileOutputName()
+                 <<"\" is less than the time step. File will not be written."<<endl;
+           }
+           else
+             enabledFiles.push_back(allFiles[i]); // otherwise true by default
+         }
 
       if (enabledFiles.size() == 0)
@@ -1267 +1289 @@
      StdString fileDefRoot("file_definition");
      CFileGroup* cfgrpPtr = CFileGroup::get(fileDefRoot);
+
      for (int i = 0; i < size; ++i)
      {
@@ -1313 +1336 @@
        CFile* file = allFiles[i];
 
+       std::vector<CVariable*> fileVars, fieldVars, vars = file->getAllVariables();
+       for (size_t k = 0; k < vars.size(); k++)
+       {
+         CVariable* var = vars[k];
+
+         if (var->ts_target.isEmpty()
+              || var->ts_target == CVariable::ts_target_attr::file || var->ts_target == CVariable::ts_target_attr::both)
+           fileVars.push_back(var);
+
+         if (!var->ts_target.isEmpty()
+              && (var->ts_target == CVariable::ts_target_attr::field || var->ts_target == CVariable::ts_target_attr::both))
+           fieldVars.push_back(var);
+       }
+
        if (!file->timeseries.isEmpty() && file->timeseries != CFile::timeseries_attr::none)
        {
-         StdString tsPrefix = !file->ts_prefix.isEmpty() ? file->ts_prefix : file->getFileOutputName();
-
+         StdString fileNameStr("%file_name%") ;
+         StdString tsPrefix = !file->ts_prefix.isEmpty() ? file->ts_prefix : fileNameStr ;
+         
+         StdString fileName=file->getFileOutputName();
+         size_t pos=tsPrefix.find(fileNameStr) ;
+         while (pos!=std::string::npos)
+         {
+           tsPrefix=tsPrefix.replace(pos,fileNameStr.size(),fileName) ;
+           pos=tsPrefix.find(fileNameStr) ;
+         }
+        
          const std::vector<CField*> allFields = file->getAllFields();
          for (size_t j = 0; j < allFields.size(); j++)
@@ -1326 +1372 @@
              CFile* tsFile = CFile::create();
              tsFile->duplicateAttributes(file);
-             tsFile->setVirtualVariableGroup(file->getVirtualVariableGroup());
-
+
+             // Add variables originating from file and targeted to timeserie file
+             for (size_t k = 0; k < fileVars.size(); k++)
+               tsFile->getVirtualVariableGroup()->addChild(fileVars[k]);
+
+            
              tsFile->name = tsPrefix + "_";
              if (!field->name.isEmpty())
@@ -1341 +1391 @@
              CField* tsField = tsFile->addField();
              tsField->field_ref = field->getId();
-             tsField->setVirtualVariableGroup(field->getVirtualVariableGroup());
+
+             // Add variables originating from file and targeted to timeserie field
+             for (size_t k = 0; k < fieldVars.size(); k++)
+               tsField->getVirtualVariableGroup()->addChild(fieldVars[k]);
+
+             vars = field->getAllVariables();
+             for (size_t k = 0; k < vars.size(); k++)
+             {
+               CVariable* var = vars[k];
+
+               // Add variables originating from field and targeted to timeserie field
+               if (var->ts_target.isEmpty()
+                    || var->ts_target == CVariable::ts_target_attr::field || var->ts_target == CVariable::ts_target_attr::both)
+                 tsField->getVirtualVariableGroup()->addChild(var);
+
+               // Add variables originating from field and targeted to timeserie file
+               if (!var->ts_target.isEmpty()
+                    && (var->ts_target == CVariable::ts_target_attr::file || var->ts_target == CVariable::ts_target_attr::both))
+                 tsFile->getVirtualVariableGroup()->addChild(var);
+             }
 
              tsFile->solveFieldRefInheritance(true);
@@ -1456 +1525 @@
    void CContext::updateCalendar(int step)
    {
-      info(50) <<"Context "<< this->getId() <<" updateCalendar : before : " << calendar->getCurrentDate() << endl;
+      info(50) << "updateCalendar : before : " << calendar->getCurrentDate() << endl;
       calendar->update(step);
-      info(50) <<"Context "<< this->getId() << " updateCalendar : after : " << calendar->getCurrentDate() << endl;
-
+      info(50) << "updateCalendar : after : " << calendar->getCurrentDate() << endl;
+#ifdef XIOS_MEMTRACK_LIGHT
+      info(50) << " Current memory used by XIOS : "<<  MemTrack::getCurrentMemorySize()*1.0/(1024*1024)<<" Mbyte, at timestep "<<step<<" of context "<<this->getId()<<endl ;
+#endif
       if (hasClient)
       {
@@ -1537 +1608 @@
 
   void CContext::sendRegistry(void)
-  {    
+  {
     registryOut->hierarchicalGatherRegistry() ;
 

XIOS/dev/dev_olga/src/node/domain.cpp

@@ -26 +26 @@
 namespace xios {
 
-   /// ////////////////////// Dfinitions ////////////////////// ///
+   /// ////////////////////// Définitions ////////////////////// ///
 
    CDomain::CDomain(void)
@@ -79 +79 @@
    }
 
+   const std::set<StdString> & CDomain::getRelFiles(void) const
+   {
+      return (this->relFiles);
+   }
+
+
    /*!
      Returns the number of indexes written by each server.
@@ -170 +176 @@
    {
       return ((this->zoom_i_index.isEmpty()) || (0 == this->zoom_i_index.numElements()));
-      // return ((this->zoom_ni_srv == 0) ||
-      //         (this->zoom_nj_srv == 0));
+
    }
 
@@ -190 +195 @@
    bool CDomain::isDistributed(void) const
    {
-      return !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) ||
+      bool distributed =  !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) ||
               (!i_index.isEmpty() && i_index.numElements() == ni_glo*nj_glo));
+      distributed |= (1 == CContext::getCurrent()->client->clientSize);
+
+      return distributed;
    }
 
@@ -221 +229 @@
 
    //----------------------------------------------------------------
+
+   /*!
+      Verify if all distribution information of a domain are available
+      This checking verifies the definition of distribution attributes (ni, nj, ibegin, jbegin)
+   */
+   bool CDomain::distributionAttributesHaveValue() const
+   {
+      bool hasValues = true;
+
+      if (ni.isEmpty() && ibegin.isEmpty() && i_index.isEmpty())
+      {
+        hasValues = false;
+        return hasValues;
+      }
+
+      return hasValues;
+   }
 
    /*!
@@ -331 +356 @@
             ni.setValue(ni_glo - ibeginVec[iIdx]);
           }
-        }
-
-        // Now fill other attributes
-        if (type_attr::rectilinear == type) fillInRectilinearLonLat();
+        } 
      }
      else  // unstructured domain
@@ -380 +402 @@
             nj.setValue(1);
           }
+
+          i_index.resize(ni);          
+          for(int idx = 0; idx < ni; ++idx) i_index(idx)=ibegin+idx;
         }
         else
@@ -391 +416 @@
 
      checkDomain();
+   }
+
+   /*!
+     Fill in longitude and latitude whose values are read from file
+   */
+   void CDomain::fillInLonLat()
+   {
+     switch (type)
+     {
+      case type_attr::rectilinear:
+        fillInRectilinearLonLat();
+        break;
+      case type_attr::curvilinear:
+        fillInCurvilinearLonLat();
+        break;
+      case type_attr::unstructured:
+        fillInUnstructuredLonLat();
+        break;
+
+      default:
+      break;
+     }
+
    }
 
@@ -468 +516 @@
    }
 
-
-
+    /*
+      Fill in longitude and latitude of curvilinear domain read from a file
+      If there are already longitude and latitude defined by model. We just igonore reading value.
+    */
+   void CDomain::fillInCurvilinearLonLat()
+   {
+     if (!lonvalue_curvilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty())
+     {
+       lonvalue_2d.resize(ni,nj);
+       for (int jdx = 0; jdx < nj; ++jdx)
+        for (int idx = 0; idx < ni; ++idx)
+         lonvalue_2d(idx,jdx) = lonvalue_curvilinear_read_from_file(idx+ibegin, jdx+jbegin);
+
+       lonvalue_curvilinear_read_from_file.free();
+     }
+
+     if (!latvalue_curvilinear_read_from_file.isEmpty() && latvalue_2d.isEmpty())
+     {
+       latvalue_2d.resize(ni,nj);
+       for (int jdx = 0; jdx < nj; ++jdx)
+        for (int idx = 0; idx < ni; ++idx)
+         latvalue_2d(idx,jdx) = latvalue_curvilinear_read_from_file(idx+ibegin, jdx+jbegin);
+
+       latvalue_curvilinear_read_from_file.free();
+     }
+
+     if (!bounds_lonvalue_curvilinear_read_from_file.isEmpty() && bounds_lon_2d.isEmpty())
+     {
+       bounds_lon_2d.resize(nvertex,ni,nj);
+       for (int jdx = 0; jdx < nj; ++jdx)
+        for (int idx = 0; idx < ni; ++idx)
+          for (int ndx = 0; ndx < nvertex; ++ndx)
+         bounds_lon_2d(ndx,idx,jdx) = bounds_lonvalue_curvilinear_read_from_file(ndx,idx+ibegin, jdx+jbegin);
+
+       bounds_lonvalue_curvilinear_read_from_file.free();
+     }
+
+     if (!bounds_latvalue_curvilinear_read_from_file.isEmpty() && bounds_lat_2d.isEmpty())
+     {
+       bounds_lat_2d.resize(nvertex,ni,nj);
+       for (int jdx = 0; jdx < nj; ++jdx)
+        for (int idx = 0; idx < ni; ++idx)
+          for (int ndx = 0; ndx < nvertex; ++ndx)
+            bounds_lat_2d(ndx,idx,jdx) = bounds_latvalue_curvilinear_read_from_file(ndx,idx+ibegin, jdx+jbegin);
+
+       bounds_latvalue_curvilinear_read_from_file.free();
+     }
+
+   }
+
+    /*
+      Fill in longitude and latitude of unstructured domain read from a file
+      If there are already longitude and latitude defined by model. We just igonore reading value.
+    */
+   void CDomain::fillInUnstructuredLonLat()
+   {
+     if (i_index.isEmpty())
+     {
+       i_index.resize(ni);
+       for(int idx = 0; idx < ni; ++idx) i_index(idx)=ibegin+idx;
+     }
+
+     if (!lonvalue_unstructured_read_from_file.isEmpty() && lonvalue_1d.isEmpty())
+     {
+        lonvalue_1d.resize(ni);
+        for (int idx = 0; idx < ni; ++idx)
+          lonvalue_1d(idx) = lonvalue_unstructured_read_from_file(i_index(idx));
+
+        // We dont need these values anymore, so just delete them
+        lonvalue_unstructured_read_from_file.free();
+     } 
+
+     if (!latvalue_unstructured_read_from_file.isEmpty() && latvalue_1d.isEmpty())
+     {
+        latvalue_1d.resize(ni);
+        for (int idx = 0; idx < ni; ++idx)
+          latvalue_1d(idx) =  latvalue_unstructured_read_from_file(i_index(idx));
+
+        // We dont need these values anymore, so just delete them
+        latvalue_unstructured_read_from_file.free();
+     }
+
+     if (!bounds_lonvalue_unstructured_read_from_file.isEmpty() && bounds_lon_1d.isEmpty())
+     {
+        int nbVertex = nvertex;
+        bounds_lon_1d.resize(nbVertex,ni);
+        for (int idx = 0; idx < ni; ++idx)
+          for (int jdx = 0; jdx < nbVertex; ++jdx)
+            bounds_lon_1d(jdx,idx) = bounds_lonvalue_unstructured_read_from_file(jdx, i_index(idx));
+
+        // We dont need these values anymore, so just delete them
+        lonvalue_unstructured_read_from_file.free();
+     }
+
+     if (!bounds_latvalue_unstructured_read_from_file.isEmpty() && bounds_lat_1d.isEmpty())
+     {
+        int nbVertex = nvertex;
+        bounds_lat_1d.resize(nbVertex,ni);
+        for (int idx = 0; idx < ni; ++idx)
+          for (int jdx = 0; jdx < nbVertex; ++jdx)
+            bounds_lat_1d(jdx,idx) = bounds_latvalue_unstructured_read_from_file(jdx, i_index(idx));
+
+        // We dont need these values anymore, so just delete them
+        lonvalue_unstructured_read_from_file.free();
+     }
+   }
+
+  /*
+    Get global longitude and latitude of rectilinear domain.
+  */
    void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g)
    {
@@ -590 +746 @@
     else
     {
-      if (bounds_lat_start.isEmpty()) bounds_lon_start=-90. ;
+      if (bounds_lat_start.isEmpty()) bounds_lat_start=-90. ;
       if (bounds_lat_end.isEmpty()) bounds_lat_end=90 ;
     }
@@ -695 +851 @@
        for (int j = 0; j < nj; ++j)
          for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
-     }     
+     }
+     
      checkZoom();
    }
@@ -1431 +1588 @@
      if (context->hasClient)
      {
-       // this->checkMask();
       this->computeConnectedClients();
-       // if (hasLonLat || hasArea || isCompressible_) this->computeConnectedClients();
        if (hasLonLat)
          if (!context->hasServer)
@@ -1482 +1637 @@
      if (context->hasClient)
      {
-//       this->completeLonLatClient();
        sendAttributes();
      }
@@ -2694 +2848 @@
   }
 
-
   /*!
     Receive area information from client(s)
@@ -2742 +2895 @@
       
     }
+  }
+
+  /*!
+    Compare two domain objects. 
+    They are equal if only if they have identical attributes as well as their values.
+    Moreover, they must have the same transformations.
+  \param [in] domain Compared domain
+  \return result of the comparison
+  */
+  bool CDomain::isEqual(CDomain* obj)
+  {
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("domain_ref");
+    bool objEqual = SuperClass::isEqual(obj, excludedAttr);
+    if (!objEqual) return objEqual;
+
+    TransMapTypes thisTrans = this->getAllTransformations();
+    TransMapTypes objTrans  = obj->getAllTransformations();
+
+    TransMapTypes::const_iterator it, itb, ite;
+    std::vector<ETranformationType> thisTransType, objTransType;
+    for (it = thisTrans.begin(); it != thisTrans.end(); ++it)
+      thisTransType.push_back(it->first);
+    for (it = objTrans.begin(); it != objTrans.end(); ++it)
+      objTransType.push_back(it->first);
+
+    if (thisTransType.size() != objTransType.size()) return false;
+    for (int idx = 0; idx < thisTransType.size(); ++idx)
+      objEqual &= (thisTransType[idx] == objTransType[idx]);
+
+    return objEqual;
   }
 

XIOS/dev/dev_olga/src/node/domain.hpp

@@ -42 +42 @@
       , public CDomainAttributes
    {
-               /// typedef ///
-         typedef CObjectTemplate<CDomain>   SuperClass;
-         typedef CDomainAttributes SuperClassAttribute;
-         
-      public :
+     /// typedef ///
+     typedef CObjectTemplate<CDomain>   SuperClass;
+     typedef CDomainAttributes SuperClassAttribute;
+     public:
          enum EEventId
          {
@@ -91 +90 @@
          CTransformation<CDomain>* addTransformation(ETranformationType transType, const StdString& id="");
 
-      public:         
+      public:
+         const std::set<StdString> & getRelFiles(void) const;
          bool IsWritten(const StdString & filename) const;
          bool isWrittenCompressed(const StdString& filename) const;
@@ -116 +116 @@
          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
-
+         std::vector<int> getNbGlob();
+         bool isEqual(CDomain* domain);
       public:
          /// Mutateur ///
@@ -130 +131 @@
          void fillInRectilinearBoundLonLat(CArray<double,1>& lon, CArray<double,1>& lat,
                                            CArray<double,2>& boundsLon, CArray<double,2>& boundsLat);
-         void fillInRectilinearLonLat();
+         
+         void fillInLonLat();
+         bool distributionAttributesHaveValue() const;
 
          static bool dispatchEvent(CEventServer& event);
@@ -157 +160 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-         static ENodeType GetType(void);   
-
+
+         static ENodeType GetType(void);
+         const std::map<int, vector<size_t> >& getIndexServer() const;
          CArray<bool, 1> localMask;
          bool isCurvilinear ;
@@ -182 +186 @@
 
          void setTransformations(const TransMapTypes&);         
-
+         void computeNGlobDomain();
          void sendAttributes();
          void sendIndex();
@@ -192 +196 @@
          void sendDataIndex();
          void convertLonLatValue();
-
+         void fillInRectilinearLonLat();
+         void fillInCurvilinearLonLat();
+         void fillInUnstructuredLonLat();
        private:         
          bool doZoomByIndex_;

XIOS/dev/dev_olga/src/node/expand_domain.cpp

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

XIOS/dev/dev_olga/src/node/field.cpp

@@ -38 +38 @@
       , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
       , useCompressedOutput(false)
+      , hasTimeInstant(false)
+      , hasTimeCentered(false)
       , wasDataAlreadyReceivedFromServer(false)
+      , isEOF(false)
    { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
 
@@ -50 +53 @@
       , areAllReferenceSolved(false), isReferenceSolved(false), isReferenceSolvedAndTransformed(false)
       , useCompressedOutput(false)
+      , hasTimeInstant(false)
+      , hasTimeCentered(false)
       , wasDataAlreadyReceivedFromServer(false)
+      , isEOF(false)
    { setVirtualVariableGroup(CVariableGroup::create(getId() + "_virtual_variable_group")); }
 
@@ -122 +128 @@
   void CField::sendUpdateData(const CArray<double,1>& data)
   {
-    CTimer::get("XIOS Send Data").resume();
+    CTimer::get("Field : send data").resume();
 
     CContext* context = CContext::getCurrent();
@@ -174 +180 @@
       }    
 
-    CTimer::get("XIOS Send Data").suspend();
+    CTimer::get("Field : send data").suspend();
   }
 
@@ -183 +189 @@
     list<CEventServer::SSubEvent>::iterator it;
     string fieldId;
-
+    CTimer::get("Field : recv data").resume();
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
     {
@@ -192 +198 @@
     }
     get(fieldId)->recvUpdateData(rankBuffers);
+    CTimer::get("Field : recv data").suspend();
   }
 
@@ -252 +259 @@
     }
   }
-  
-//   void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
-//   {
-//     CContext* context = CContext::getCurrent();
-
-//     if (data_srv.empty())
-//     {
-//       for (map<int, CArray<size_t, 1> >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
-//       {
-//         int rank = it->first;
-//         data_srv.insert(std::make_pair(rank, CArray<double,1>(it->second.numElements())));
-//         foperation_srv.insert(pair<int,boost::shared_ptr<func::CFunctor> >(rank,boost::shared_ptr<func::CFunctor>(new func::CInstant(data_srv[rank]))));
-//       }
-//     }
-
-//     const CDate& currDate = context->getCalendar()->getCurrentDate();
-//     const CDate opeDate      = last_operation_srv +freq_op + freq_operation_srv - freq_op;
-//     const CDate writeDate    = last_Write_srv     + freq_write_srv;
-
-//     if (opeDate <= currDate)
-//     {
-//       for (int n = 0; n < ranks.size(); n++)
-//       {
-//         CArray<double,1> data_tmp;
-//         *buffers[n] >> data_tmp;
-//         (*foperation_srv[ranks[n]])(data_tmp);
-//       }
-//       last_operation_srv = currDate;
-//     }
-
-//     if (writeDate < (currDate + freq_operation_srv))
-//     {
-//       for (int n = 0; n < ranks.size(); n++)
-//       {
-//         this->foperation_srv[ranks[n]]->final();
-//       }
-
-//       last_Write_srv = writeDate;
-//     }
-
-//     if (context->hasClient && context->hasServer)
-//     {
-//       size_t writtenSize;
-// //      if (field->getUseCompressedOutput())
-// //        writtenSize = grid->getNumberWrittenIndexes();
-// //      else
-//         writtenSize = grid->getWrittenDataSize();
-
-//       CArray<double,1> fieldData(writtenSize);
-// //      if (!field->default_value.isEmpty()) fieldData = field->default_value;
-
-// //      if (field->getUseCompressedOutput())
-// //        field->outputCompressedField(fieldData);
-// //      else
-//         this->outputField(fieldData);
-//       sendUpdateData(fieldData);
-//     }
-//     if (!context->hasClient && context->hasServer)
-//     {
-//       writeField();
-//     }
-
-//     lastlast_Write_srv = last_Write_srv;
-
-//   }
 
   void CField::writeField(void)
@@ -331 +273 @@
   }
 
-  void CField::sendReadDataRequest(const CDate& tsDataRequested)
+  bool CField::sendReadDataRequest(const CDate& tsDataRequested)
   {
     CContext* context = CContext::getCurrent();
@@ -339 +281 @@
     lastDataRequestedFromServer = tsDataRequested;
 
-    CEventClient event(getType(), EVENT_ID_READ_DATA);
-    if (client->isServerLeader())
+    if (!isEOF) // No need to send the request if we already know we are at EOF
     {
-      CMessage msg;
-      msg << getId();
-      const std::list<int>& ranks = client->getRanksServerLeader();
-      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
-        event.push(*itRank, 1, msg);
-      client->sendEvent(event);
-    }
-    else client->sendEvent(event);
+      CEventClient event(getType(), EVENT_ID_READ_DATA);
+      if (client->isServerLeader())
+      {
+        CMessage msg;
+        msg << getId();
+        const std::list<int>& ranks = client->getRanksServerLeader();
+        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
+          event.push(*itRank, 1, msg);
+        client->sendEvent(event);
+      }
+      else client->sendEvent(event);
+    }
+    else
+      serverSourceFilter->signalEndOfStream(tsDataRequested);
+
+    return !isEOF;
   }
 
@@ -361 +310 @@
 
     bool dataRequested = false;
+
     while (currentDate >= lastDataRequestedFromServer)
     {
@@ -368 +318 @@
       info(20) << "lastDataRequestedFromServer + file->output_freq.getValue() : " << lastDataRequestedFromServer + file->output_freq << endl ;
 
-      sendReadDataRequest(lastDataRequestedFromServer + file->output_freq);
-
-      dataRequested = true;
-    }
+      dataRequested |= sendReadDataRequest(lastDataRequestedFromServer + file->output_freq);
+    }
+
     return dataRequested;
   }
@@ -386 +335 @@
   {
     CContext* context = CContext::getCurrent();
-    CContextClient* client = context->client;    
+    CContextClient* client = context->client;
 
     CEventClient event(getType(), EVENT_ID_READ_DATA_READY);
@@ -393 +342 @@
     bool hasData = readField();
 
-    
+    map<int, CArray<double,1> >::iterator it;
     if (!grid->doGridHaveDataDistributed())
     {
@@ -413 +362 @@
             }
           }
-
           client->sendEvent(event);
        }
@@ -500 +448 @@
     std::map<int, CArray<double,1> > data;
 
-    bool isEOF = false;
-
     for (int i = 0; i < ranks.size(); i++)
     {
@@ -585 +531 @@
    //----------------------------------------------------------------
 
-   bool CField::isActive(void) const
-   {
-      return (instantDataFilter != NULL);
+   bool CField::isActive(bool atCurrentTimestep /*= false*/) const
+   {
+      if (clientSourceFilter)
+        return atCurrentTimestep ? clientSourceFilter->isDataExpected(CContext::getCurrent()->getCalendar()->getCurrentDate()) : true;
+      else if (storeFilter)
+        return true;
+      else if (instantDataFilter)
+        ERROR("bool CField::isActive(bool atCurrentTimestep)",
+              << "Impossible to check if field [ id = " << getId() << " ] is active as it cannot be used to receive nor send data.");
+
+      return false;
    }
 
@@ -815 +769 @@
           if (hasDirectFieldReference()) getDirectFieldReference()->solveAllReferenceEnabledField(false);
         }
-       else if (context->hasServer)        
+        else if (context->hasServer)
           solveServerOperation();
 
@@ -940 +894 @@
        {
          // Check if we have an expression to parse
-       if (hasExpression())
+         if (hasExpression())
          {
-         boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0'));
-         boost::shared_ptr<COutputPin> filter = expr->reduce(gc, *this);
-
-         // Check if a spatial transformation is needed
-         if (!field_ref.isEmpty())
-         {
-           CGrid* gridRef = CField::get(field_ref)->grid;
-
-           if (grid && grid != gridRef && grid->hasTransform())
+           boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0'));
+           boost::shared_ptr<COutputPin> filter = expr->reduce(gc, *this);
+
+           // Check if a spatial transformation is needed
+           if (!field_ref.isEmpty())
            {
-             double defaultValue = !default_value.isEmpty() ? default_value : 0.0;
-             std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, defaultValue);
-
-             filter->connectOutput(filters.first, 0);
-             filter = filters.second;
+             CGrid* gridRef = CField::get(field_ref)->grid;
+
+             if (grid && grid != gridRef && grid->hasTransform())
+             {
+               bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+               double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+               std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, hasMissingValue, defaultValue);
+
+               filter->connectOutput(filters.first, 0);
+               filter = filters.second;
+             }
            }
-         }
-
-         instantDataFilter = filter;
+
+           instantDataFilter = filter;
          }
          // Check if we have a reference on another field
@@ -967 +922 @@
          // Check if the data is to be read from a file
          else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
-         instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,
-                                                                                                     freq_offset.isEmpty() ? NoneDu : freq_offset,
-                                                                                                     true));
+           instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,
+                                                                                                       freq_offset.isEmpty() ? NoneDu : freq_offset,
+                                                                                                       true));
          else // The data might be passed from the model
-         instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid));
-       }
-
-       // If the field data is to be read by the client or/and written to a file
-       if (enableOutput && !storeFilter && !fileWriterFilter)
-       {
-         if (!read_access.isEmpty() && read_access)
          {
-           storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid));
-           instantDataFilter->connectOutput(storeFilter, 0);
+            bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+            double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
+            instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false,
+                                                                                                        ignoreMissingValue, defaultValue));
          }
-
-         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
-         {
-           fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
-           getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
-         }
-       }
-     }
-   }
-
+       }
+     }
+
+     // If the field data is to be read by the client or/and written to a file
+     if (enableOutput && !storeFilter && !fileWriterFilter)
+     {
+       if (!read_access.isEmpty() && read_access)
+       {
+         storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid));
+         instantDataFilter->connectOutput(storeFilter, 0);
+       }
+
+       if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+       {
+         fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+         getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
+       }
+     }
+   }
 
    /*!
@@ -1000 +959 @@
     * \return the output pin corresponding to the field reference
     */
-     boost::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
-     {
-       if (instantDataFilter || field_ref.isEmpty())
-         ERROR("COutputPin* CField::getFieldReference(CGarbageCollector& gc)",
-               "Impossible to get the field reference for a field which has already been parsed or which does not have a field_ref.");
-
-       CField* fieldRef = CField::get(field_ref);
-       fieldRef->buildFilterGraph(gc, false);
-
-       std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters;
-       // Check if a spatial transformation is needed
-       if (grid && grid != fieldRef->grid && grid->hasTransform())
-       {
-         double defaultValue = !default_value.isEmpty() ? default_value : 0.0;
-         filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, defaultValue);
-       }
-       else
-         filters.first = filters.second = boost::shared_ptr<CFilter>(new CPassThroughFilter(gc));
-
-       fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
-
-       return filters.second;
-     }
+   boost::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
+   {
+     if (instantDataFilter || field_ref.isEmpty())
+       ERROR("COutputPin* CField::getFieldReference(CGarbageCollector& gc)",
+             "Impossible to get the field reference for a field which has already been parsed or which does not have a field_ref.");
+
+     CField* fieldRef = CField::get(field_ref);
+     fieldRef->buildFilterGraph(gc, false);
+
+     std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters;
+     // Check if a spatial transformation is needed
+     if (grid && grid != fieldRef->grid && grid->hasTransform())
+     {       
+       bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+       double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);                                
+       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue);
+     }
+     else
+       filters.first = filters.second = boost::shared_ptr<CFilter>(new CPassThroughFilter(gc));
+
+     fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
+
+     return filters.second;
+   }
 
    /*!
@@ -1058 +1018 @@
        {
          if (!clientSourceFilter)
-           clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid));
+         {
+           bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+           double defaultValue  = ignoreMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
+           clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, NoneDu, false,
+                                                                                   ignoreMissingValue, defaultValue));
+         }
 
          selfReferenceFilter = clientSourceFilter;
@@ -1104 +1069 @@
      return it->second;
    }
+
+  /*!
+    * Returns the temporal filter corresponding to the field's temporal operation
+    * for the specified operation frequency.
+    *
+    * \param gc the garbage collector to use
+    * \param outFreq the operation frequency, i.e. the frequency at which the output data will be computed
+    * \return the output pin corresponding to the requested temporal filter
+    */
+   
+   boost::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   {
+     if (instantDataFilter || !hasExpression())
+       ERROR("COutputPin* CField::getSelfTemporalDataFilter(CGarbageCollector& gc)",
+             "Impossible to add a self reference to a field which has already been parsed or which does not have an expression.");
+
+     if (!selfReferenceFilter) getSelfReference(gc) ;
+
+     if (serverSourceFilter || clientSourceFilter)
+     {
+       if (operation.isEmpty())
+         ERROR("void CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
+               << "An operation must be defined for field \"" << getId() << "\".");
+
+       if (freq_op.isEmpty()) freq_op.setValue(TimeStep);
+       if (freq_offset.isEmpty()) freq_offset.setValue(NoneDu);
+
+       const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+
+       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                             freq_op, freq_offset, outFreq,
+                                                                             ignoreMissingValue, ignoreMissingValue ? default_value : 0.0));
+       selfReferenceFilter->connectOutput(temporalFilter, 0);
+       return temporalFilter ;
+     }
+     else if (!field_ref.isEmpty())
+     {
+       CField* fieldRef = CField::get(field_ref);
+       fieldRef->buildFilterGraph(gc, false); 
+       return fieldRef->getTemporalDataFilter(gc, outFreq) ;
+     }
+  }
 
    //----------------------------------------------------------------

XIOS/dev/dev_olga/src/node/field.hpp

@@ -99 +99 @@
 
        public:
-         bool isActive(void) const;
+         bool isActive(bool atCurrentTimestep = false) const;
          bool hasOutputFile;
 
@@ -150 +150 @@
         void recvUpdateData(std::map<int,CBufferIn*>& rankBuffers);
         void writeField(void);
-        void sendReadDataRequest(const CDate& tsDataRequested);
+        bool sendReadDataRequest(const CDate& tsDataRequested);
         bool sendReadDataRequestIfNeeded(void);
         static void recvReadDataRequest(CEventServer& event);
@@ -157 +157 @@
         static void recvReadDataReady(CEventServer& event);
         void recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers);
+        void outputField(CArray<double,3>& fieldOut);
+        void outputField(CArray<double,2>& fieldOut);
         void outputField(CArray<double,1>& fieldOut);
+        void inputField(CArray<double,3>& fieldOut);
+        void inputField(CArray<double,2>& fieldOut);
         void inputField(CArray<double,1>& fieldOut);
         void outputCompressedField(CArray<double, 1>& fieldOut);
@@ -240 +244 @@
          //! The terminal filter which stores the instant data
          boost::shared_ptr<CStoreFilter> storeFilter;
-         //! The terminal filter which sends the data to file
+         //! The terminal filter which writes the data to file
          boost::shared_ptr<CFileWriterFilter> fileWriterFilter;
          //! The terminal filter which writes data to file

XIOS/dev/dev_olga/src/node/file.cpp

@@ -14 +14 @@
 #include "type.hpp"
 #include "xios_spl.hpp"
+#include "context_client.hpp"
 #include "mpi.hpp"
+#include "timer.hpp"
 
 namespace xios {
@@ -49 +51 @@
    //----------------------------------------------------------------
 
-   const StdString& CFile::getFileOutputName(void) const
-   {
-     return name.isEmpty() ? getId() : name;
+   const StdString CFile::getFileOutputName(void) const
+   {
+     return (name.isEmpty() ? getId() : name) + (name_suffix.isEmpty() ? StdString("") :  name_suffix.getValue());
    }
 
@@ -215 +217 @@
       if (!split_freq.isEmpty())
       {
-        if (context->registryIn->foundKey("splitStart") && context->registryIn->foundKey("splitEnd"))
+        StdString keySuffix("CContext_"+CContext::getCurrent()->getId()+"::CFile_"+getFileOutputName()+"::") ; 
+        if (context->registryIn->foundKey(keySuffix+"splitStart") && context->registryIn->foundKey(keySuffix+"splitEnd"))
         {
           CDate savedSplitStart(*context->getCalendar()), savedSplitEnd(*context->getCalendar());
-          context->registryIn->getKey("splitStart", savedSplitStart);
-          context->registryIn->getKey("splitEnd",   savedSplitEnd);
+          context->registryIn->getKey(keySuffix+"splitStart", savedSplitStart);
+          context->registryIn->getKey(keySuffix+"splitEnd",   savedSplitEnd);
 
           if (savedSplitStart <= lastSplit && lastSplit <= savedSplitEnd)
@@ -234 +237 @@
       const int recordOffset = record_offset.isEmpty() ? 0 : record_offset;
 
-//      set<CAxis*> setAxis;
-//      set<CDomain*> setDomains;
       set<StdString> setAxis;
       set<StdString> setDomains;
@@ -263 +264 @@
       if (allDomainEmpty) MPI_Comm_free(&fileComm);
 
-      if (time_counter.isEmpty()) time_counter.setValue(time_counter_attr::centered);
+      // if (time_counter.isEmpty()) time_counter.setValue(time_counter_attr::centered);
       if (time_counter_name.isEmpty()) time_counter_name = "time_counter";
     }
@@ -281 +282 @@
         if (mode.isEmpty() || mode.getValue() == mode_attr::write)
         {
+          CTimer::get("Files : create headers").resume();
           if (!isOpen) createHeader();
+          CTimer::get("Files : create headers").suspend();
           checkSync();
         }        
@@ -303 +306 @@
         if (!mode.isEmpty() && mode.getValue() == mode_attr::read)
         {
+          CTimer::get("Files : open headers").resume();
           if (!isOpen) openInReadMode(&(context->server->intraComm));
+          CTimer::get("Files : open headers").suspend();
         }
         //checkSplit(); // Really need for reading?
@@ -374 +379 @@
       {
          StdString filename = getFileOutputName();
-         if (!name_suffix.isEmpty()) filename+=name_suffix.getValue();
 
 // determine splitting format in the file name  : firstPart%start_date%middlePart%end_date%lastPart
@@ -441 +445 @@
            oss << lastPart ;
 
-           context->registryOut->setKey("splitStart", lastSplit);
-           context->registryOut->setKey("splitEnd",   splitEnd);
+           StdString keySuffix("CContext_"+CContext::getCurrent()->getId()+"::CFile_"+getFileOutputName()+"::") ; 
+           context->registryOut->setKey(keySuffix+"splitStart", lastSplit);
+           context->registryOut->setKey(keySuffix+"splitEnd",   splitEnd);
          }
          else oss<<firstPart<<lastPart ;
@@ -489 +494 @@
          if (isOpen) data_out->closeFile();
 
-        data_out = shared_ptr<CDataOutput>(new CNc4DataOutput(oss.str(), append, useClassicFormat, useCFConvention,
+        data_out = shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention,
                                                               fileComm, multifile, isCollective, time_counter_name));
         isOpen = true;
@@ -509 +514 @@
           {
             CField* field = *it;
+            this->data_out->writeFieldTimeAxis(field);
+          }
+          
+          for (it = this->enabledFields.begin(); it != end; it++)
+          {
+            CField* field = *it;
             this->data_out->writeField(field);
           }
@@ -517 +528 @@
 
           this->data_out->definition_end();
+        }
+        else
+        {
+          // check time axis even in append mode
+          std::vector<CField*>::iterator it, end = this->enabledFields.end();
+          for (it = this->enabledFields.begin(); it != end; it++)
+          {
+            CField* field = *it;
+            this->data_out->writeFieldTimeAxis(field);
+          }
         }
       }
@@ -535 +556 @@
       StdOStringStream oss;
       oss << filename;
-      if (!name_suffix.isEmpty()) oss << name_suffix.getValue();
 
       if (!split_freq.isEmpty())
@@ -872 +892 @@
    }
 
-
    /*!
    \brief Send a message to create a field on server side

XIOS/dev/dev_olga/src/node/file.hpp

@@ -70 +70 @@
       public:
          /// Accesseurs ///
-         const StdString& getFileOutputName(void) const;
+         const StdString getFileOutputName(void) const;
          boost::shared_ptr<CDataOutput> getDataOutput(void) const;
          boost::shared_ptr<CDataInput> getDataInput(void) const;

XIOS/dev/dev_olga/src/node/grid.cpp

@@ -31 +31 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
       , computedWrittenIndex_(false)
@@ -50 +50 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
       , computedWrittenIndex_(false)
@@ -76 +76 @@
 
 
-   StdSize CGrid::getDimension(void) const
-   {
-      return globalDim_.size();
+   StdSize CGrid::getDimension(void)
+   {
+      return getGlobalDimension().size();
    }
 
@@ -196 +196 @@
         for (int i = 0; i < axisListP.size(); ++i)
         {
-          axisListP[i]->checkAttributesOnClientAfterTransformation(globalDim_,axisPositionInGrid_[i]);
+          axisListP[i]->checkAttributesOnClientAfterTransformation(getGlobalDimension(),axisPositionInGrid_[i]);
         }
       }
@@ -243 +243 @@
      this->solveScalarRef(areAttributesChecked);
      this->solveAxisRef(areAttributesChecked);
-     this->solveDomainRef(areAttributesChecked);
-     computeGridGlobalDimension(getDomains(), getAxis(), getScalars(), axis_domain_order);
+     this->solveDomainRef(areAttributesChecked);     
      this->isDomainAxisChecked = areAttributesChecked;
    }
@@ -311 +310 @@
             {sendIndex(); this->isIndexSent = true;}
        }
+
+       // Not sure about this
+       //if (!(this->hasTransform() && !this->isTransformed()))
+       // this->isChecked = true;
+       //return;
      }
     
@@ -409 +413 @@
       using namespace std;
       std::vector<CDomain*> domainP = this->getDomains();
-      std::vector<CAxis*> axisP = this->getAxis();      
+      std::vector<CAxis*> axisP = this->getAxis();
       int dim = domainP.size() * 2 + axisP.size();
 
@@ -512 +516 @@
         {
           if (sendAtt)
-            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionInGrid_[i]);
+            axisListP[i]->sendCheckedAttributes(getGlobalDimension(),axisPositionInGrid_[i]);
           else
             axisListP[i]->checkAttributesOnClient();
@@ -534 +538 @@
         }
       }
+   }
+   std::vector<int> CGrid::getAxisPositionInGrid() const
+   {
+     return axisPositionInGrid_;
    }
 
@@ -652 +660 @@
               }              
             }
-
-
           }          
         }
@@ -695 +701 @@
        // Compute mapping between client and server
        std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
-       CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize);
+       CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize);
        serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement,
                                                                   client->clientRank,
@@ -933 +939 @@
         }
       }
-     }
+    }
    }
    //----------------------------------------------------------------
@@ -1122 +1128 @@
    }
 
+/*
+   void CGrid::outputField(int rank, const CArray<double, 1>& stored, double* field)
+   {
+     const CArray<size_t,1>& out_i = outIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       field[out_i(n)] = stored(n);
+     }
+   }
+
+   void CGrid::inputField(int rank, const double* const field, CArray<double,1>& stored)
+   {
+     const CArray<size_t,1>& out_i = outIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       stored(n) = field[out_i(n)];
+     }
+   }
+
+   void CGrid::outputCompressedField(int rank, const CArray<double,1>& stored, double* field)
+   {
+     const CArray<size_t,1>& out_i = compressedOutIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       field[out_i(n)] = stored(n);
+     }
+   }
+*/
+   //----------------------------------------------------------------
+
    void CGrid::storeField_arr(const double* const data, CArray<double, 1>& stored) const
    {
@@ -1170 +1209 @@
   {
     CContext* context = CContext::getCurrent();
-    // int nbSrvPools = (context->hasServer) ? context->clientPrimServer.size() : 1;
     int nbSrvPools = (context->hasServer) ? (context->hasClient ? context->clientPrimServer.size() : 0) : 1;
     for (int p = 0; p < nbSrvPools; ++p)
@@ -1538 +1576 @@
   }
 
-  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains,
-                                         const std::vector<CAxis*>& axis,
-                                         const std::vector<CScalar*>& scalars,
-                                         const CArray<int,1>& axisDomainOrder)
-  {
-    globalDim_.resize(domains.size()*2+axis.size()+scalars.size());
+  /*
+     Compute on the fly the global dimension of a grid with its elements
+     \param[in/out] globalDim global dimension of grid
+     \param[in] domains list of its domains
+     \param[in] axiss list of its axis
+     \param[in] scalars list of its scalars
+     \param[in] axisDomainOrder the order of element in a grid (e.g: scalar then axis)
+     \return The dimension of which we do distribution (often for server)
+  */
+  int CGrid::computeGridGlobalDimension(std::vector<int>& globalDim,
+                                        const std::vector<CDomain*> domains,
+                                        const std::vector<CAxis*> axis,
+                                        const std::vector<CScalar*> scalars,
+                                        const CArray<int,1>& axisDomainOrder)
+  {
+    globalDim.resize(domains.size()*2+axis.size()+scalars.size());
+    int positionDimensionDistributed = 1;
     int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0;
     for (int i = 0; i < axisDomainOrder.numElements(); ++i)
@@ -1551 +1600 @@
         if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured))
         {
-          positionDimensionDistributed_ = idx;
+          positionDimensionDistributed = idx;
         }
         else
         {
-          positionDimensionDistributed_ = idx +1;
-        }
-
-        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue();
-        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue();
+          positionDimensionDistributed = idx +1;
+        }
+
+        globalDim[idx]   = domains[idxDomain]->ni_glo.getValue();
+        globalDim[idx+1] = domains[idxDomain]->nj_glo.getValue();
 
         ++idxDomain;
@@ -1566 +1615 @@
       else if (1 == axisDomainOrder(i))
       {
-        globalDim_[idx] = axis[idxAxis]->n_glo.getValue();
+        globalDim[idx] = axis[idxAxis]->n_glo.getValue();
         ++idxAxis;
         ++idx;
@@ -1572 +1621 @@
       else
       {
-        globalDim_[idx] = 1;
+        globalDim[idx] = 1;
         ++idxScalar;
         ++idx;
       }
     }
-  }
-
+
+    return positionDimensionDistributed;
+  }
+
+  // Retrieve the global dimension of grid
   std::vector<int> CGrid::getGlobalDimension()
   {
-    return globalDim_;
+    std::vector<int> globalDim;
+    computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);
+
+    return globalDim;
+  }
+
+  // Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
+  int CGrid::getDistributedDimension()
+  {
+    std::vector<int> globalDim;
+    return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);    
   }
 

XIOS/dev/dev_olga/src/node/grid.hpp

@@ -87 +87 @@
 
          /// Accesseurs ///
-         StdSize getDimension(void) const;
+         StdSize getDimension(void);
 
          StdSize  getDataSize(void) const;
@@ -176 +176 @@
          std::vector<int> getGlobalDimension();
          bool isScalarGrid() const;
+         std::vector<int> getAxisPositionInGrid() const;
 
          bool doGridHaveDataToWrite();
@@ -268 +269 @@
         void computeIndexByElement(const std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
                                    CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
+        int computeGridGlobalDimension(std::vector<int>& globalDim,
+                                       const std::vector<CDomain*> domains,
+                                       const std::vector<CAxis*> axis,
+                                       const std::vector<CScalar*> scalars,
+                                       const CArray<int,1>& axisDomainOrder);
+        int getDistributedDimension();
 
         void computeClientIndex();
@@ -296 +303 @@
         std::vector<int> axisPositionInGrid_;
         CGridTransformation* transformations_;
-        bool hasDomainAxisBaseRef_;
-        std::vector<int> globalDim_;
+        bool hasDomainAxisBaseRef_;        
         std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
         bool hasTransform_;

XIOS/dev/dev_olga/src/node/interpolate_domain.cpp

@@ -55 +55 @@
     {
       case mode_attr::read:
-        if (this->file.isEmpty())
+        if (this->weight_filename.isEmpty())
         {
           if (!this->write_weight)
@@ -64 +64 @@
         else
         {
-          weightFile = this->file;
+          weightFile = this->weight_filename;
           ifstream f(weightFile.c_str());
           if (!f.good())
@@ -75 +75 @@
         break;
       case mode_attr::read_or_compute:
-        if (!this->file.isEmpty() && !this->write_weight)
+        if (!this->weight_filename.isEmpty() && !this->write_weight)
         {
-          weightFile = this->file;
+          weightFile = this->weight_filename;
           ifstream f(weightFile.c_str());
           if (!f.good())

XIOS/dev/dev_olga/src/node/mesh.cpp

@@ -11 +11 @@
 /// ////////////////////// Définitions ////////////////////// ///
 
-  CMesh::CMesh(void) :  nbNodesGlo{0}, nbEdgesGlo{0}
-            ,  node_start{0}, node_count{0}
-            ,  edge_start{0}, edge_count{0}
-            ,  nbFaces_{0}, nbNodes_{0}, nbEdges_{0}
-            ,  nodesAreWritten{false}, edgesAreWritten{false}, facesAreWritten{false}
+  CMesh::CMesh(void) :  nbNodesGlo(0), nbEdgesGlo(0)
+            ,  node_start(0), node_count(0)
+            ,  edge_start(0), edge_count(0)
+            ,  nbFaces_(0), nbNodes_(0), nbEdges_(0)
+            ,  nodesAreWritten(false), edgesAreWritten(false), facesAreWritten(false)
             ,  node_lon(), node_lat()
             ,  edge_lon(), edge_lat(), edge_nodes()
             ,  face_lon(), face_lat()
             ,  face_nodes()
-            ,  pNodeGlobalIndex{NULL}, pEdgeGlobalIndex{NULL}
+            ,  pNodeGlobalIndex(NULL), pEdgeGlobalIndex(NULL)
   {
   }
@@ -91 +91 @@
       seed ^= sizetHash(first) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
     }
-    return seed ;
-  }
-
-///----------------------------------------------------------------
-/*!
- * \fn size_t generateEdgeIndex(size_t first, size_t second, int rank)
- * Generates an edge index.
- * If the same edge is generated by two processes, each process will have its own edge index.
- * \param [in] first Edge node.
- * \param [in] second Edge node.
- * \param [in] rank MPI process rank.
- */
-  size_t generateEdgeIndex(size_t first, size_t second, int rank)
-  {
-    size_t seed = rank ;
-    if (first < second)
-    {
-      seed = hashPair(seed, first);
-      seed = hashPair(seed, second);
-    }
-    else
-    {
-      seed = hashPair(seed, second);
-      seed = hashPair(seed, first);
-    }
-
     return seed ;
   }
@@ -141 +115 @@
     return seed ;
   }
+
+  ///----------------------------------------------------------------
+  /*!
+   * \fn size_t generateNodeIndex(vector<size_t>& valList)
+   * Generates a node index unique for all processes.
+   * \param [in] valList Vector storing four node hashes.
+   */
+    size_t generateNodeIndex(vector<size_t>& valList)
+    {
+      // Sort is needed to avoid problems for nodes with lon = 0 generated by faces in east and west semisphere
+      vector<size_t> vec = valList;
+      sort (vec.begin(), vec.end());
+      size_t seed = vec[0] ;
+      int it = 1;
+      for(; it != vec.size(); ++it)
+      {
+         seed = hashPair(seed, vec[it]);
+      }
+      return seed ;
+    }
+
 
 ///----------------------------------------------------------------
@@ -600 +595 @@
         CClientClientDHTSizet::Index2VectorInfoTypeMap nodeHash2Idx;
         CArray<size_t,1> nodeHashList(nbEdges_*nvertex*4);
+        int nbHash = 0;
         for (int ne = 0; ne < nbEdges_; ++ne)
         {
@@ -609 +605 @@
               if (nodeHash2Idx[hashValues[nh]].size() == 0)
               {
-                nodeHash2Idx[hashValues[nh]].push_back(generateNodeIndex(hashValues, mpiRank));
+                nodeHash2Idx[hashValues[nh]].push_back(generateNodeIndex(hashValues));
                 nodeHash2Idx[hashValues[nh]].push_back(mpiRank);
+                nodeHashList(nbHash) = hashValues[nh];
+                ++nbHash;
               }
-              nodeHashList((ne*nvertex + nv)*4 + nh) = hashValues[nh];
-            }
-          }
-        }
+            }
+          }
+        }
+        nodeHashList.resizeAndPreserve(nbHash);
 
         // (2.2) Generating global node indexes
-        // The ownership criterion: priority of the process holding the smaller index
+        // The ownership criterion: priority of the process of smaller index
         // Maps generated in this step are:
-        // nodeHash2Info = <hash, [[idx1, rank1], [idx2, rank2], [idx3, rank3]..]>
-        // nodeIdx2IdxMin = <idx, idxMin>
-        // nodeIdx2IdxGlo = <idxMin, idxMin>
-
-        CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2IdxMin;
-        CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2IdxGlo;
-        CArray<size_t,1> nodeIdxMinList(nbEdges_*nvertex);
-
-        CClientClientDHTSizet dhtNodeHash(nodeHash2Idx, comm);
-        dhtNodeHash.computeIndexInfoMapping(nodeHashList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeHash2Info = dhtNodeHash.getInfoIndexMap();
-        size_t iIdxMin = 0;
-
-        for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = nodeHash2Info.begin(); it != nodeHash2Info.end(); ++it)
-        {
-          size_t idx = (it->second)[0];
-          size_t idxMin = (it->second)[0];
-          for (int i = 2; i < (it->second).size();)
-          {
-            if (mpiRank == (it->second)[i+1])
-            {
-              idx = (it->second)[i];
-            }
-            if ((it->second)[i] < idxMin)
-            {
-                idxMin = (it->second)[i];
-                (it->second)[i] = (it->second)[i-2];
-            }
-            i += 2;
-          }
-          (it->second)[0] = idxMin;
-          if (nodeIdx2IdxMin.count(idx) == 0)
-          {
-            nodeIdx2IdxMin[idx].push_back(idxMin);
-            if (idx == idxMin)
-              nodeIdx2IdxGlo[idxMin].push_back(idxMin);
-            nodeIdxMinList(iIdxMin) = idxMin;
-            ++iIdxMin;
-          }
-        }
-        nodeIdxMinList.resizeAndPreserve(iIdxMin);
-        CDHTAutoIndexing dhtNodeIdxGlo = CDHTAutoIndexing(nodeIdx2IdxGlo, comm);
-        CClientClientDHTSizet dhtNodeIdx(nodeIdx2IdxGlo, comm);
-        dhtNodeIdx.computeIndexInfoMapping(nodeIdxMinList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeIdxMin2IdxGlo = dhtNodeIdx.getInfoIndexMap();
-        // nodeIdx2IdxGlo holds global indexes only for nodes owned by a process
-        // nodeIdxMin2IdxGlo holds global indexes for all nodes generated by a process
+        // Maps generated in this step are:
+         // nodeHash2Info = <hash, [[idx, rankMin], [idx, rank1], [idx, rank3]..]>
+         // nodeIdx2Idx = <idx, <rankOwner, idx>>
+
+         CClientClientDHTSizet dhtNodeHash(nodeHash2Idx, comm);
+         dhtNodeHash.computeIndexInfoMapping(nodeHashList);
+         CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeHash2Info = dhtNodeHash.getInfoIndexMap();
+
+
+         CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2Idx;
+         CArray<size_t,1> nodeIdxList(nbEdges_*nvertex*4);
+         size_t nIdx = 0;
+
+         for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = nodeHash2Info.begin(); it != nodeHash2Info.end(); ++it)
+         {
+           size_t rankMin = (it->second)[1];
+           size_t idx = (it->second)[0];
+           for (int i = 2; i < (it->second).size();)
+           {
+             if ( (it->second)[i+1] < rankMin)
+             {
+               idx = (it->second)[i];
+               rankMin = (it->second)[i+1];
+               (it->second)[i+1] = (it->second)[i-1];
+             }
+             i += 2;
+           }
+           if (nodeIdx2Idx.count(idx) == 0)
+           {
+             if (mpiRank == rankMin)
+             {
+               nodeIdx2Idx[idx].push_back(rankMin);
+               nodeIdx2Idx[idx].push_back(idx);
+             }
+             nodeIdxList(nIdx) = idx;
+             ++nIdx;
+           }
+         }
+         nodeIdxList.resizeAndPreserve(nIdx);
+
+         // CDHTAutoIndexing will not give consistent node numbering for varying number of procs. =>
+         // Solution: global node indexing by hand.
+         // Maps modified in this step:
+         // nodeIdx2Idx = <idx, idxGlo>
+         int nodeCount = nodeIdx2Idx.size();
+         int nodeStart, nbNodes;
+         MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+         int nNodes = nodeStart;
+         MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+         nbNodesGlo = nNodes;
+
+         nodeStart -= nodeCount;
+         node_start = nodeStart;
+         node_count = nodeCount;
+         CClientClientDHTSizet::Index2VectorInfoTypeMap dummyMap; // just a dummy map used to ensure that each node is numbered only once
+         size_t count = 0;
+
+         for (int ne = 0; ne < nbEdges_; ++ne)
+         {
+           for (int nv = 0; nv < nvertex; ++nv)
+           {
+             vector<size_t> hashValues = CMesh::createHashes(bounds_lon(nv, ne), bounds_lat(nv, ne));
+             size_t nodeIdx = generateNodeIndex(hashValues);
+             CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = nodeIdx2Idx.find(nodeIdx);
+             if (it != nodeIdx2Idx.end())
+             {
+               if (dummyMap.count(nodeIdx) == 0)
+               {
+                 dummyMap[nodeIdx].push_back(nodeIdx);
+                 (it->second)[1] = node_start + count;
+                 ++count;
+               }
+             }
+           }
+         }
+
+         CClientClientDHTSizet dhtNodeIdx(nodeIdx2Idx, comm);
+         dhtNodeIdx.computeIndexInfoMapping(nodeIdxList);
+         CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeIdx2IdxGlo = dhtNodeIdx.getInfoIndexMap();
 
         // (2.3) Saving variables: node_lon, node_lat, edge_nodes
         // Creating map nodeHash2IdxGlo <hash, idxGlo>
         // Creating map edgeHash2IdxGlo <hash, idxGlo>
-        nbNodesGlo = dhtNodeIdxGlo.getNbIndexesGlobal();
-        node_count = dhtNodeIdxGlo.getIndexCount();
-        node_start = dhtNodeIdxGlo.getIndexStart();
+//        nbNodesGlo = dhtNodeIdxGlo.getNbIndexesGlobal();
+//        node_count = dhtNodeIdxGlo.getIndexCount();
+//        node_start = dhtNodeIdxGlo.getIndexStart();
         CClientClientDHTSizet::Index2VectorInfoTypeMap nodeHash2IdxGlo;
         node_lon.resize(node_count);
@@ -685 +715 @@
           {
             hashValues = CMesh::createHashes(bounds_lon(nv, ne), bounds_lat(nv, ne));
-            size_t myIdx = generateNodeIndex(hashValues, mpiRank);
-            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = nodeIdx2IdxMin.find(myIdx);
-            size_t ownerIdx = (itIdx->second)[0];
-
-            if (myIdx == ownerIdx)
-            {
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = nodeIdx2IdxGlo.find(myIdx);
-              idxGlo = (itIdxGlo->second)[0];
+            size_t myIdx = generateNodeIndex(hashValues);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = nodeIdx2IdxGlo.find(myIdx);
+            idxGlo = (itIdx->second)[1];
+
+            if (mpiRank == (itIdx->second)[0])
+            {
 //              node_lon(idxGlo - node_start) = (bounds_lon(nv, ne) == 360.) ? (0.) : (bounds_lon(nv, ne));
               node_lon(idxGlo - node_start) = bounds_lon(nv, ne);
               node_lat(idxGlo - node_start) = bounds_lat(nv, ne);
             }
-            else
-            {
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = nodeIdxMin2IdxGlo.find(ownerIdx);
-              idxGlo = (itIdxGlo->second)[0];
-            }
-
             edge_nodes(nv,ne) = idxGlo;
             for (int nh = 0; nh < 4; ++nh)
@@ -793 +815 @@
         CClientClientDHTSizet::Index2VectorInfoTypeMap edgeHash2Rank;
         CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdxGlo2Face;
-        CArray<size_t,1> edgeIdxGloList(nbFaces_*nvertex);
+        CArray<size_t,1> edgeIdxList(nbFaces_*nvertex);
         size_t iIdx = 0;
 
@@ -824 +846 @@
               if (edgeIdxGlo2Face.count(edgeIdxGlo) == 0)
               {
-                edgeIdxGloList(iIdx) = edgeIdxGlo;
+                edgeIdxList(iIdx) = edgeIdxGlo;
                 ++iIdx;
               }
               edgeIdxGlo2Face[edgeIdxGlo].push_back(faceIdxGlo);
-              edgeHash2Rank[edgeHash].push_back(itEdgeHash->first);
               edgeHash2Rank[edgeHash].push_back(mpiRank);
+              edgeHash2Rank[edgeHash].push_back(itEdgeHash->second[0]);
             }
             else
@@ -837 +859 @@
           }
         }
-        edgeIdxGloList.resizeAndPreserve(iIdx);
+        edgeIdxList.resizeAndPreserve(iIdx);
 
         // (1.3) Saving remaining variables edge_faces and face_faces
@@ -846 +868 @@
         dhtEdgeHash.computeIndexInfoMapping(edgeHashList);
         CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeHash2Info = dhtEdgeHash.getInfoIndexMap();
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeHashMin2IdxGlo;
-
-        // edgeHash2Info = <edgeHash, <idxGlo, rank1, idxGlo, rank2>>
-        // edgeHashMin2IdxGlo = <edgeHashMin, idxGlo>
+
+        // edgeHash2Info = <edgeHash, < rank1, idxGlo, rank2, idxGlo>>
+        int edgeCount = 0;
         for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeHash2Info.begin(); it != edgeHash2Info.end(); ++it)
         {
           vector <size_t> edgeInfo = it->second;
-          if (edgeInfo.size() == 4)                       // two processes generate the same edge
-            if (edgeInfo[1] > edgeInfo[3])
-              edgeInfo[1] = edgeInfo[3];
-          if (edgeInfo[1] == mpiRank)
-            edgeHashMin2IdxGlo[it->first].push_back(edgeInfo[0]);
-        }
-
-        CDHTAutoIndexing dhtEdgeIdxGlo = CDHTAutoIndexing(edgeHashMin2IdxGlo, comm);
-        edge_count = dhtEdgeIdxGlo.getIndexCount();
-        edge_start = dhtEdgeIdxGlo.getIndexStart();
+          if (edgeInfo[0] == mpiRank)
+          {
+            ++edgeCount;
+          }
+        }
+
+        int edgeStart, nbEdges;
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        int nEdges = edgeStart;
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        nbEdgesGlo = nEdges;
+
+        // edges to be splitted equally between procs
+        if ( (nbEdgesGlo % mpiSize) == 0)
+        {
+          edge_count = nbEdgesGlo/mpiSize;
+          edge_start = mpiRank*edge_count;
+        }
+        else
+        {
+          if (mpiRank == (mpiSize - 1) )
+          {
+            edge_count = nbEdgesGlo/mpiSize;
+            edge_start = mpiRank*(nbEdgesGlo/mpiSize + 1);
+          }
+          else
+          {
+            edge_count = nbEdgesGlo/mpiSize + 1;
+            edge_start = mpiRank*edge_count;
+          }
+        }
+        CArray<size_t,1> edgeIdxGloList(edge_count);
+        for (int i = 0; i < edge_count; ++i)
+        {
+          edgeIdxGloList(i) = i + edge_start;
+        }
+
+        CClientClientDHTSizet dhtEdgeIdxGlo2Face (edgeIdxGlo2Face, comm);
+        CClientClientDHTSizet dhtEdge2Face (edgeIdxGlo2Face, comm);
+        dhtEdgeIdxGlo2Face.computeIndexInfoMapping(edgeIdxGloList);
+        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdxGlo2FaceIdx = dhtEdgeIdxGlo2Face.getInfoIndexMap();
+        dhtEdge2Face.computeIndexInfoMapping(edgeIdxList);
+        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdx2FaceIdx = dhtEdge2Face.getInfoIndexMap();
+
 
         edge_faces.resize(2, edge_count);
+        for (int i = 0; i < edge_count; ++i)
+        {
+          CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeIdxGlo2FaceIdx.find(i + edge_start);
+          int indexGlo = it->first;
+          vector<size_t> faces = it->second;
+          int face1 = faces[0];
+          edge_faces(0, indexGlo - edge_start) = face1;
+          if (faces.size() == 2)
+          {
+            int face2 = faces[1];
+            edge_faces(1, indexGlo - edge_start) = face2;
+          }
+          else
+          {
+            edge_faces(1, indexGlo - edge_start) = -999;
+          }
+        }
+
+        size_t tmp;
+        vector<size_t> tmpVec;
+        for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeIdx2FaceIdx.begin(); it != edgeIdx2FaceIdx.end(); it++)
+        {
+          tmp = it->first;
+          tmpVec = it->second;
+          tmp++;
+        }
+
+        CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itFace1, itFace2, itIndex;
         face_faces.resize(nvertex, nbFaces_);
-
-        CClientClientDHTSizet dhtEdge2Face (edgeIdxGlo2Face, comm);
-        dhtEdge2Face.computeIndexInfoMapping(edgeIdxGloList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdxGlo2FaceIdx = dhtEdge2Face.getInfoIndexMap();
-        CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itFace1, itFace2;
-
         for (int nf = 0; nf < nbFaces_; ++nf)
         {
@@ -896 +973 @@
               size_t faceIdxGlo = nbFacesAccum + nf;
               size_t edgeHash = hashPairOrdered(it1->second[0], it2->second[0]);
-              itEdgeHash = edgeHash2IdxGlo.find(edgeHash);
-              if (itEdgeHash != edgeHashMin2IdxGlo.end())
+              itEdgeHash = edgeHash2Info.find(edgeHash);
+              int edgeIdxGlo = (itEdgeHash->second)[1];
+
+              if ( (itEdgeHash->second)[0] == mpiRank)
               {
-                int edgeIdxGlo = itEdgeHash->second[0];
-                itFace1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
+                itFace1 = edgeIdx2FaceIdx.find(edgeIdxGlo);
                 int face1 = itFace1->second[0];
                 if (itFace1->second.size() == 1)
                 {
-                  edge_faces(0, edgeIdxGlo - edge_start) = face1;
-                  edge_faces(1, edgeIdxGlo - edge_start) = -999;
                   face_faces(nv1, nf) = 999999;
                 }
@@ -911 +987 @@
                 {
                   int face2 = itFace1->second[1];
-                  edge_faces(0, edgeIdxGlo - edge_start) = face1;
-                  edge_faces(1, edgeIdxGlo - edge_start) = face2;
                   face_faces(nv1, nf) = (faceIdxGlo == face1 ? face2 : face1);
                 }
@@ -918 +992 @@
               else
               {
-                itEdgeHash = edgeHashMin2IdxGlo.find(edgeHash);
-                size_t edgeIdxGlo = itEdgeHash->second[0];
-                itFace1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
+                itFace1 = edgeIdx2FaceIdx.find(edgeIdxGlo);
                 int face1 = itFace1->second[0];
                 int face2 = itFace1->second[1];
@@ -957 +1029 @@
         CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it1, it2;
         CArray<size_t,1> edgeHashList(nbFaces_*nvertex);
+        int nEdgeHash = 0;
         for (int nf = 0; nf < nbFaces_; ++nf)
         {
@@ -978 +1051 @@
             face_nodes(nv1,nf) = it1->second[0];
             size_t edgeHash = hashPairOrdered(it1->second[0], it2->second[0]);
-            edgeHash2Idx[edgeHash].push_back(generateEdgeIndex(it1->second[0], it2->second[0], mpiRank));
-            edgeHash2Idx[edgeHash].push_back(mpiRank);
-            edgeHashList(nf*nvertex + nv1) = edgeHash;
-          }
-        }
-
-        // (2.2) Generating global edge indexes
-        // The ownership criterion: priority of the process holding the smaller index
+            if (edgeHash2Idx.count(edgeHash) == 0)
+            {
+              edgeHash2Idx[edgeHash].push_back(edgeHash);
+              edgeHash2Idx[edgeHash].push_back(mpiRank);
+              edgeHashList(nEdgeHash) = edgeHash;
+              ++nEdgeHash;
+            }
+          }
+        }
+        edgeHashList.resizeAndPreserve(nEdgeHash);
+
+        // (2.3) Generating global edge indexes
+        // The ownership criterion: priority of the process with smaller rank
         // Maps generated in this step are:
-        // edgeHash2Info = <hash, [[idx1, rank1], [idx2, rank2], [idx3, rank3]..]>
-        // edgeIdx2IdxMin = = <idx, idxMin>
-        // edgeIdx2IdxGlo = <idxMin, idxGlo>
+        // edgeIdx2Idx = = <idx, <rankOwner, idx>>
+        // edgeIdx2IdxGlo = <idxMin, <rankOwner, idxGlo>>
 
         CClientClientDHTSizet dhtEdgeHash(edgeHash2Idx, comm);
         dhtEdgeHash.computeIndexInfoMapping(edgeHashList);
         CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeHash2Info = dhtEdgeHash.getInfoIndexMap();
-
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2IdxMin;
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2IdxGlo;
-        CArray<size_t,1> edgeIdxMinList(nbFaces_*nvertex);
-        size_t iIdxMin = 0;
+        // edgeHash2Info = <hash, [[idx1, rank1], [idx2, rank2], [idx3, rank3]..]>
+
+        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2Idx;
 
         for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeHash2Info.begin(); it != edgeHash2Info.end(); ++it)
         {
-          size_t idxMin = (it->second)[0];
+          size_t rankMin = (it->second)[1];
           size_t idx = (it->second)[0];
+
           for (int i = 2; i < (it->second).size();)
           {
-            if (mpiRank == (it->second)[i+1])
-            {
+            if ((it->second)[i+1] < rankMin)
+            {
+              rankMin = (it->second)[i+1];
               idx = (it->second)[i];
-            }
-            if ((it->second)[i] < idxMin)
-            {
-                idxMin = (it->second)[i];
-                (it->second)[i] = (it->second)[i-2];
+              (it->second)[i+1] = (it->second)[i-1];
             }
             i += 2;
           }
-          (it->second)[0] = idxMin;
-          if (edgeIdx2IdxMin.count(idx) == 0)
-          {
-            edgeIdx2IdxMin[idx].push_back(idxMin);
-            if (idx == idxMin)
-              edgeIdx2IdxGlo[idxMin].push_back(idxMin);
-            edgeIdxMinList(iIdxMin) = idxMin;
-            ++iIdxMin;
-          }
-        }
-        edgeIdxMinList.resizeAndPreserve(iIdxMin);
-        CDHTAutoIndexing dhtEdgeIdxGlo = CDHTAutoIndexing(edgeIdx2IdxGlo, comm);
-        CClientClientDHTSizet dhtEdgeIdx(edgeIdx2IdxGlo, comm);
-        dhtEdgeIdx.computeIndexInfoMapping(edgeIdxMinList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdxMin2IdxGlo = dhtEdgeIdx.getInfoIndexMap();
-        // edgeIdx2IdxGlo holds global indexes only for edges owned by a process
-        // edgeIdxMin2IdxGlo holds global indexes for all edges generated by a process
-
-        // (2.3) Saving variables: edge_lon, edge_lat, face_edges
-        nbEdgesGlo = dhtEdgeIdxGlo.getNbIndexesGlobal();
-        edge_count = dhtEdgeIdxGlo.getIndexCount();
-        edge_start = dhtEdgeIdxGlo.getIndexStart();
-        edge_lon.resize(edge_count);
-        edge_lat.resize(edge_count);
-        edge_nodes.resize(2, edge_count);
-        face_edges.resize(nvertex, nbFaces_);
-
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdxGlo2Face;
-        CArray<size_t,1> edgeIdxGloList(nbFaces_*nvertex);
-        size_t iIdx = 0;
+          if (edgeIdx2Idx.count(idx) == 0)
+          {
+            if (mpiRank == rankMin)
+            {
+              edgeIdx2Idx[idx].push_back(rankMin);
+              edgeIdx2Idx[idx].push_back(idx);
+            }
+          }
+        }
+
+        int edgeCount = edgeIdx2Idx.size();
+        int edgeStart, nbEdges;
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        int nEdges = edgeStart;
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        nbEdgesGlo = nEdges;
+
+        edgeStart -= edgeCount;
+        edge_start = edgeStart;
+        edge_count = edgeCount;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap dummyEdgeMap;
+        int count = 0;
 
         for (int nf = 0; nf < nbFaces_; ++nf)
@@ -1068 +1133 @@
               it2 = nodeHash2IdxGlo.find(nodeHashList((nf*nvertex + nv1)*4 + nh2));
             }
+            size_t nodeIdxGlo1 = it1->second[0];
+            size_t nodeIdxGlo2 = it2->second[0];
+
+            if (nodeIdxGlo1 != nodeIdxGlo2)
+            {
+              size_t edgeIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
+              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeIdx2Idx.find(edgeIdx);
+              if (it != edgeIdx2Idx.end())
+              {
+                if (dummyEdgeMap.count(edgeIdx) == 0)
+                {
+                  dummyEdgeMap[edgeIdx].push_back(edgeIdx);
+                  (it->second)[1] = edge_start + count;
+                  ++count;
+                }
+              }
+            }
+          }
+        }
+
+        CClientClientDHTSizet dhtEdgeIdx(edgeIdx2Idx, comm);
+        dhtEdgeIdx.computeIndexInfoMapping(edgeHashList);
+        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdx2IdxGlo = dhtEdgeIdx.getInfoIndexMap();
+
+        // (2.4) Saving variables: edge_lon, edge_lat, face_edges
+        edge_lon.resize(edge_count);
+        edge_lat.resize(edge_count);
+        edge_nodes.resize(2, edge_count);
+        face_edges.resize(nvertex, nbFaces_);
+
+        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdxGlo2Face;
+        CArray<size_t,1> edgeIdxGloList(nbFaces_*nvertex);
+        size_t iIdx = 0;
+
+        for (int nf = 0; nf < nbFaces_; ++nf)
+        {
+          for (int nv1 = 0; nv1 < nvertex; ++nv1)
+          {
+            // Getting global indexes of edge's nodes
+            int nh1 = 0;
+            int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation
+            it1 = nodeHash2IdxGlo.find(nodeHashList((nf*nvertex + nv1)*4 + nh1));
+            while (it1 == nodeHash2IdxGlo.end())
+            {
+              ++nh1;
+              it1 = nodeHash2IdxGlo.find(nodeHashList((nf*nvertex + nv1)*4 + nh1));
+            }
+            int nh2 = 0;
+            it2 = nodeHash2IdxGlo.find(nodeHashList((nf*nvertex + nv2)*4 + nh2));
+            while (it2 == nodeHash2IdxGlo.end())
+            {
+              ++nh2;
+              it2 = nodeHash2IdxGlo.find(nodeHashList((nf*nvertex + nv1)*4 + nh2));
+            }
             // Getting edge global index
             size_t nodeIdxGlo1 = it1->second[0];
             size_t nodeIdxGlo2 = it2->second[0];
-            size_t myIdx = generateEdgeIndex(nodeIdxGlo1, nodeIdxGlo2, mpiRank);
+            size_t myIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
             if (nodeIdxGlo1 != nodeIdxGlo2)
             {
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxMin.find(myIdx);
-              size_t ownerIdx = (itIdx->second)[0];
-              int edgeIdxGlo = 0;
+              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxGlo.find(myIdx);
+              int edgeIdxGlo = (itIdx->second)[1];
               size_t faceIdxGlo = nbFacesAccum + nf;
 
-              if (myIdx == ownerIdx)
+              if (mpiRank == (itIdx->second)[0])
               {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdx2IdxGlo.find(myIdx);
-                edgeIdxGlo = (itIdxGlo->second)[0];
                 double edgeLon;
                 double diffLon = abs(bounds_lon(nv1, nf) - bounds_lon(nv2, nf));
@@ -1096 +1212 @@
                 edge_nodes(1, edgeIdxGlo - edge_start) = nodeIdxGlo2;
               }
-              else
-              {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdxMin2IdxGlo.find(ownerIdx);
-                edgeIdxGlo = (itIdxGlo->second)[0];
-              }
               face_edges(nv1,nf) = edgeIdxGlo;
               if (edgeIdxGlo2Face.count(edgeIdxGlo) == 0)
@@ -1117 +1228 @@
         edgeIdxGloList.resizeAndPreserve(iIdx);
 
-        // (2.4) Saving remaining variables edge_faces and face_faces
+        // (2.5) Saving remaining variables edge_faces and face_faces
         edge_faces.resize(2, edge_count);
         face_faces.resize(nvertex, nbFaces_);
@@ -1125 +1236 @@
         CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdxGlo2FaceIdx = dhtEdge2Face.getInfoIndexMap();
         CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdxGlo1, itNodeIdxGlo2;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx;
 
         for (int nf = 0; nf < nbFaces_; ++nf)
@@ -1149 +1261 @@
             size_t nodeIdxGlo2 = it2->second[0];
 
-            size_t myIdx = generateEdgeIndex(nodeIdxGlo1, nodeIdxGlo2, mpiRank);
-            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxMin.find(myIdx);
-            size_t ownerIdx = (itIdx->second)[0];
+            size_t myIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
+            itIdx = edgeIdx2IdxGlo.find(myIdx);
             size_t faceIdxGlo = nbFacesAccum + nf;
-
-            if (myIdx == ownerIdx)
-            {
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdx2IdxGlo.find(myIdx);
-              int edgeIdxGlo = (itIdxGlo->second)[0];
+            int edgeIdxGlo = (itIdx->second)[1];
+
+            if (mpiRank == (itIdx->second)[0])
+            {
               it1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
               int face1 = it1->second[0];
@@ -1176 +1286 @@
             else
             {
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdxMin2IdxGlo.find(ownerIdx);
-              size_t edgeIdxGlo = (itIdxGlo->second)[0];
               it1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
               int face1 = it1->second[0];
@@ -1200 +1308 @@
           {
             hashValues = CMesh::createHashes(bounds_lon(nv, nf), bounds_lat(nv, nf));
-            size_t nodeIndex = generateNodeIndex(hashValues, mpiRank);
+//            size_t nodeIndex = generateNodeIndex(hashValues, mpiRank);
+            size_t nodeIndex = generateNodeIndex(hashValues);
             for (int nh = 0; nh < 4; ++nh)
             {
@@ -1216 +1325 @@
 
         // (3.2) Generating global node indexes
-        // The ownership criterion: priority of the process holding the smaller index
+        // The ownership criterion: priority of the process with smaller rank.
+        // With any other criterion it is not possible to have consistent node indexing for different number of procs.
         // Maps generated in this step are:
-        // nodeHash2Info = <hash, [[idxMin, rankMin], [idx1, rank1], [idx3, rank3]..]>
-        // nodeIdx2IdxMin = = <idx, idxMin>
-        // nodeIdx2IdxGlo = <idxMin, idxGlo>
+        // nodeHash2Info = <hash, [[idx, rankMin], [idx, rank1], [idx, rank3]..]>
+        // nodeIdx2Idx = <idx, <rankOwner, idx>>
 
         CClientClientDHTSizet dhtNodeHash(nodeHash2Idx, comm);
@@ -1226 +1335 @@
         CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeHash2Info = dhtNodeHash.getInfoIndexMap();
 
-        CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2IdxMin;
-        CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2IdxGlo;
-        CArray<size_t,1> nodeIdxMinList(nbFaces_*nvertex*4);
-        size_t iIdxMin = 0;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap nodeIdx2Idx;
+        CArray<size_t,1> nodeIdxList(nbFaces_*nvertex*4);
+        size_t nIdx = 0;
 
         for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = nodeHash2Info.begin(); it != nodeHash2Info.end(); ++it)
         {
-          size_t idxMin = (it->second)[0];
+          size_t rankMin = (it->second)[1];
           size_t idx = (it->second)[0];
           for (int i = 2; i < (it->second).size();)
           {
-            if (mpiRank == (it->second)[i+1])
+            if ( (it->second)[i+1] < rankMin)
             {
               idx = (it->second)[i];
-            }
-            if ((it->second)[i] < idxMin)
-            {
-                idxMin = (it->second)[i];
-                (it->second)[i] = (it->second)[i-2];
+              rankMin = (it->second)[i+1];
+              (it->second)[i+1] = (it->second)[i-1];
             }
             i += 2;
           }
-          (it->second)[0] = idxMin;
-          if (nodeIdx2IdxMin.count(idx) == 0)
-          {
-            nodeIdx2IdxMin[idx].push_back(idxMin);
-            if (idx == idxMin)
-              nodeIdx2IdxGlo[idxMin].push_back(idxMin);
-            nodeIdxMinList(iIdxMin) = idxMin;
-            ++iIdxMin;
-          }
-        }
-
-        nodeIdxMinList.resizeAndPreserve(iIdxMin);
-        CDHTAutoIndexing dhtNodeIdxGlo = CDHTAutoIndexing(nodeIdx2IdxGlo, comm);
-        CClientClientDHTSizet dhtNodeIdx(nodeIdx2IdxGlo, comm);
-        dhtNodeIdx.computeIndexInfoMapping(nodeIdxMinList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeIdxMin2IdxGlo = dhtNodeIdx.getInfoIndexMap();
+          if (nodeIdx2Idx.count(idx) == 0)
+          {
+            if (mpiRank == rankMin)
+            {
+              nodeIdx2Idx[idx].push_back(rankMin);
+              nodeIdx2Idx[idx].push_back(idx);
+            }
+            nodeIdxList(nIdx) = idx;
+            ++nIdx;
+          }
+        }
+
+//        CDHTAutoIndexing dhtNodeIdxGlo = CDHTAutoIndexing(nodeIdx2Idx, comm);
+        // CDHTAutoIndexing will not give consistent node numbering for varying number of procs. =>
+        // Solution: global node indexing by hand.
+        // Maps modified in this step:
+        // nodeIdx2Idx = <idx, idxGlo>
+        int nodeCount = nodeIdx2Idx.size();
+        int nodeStart, nbNodes;
+        MPI_Scan(&nodeCount, &nodeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        int nNodes = nodeStart;
+        MPI_Bcast(&nNodes, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        nbNodesGlo = nNodes;
+
+        nodeStart -= nodeCount;
+        node_start = nodeStart;
+        node_count = nodeCount;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap dummyMap; // just a dummy map used to ensure that each node is numbered only once
+        size_t count = 0;
+
+        for (int nf = 0; nf < nbFaces_; ++nf)
+        {
+          for (int nv = 0; nv < nvertex; ++nv)
+          {
+            vector<size_t> hashValues = CMesh::createHashes(bounds_lon(nv, nf), bounds_lat(nv, nf));
+            size_t nodeIdx = generateNodeIndex(hashValues);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = nodeIdx2Idx.find(nodeIdx);
+            if (it != nodeIdx2Idx.end())
+            {
+              if (dummyMap.count(nodeIdx) == 0)
+              {
+                dummyMap[nodeIdx].push_back(nodeIdx);
+                (it->second)[1] = node_start + count;
+                ++count;
+              }
+            }
+          }
+        }
+        nodeIdxList.resizeAndPreserve(nIdx);
+        CClientClientDHTSizet dhtNodeIdx(nodeIdx2Idx, comm);
+        dhtNodeIdx.computeIndexInfoMapping(nodeIdxList);
+        CClientClientDHTSizet::Index2VectorInfoTypeMap& nodeIdx2IdxGlo = dhtNodeIdx.getInfoIndexMap();
 
         // (3.3) Saving node data: node_lon, node_lat, and face_nodes
         // Generating edgeHash2Info = <hash, <idx, rank>> and edgeHashList
-        nbNodesGlo = dhtNodeIdxGlo.getNbIndexesGlobal();
-        node_count = dhtNodeIdxGlo.getIndexCount();
-        node_start = dhtNodeIdxGlo.getIndexStart();
+//        nbNodesGlo = dhtNodeIdxGlo.getNbIndexesGlobal();
+//        node_count = dhtNodeIdxGlo.getIndexCount();
+//        node_start = dhtNodeIdxGlo.getIndexStart();
         node_lon.resize(node_count);
         node_lat.resize(node_count);
@@ -1286 +1427 @@
             vector<size_t> hashValues1 = CMesh::createHashes(bounds_lon(nv1, nf), bounds_lat(nv1, nf));
             vector<size_t> hashValues2 = CMesh::createHashes(bounds_lon(nv2, nf), bounds_lat(nv2, nf));
-            size_t myNodeIdx1 = generateNodeIndex(hashValues1, mpiRank);
-            size_t myNodeIdx2 = generateNodeIndex(hashValues2, mpiRank);
-            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx1 = nodeIdx2IdxMin.find(myNodeIdx1);
-            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx2 = nodeIdx2IdxMin.find(myNodeIdx2);
-            size_t ownerNodeIdx = (itNodeIdx1->second)[0];
-
-            if (myNodeIdx1 == ownerNodeIdx)
-            {
-              itNodeIdxGlo1 = nodeIdx2IdxGlo.find(myNodeIdx1);
-              nodeIdxGlo1 = (itNodeIdxGlo1->second)[0];
+            size_t nodeIdx1 = generateNodeIndex(hashValues1);
+            size_t nodeIdx2 = generateNodeIndex(hashValues2);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx1 = nodeIdx2IdxGlo.find(nodeIdx1);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx2 = nodeIdx2IdxGlo.find(nodeIdx2);
+            size_t ownerRank = (itNodeIdx1->second)[0];
+            nodeIdxGlo1 = (itNodeIdx1->second)[1];
+            nodeIdxGlo2 = (itNodeIdx2->second)[1];
+
+            if (mpiRank == ownerRank)
+            {
               node_lon(nodeIdxGlo1 - node_start) = bounds_lon(nv1, nf);
               node_lat(nodeIdxGlo1 - node_start) = bounds_lat(nv1, nf);
             }
-            else
-            {
-              itNodeIdxGlo1 = nodeIdxMin2IdxGlo.find(ownerNodeIdx);
-              nodeIdxGlo1 = (itNodeIdxGlo1->second)[0];
-            }
-            itNodeIdxGlo2 = nodeIdxMin2IdxGlo.find((itNodeIdx2->second)[0]);
-            nodeIdxGlo2 = (itNodeIdxGlo2->second)[0];
             if (nodeIdxGlo1 != nodeIdxGlo2)
             {
               size_t edgeHash = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
-              edgeHash2Idx[edgeHash].push_back(generateEdgeIndex(nodeIdxGlo1, nodeIdxGlo2, mpiRank));
+              edgeHash2Idx[edgeHash].push_back(edgeHash);
               edgeHash2Idx[edgeHash].push_back(mpiRank);
               edgeHashList(nEdgeHash) = edgeHash;
@@ -1321 +1455 @@
         // (3.4) Generating global edge indexes
         // Maps generated in this step are:
-        // edgeIdx2IdxMin = = <idx, idxMin>
-        // edgeIdx2IdxGlo = <idxMin, idxGlo>
+        // edgeIdx2Idx = = <idx, <rankOwner, idx>>
+        // edgeIdx2IdxGlo = <idxMin, <rankOwner, idxGlo>>
 
         CClientClientDHTSizet dhtEdgeHash(edgeHash2Idx, comm);
@@ -1329 +1463 @@
         // edgeHash2Info = <hash, [[idx1, rank1], [idx2, rank2], [idx3, rank3]..]>
 
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2IdxMin;
-        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2IdxGlo;
-        CArray<size_t,1> edgeIdxMinList(nbFaces_*nvertex);
-        iIdxMin = 0;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap edgeIdx2Idx;
 
         for (CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeHash2Info.begin(); it != edgeHash2Info.end(); ++it)
         {
-          size_t idxMin = (it->second)[0];
+          size_t rankMin = (it->second)[1];
           size_t idx = (it->second)[0];
 
           for (int i = 2; i < (it->second).size();)
           {
-            if (mpiRank == (it->second)[i+1])
-            {
+            if ((it->second)[i+1] < rankMin)
+            {
+              rankMin = (it->second)[i+1];
               idx = (it->second)[i];
-            }
-            if ((it->second)[i] < idxMin)
-            {
-                idxMin = (it->second)[i];
-                (it->second)[i] = (it->second)[i-2];
+              (it->second)[i+1] = (it->second)[i-1];
             }
             i += 2;
           }
-          (it->second)[0] = idxMin;
-          if (edgeIdx2IdxMin.count(idx) == 0)
-          {
-            edgeIdx2IdxMin[idx].push_back(idxMin);
-            if (idx == idxMin)
-              edgeIdx2IdxGlo[idxMin].push_back(idxMin);
-            edgeIdxMinList(iIdxMin) = idxMin;
-            ++iIdxMin;
-          }
-        }
-        edgeIdxMinList.resizeAndPreserve(iIdxMin);
-        CDHTAutoIndexing dhtEdgeIdxGlo = CDHTAutoIndexing(edgeIdx2IdxGlo, comm);
-        CClientClientDHTSizet dhtEdgeIdx(edgeIdx2IdxGlo, comm);
-        dhtEdgeIdx.computeIndexInfoMapping(edgeIdxMinList);
-        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdxMin2IdxGlo = dhtEdgeIdx.getInfoIndexMap();
+          if (edgeIdx2Idx.count(idx) == 0)
+          {
+            if (mpiRank == rankMin)
+            {
+              edgeIdx2Idx[idx].push_back(rankMin);
+              edgeIdx2Idx[idx].push_back(idx);
+            }
+          }
+        }
+
+        int edgeCount = edgeIdx2Idx.size();
+        int edgeStart, nbEdges;
+        MPI_Scan(&edgeCount, &edgeStart, 1, MPI_UNSIGNED_LONG, MPI_SUM, comm);
+        int nEdges = edgeStart;
+        MPI_Bcast(&nEdges, 1, MPI_UNSIGNED_LONG, mpiSize-1, comm);
+        nbEdgesGlo = nEdges;
+
+        edgeStart -= edgeCount;
+        edge_start = edgeStart;
+        edge_count = edgeCount;
+        CClientClientDHTSizet::Index2VectorInfoTypeMap dummyEdgeMap;
+        count = 0;
+
+        for (int nf = 0; nf < nbFaces_; ++nf)
+        {
+          for (int nv1 = 0; nv1 < nvertex; ++nv1)
+          {
+            int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation
+            vector<size_t> hashValues1 = CMesh::createHashes(bounds_lon(nv1, nf), bounds_lat(nv1, nf));
+            vector<size_t> hashValues2 = CMesh::createHashes(bounds_lon(nv2, nf), bounds_lat(nv2, nf));
+            size_t nodeIdx1 = generateNodeIndex(hashValues1);
+            size_t nodeIdx2 = generateNodeIndex(hashValues2);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx1 = nodeIdx2IdxGlo.find(nodeIdx1);
+            CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itNodeIdx2 = nodeIdx2IdxGlo.find(nodeIdx2);
+            nodeIdxGlo1 = (itNodeIdx1->second)[1];
+            nodeIdxGlo2 = (itNodeIdx2->second)[1];
+
+            if (nodeIdxGlo1 != nodeIdxGlo2)
+            {
+              size_t edgeIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
+              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator it = edgeIdx2Idx.find(edgeIdx);
+              if (it != edgeIdx2Idx.end())
+              {
+                if (dummyEdgeMap.count(edgeIdx) == 0)
+                {
+                  dummyEdgeMap[edgeIdx].push_back(edgeIdx);
+                  (it->second)[1] = edge_start + count;
+                  ++count;
+                }
+              }
+            }
+          }
+        }
+        CClientClientDHTSizet dhtEdgeIdx(edgeIdx2Idx, comm);
+        dhtEdgeIdx.computeIndexInfoMapping(edgeHashList);
+        CClientClientDHTSizet::Index2VectorInfoTypeMap& edgeIdx2IdxGlo = dhtEdgeIdx.getInfoIndexMap();
 
         // (3.5) Saving variables: edge_lon, edge_lat, face_edges
         // Creating map edgeIdxGlo2Face <idxGlo, face>
-
-        nbEdgesGlo = dhtEdgeIdxGlo.getNbIndexesGlobal();
-        edge_count = dhtEdgeIdxGlo.getIndexCount();
-        edge_start = dhtEdgeIdxGlo.getIndexStart();
+//        nbEdgesGlo = dhtEdgeIdxGlo.getNbIndexesGlobal();
+//        edge_count = dhtEdgeIdxGlo.getIndexCount();
+//        edge_start = dhtEdgeIdxGlo.getIndexStart();
+
         edge_lon.resize(edge_count);
         edge_lat.resize(edge_count);
@@ -1393 +1562 @@
             vector<size_t> hashValues2 = CMesh::createHashes(bounds_lon(nv2, nf), bounds_lat(nv2, nf));
 
-            size_t myNodeIdx1 = generateNodeIndex(hashValues1, mpiRank);
-            size_t myNodeIdx2 = generateNodeIndex(hashValues2, mpiRank);
-            it1 = nodeIdx2IdxMin.find(myNodeIdx1);
-            it2 = nodeIdx2IdxMin.find(myNodeIdx2);
-            itNodeIdxGlo1 = nodeIdxMin2IdxGlo.find((it1->second)[0]);
-            itNodeIdxGlo2 = nodeIdxMin2IdxGlo.find((it2->second)[0]);
-            size_t nodeIdxGlo1 = (itNodeIdxGlo1->second)[0];
-            size_t nodeIdxGlo2 = (itNodeIdxGlo2->second)[0];
+            size_t nodeIdx1 = generateNodeIndex(hashValues1);
+            size_t nodeIdx2 = generateNodeIndex(hashValues2);
+            it1 = nodeIdx2IdxGlo.find(nodeIdx1);
+            it2 = nodeIdx2IdxGlo.find(nodeIdx2);
+            size_t nodeIdxGlo1 = (it1->second)[1];
+            size_t nodeIdxGlo2 = (it2->second)[1];
 
             if (nodeIdxGlo1 != nodeIdxGlo2)
             {
-              size_t myIdx = generateEdgeIndex(nodeIdxGlo1, nodeIdxGlo2, mpiRank);
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxMin.find(myIdx);
-              size_t ownerIdx = (itIdx->second)[0];
-              int edgeIdxGlo;
+              size_t myIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
+              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxGlo.find(myIdx);
+              int edgeIdxGlo = (itIdx->second)[1];
               size_t faceIdxGlo = nbFacesAccum + nf;
 
-              if (myIdx == ownerIdx)
+              if (mpiRank == (itIdx->second)[0])
               {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdx2IdxGlo.find(myIdx);
-                edgeIdxGlo = (itIdxGlo->second)[0];
                 double edgeLon;
                 double diffLon = abs(bounds_lon(nv1, nf) - bounds_lon(nv2, nf));
@@ -1427 +1591 @@
                 edge_nodes(1, edgeIdxGlo - edge_start) = nodeIdxGlo2;
               }
-              else
-              {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdxMin2IdxGlo.find(ownerIdx);
-                edgeIdxGlo = (itIdxGlo->second)[0];
-              }
               face_edges(nv1,nf) = edgeIdxGlo;
               if (edgeIdxGlo2Face.count(edgeIdxGlo) == 0)
@@ -1465 +1624 @@
             vector<size_t> hashValues2 = CMesh::createHashes(bounds_lon(nv2, nf), bounds_lat(nv2, nf));
 
-            size_t myNodeIdx1 = generateNodeIndex(hashValues1, mpiRank);
-            size_t myNodeIdx2 = generateNodeIndex(hashValues2, mpiRank);
+            size_t myNodeIdx1 = generateNodeIndex(hashValues1);
+            size_t myNodeIdx2 = generateNodeIndex(hashValues2);
             if (myNodeIdx1 != myNodeIdx2)
             {
-              it1 = nodeIdx2IdxMin.find(myNodeIdx1);
-              it2 = nodeIdx2IdxMin.find(myNodeIdx2);
-              itNodeIdxGlo1 = nodeIdxMin2IdxGlo.find((it1->second)[0]);
-              itNodeIdxGlo2 = nodeIdxMin2IdxGlo.find((it2->second)[0]);
-              size_t nodeIdxGlo1 = (itNodeIdxGlo1->second)[0];
-              size_t nodeIdxGlo2 = (itNodeIdxGlo2->second)[0];
-
-              size_t myIdx = generateEdgeIndex(nodeIdxGlo1, nodeIdxGlo2, mpiRank);
-              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxMin.find(myIdx);
-              size_t ownerIdx = (itIdx->second)[0];
+              it1 = nodeIdx2IdxGlo.find(myNodeIdx1);
+              it2 = nodeIdx2IdxGlo.find(myNodeIdx2);
+              size_t nodeIdxGlo1 = (it1->second)[1];
+              size_t nodeIdxGlo2 = (it2->second)[1];
+              size_t myIdx = hashPairOrdered(nodeIdxGlo1, nodeIdxGlo2);
+              CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdx = edgeIdx2IdxGlo.find(myIdx);
+              int edgeIdxGlo = (itIdx->second)[1];
+
               size_t faceIdxGlo = nbFacesAccum + nf;
 
-              if (myIdx == ownerIdx)
+              if (mpiRank == (itIdx->second)[0])
               {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdx2IdxGlo.find(myIdx);
-                int edgeIdxGlo = (itIdxGlo->second)[0];
                 it1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
                 int face1 = it1->second[0];
@@ -1500 +1655 @@
                   face_faces(nv1, nf) = (faceIdxGlo == face1 ? face2 : face1);
                 }
-              } // myIdx == ownerIdx
+              }
               else
               {
-                CClientClientDHTSizet::Index2VectorInfoTypeMap::iterator itIdxGlo = edgeIdxMin2IdxGlo.find(ownerIdx);
-                size_t edgeIdxGlo = (itIdxGlo->second)[0];
                 it1 = edgeIdxGlo2FaceIdx.find(edgeIdxGlo);
                 int face1 = it1->second[0];
                 int face2 = it1->second[1];
                 face_faces(nv1, nf) = (faceIdxGlo == face1 ? face2 : face1);
-              } // myIdx != ownerIdx
+              }
             } // myNodeIdx1 != myNodeIdx2
             else
@@ -1515 +1668 @@
           }
         }
+
       }
       facesAreWritten = true;

XIOS/dev/dev_olga/src/node/scalar.cpp

@@ -63 +63 @@
   {
 
+  }
+
+  /*!
+    Compare two scalar objects. 
+    They are equal if only if they have identical attributes as well as their values.
+    Moreover, they must have the same transformations.
+  \param [in] scalar Compared scalar
+  \return result of the comparison
+  */
+  bool CScalar::isEqual(CScalar* obj)
+  {
+    vector<StdString> excludedAttr;
+    excludedAttr.push_back("scalar_ref");
+    bool objEqual = SuperClass::isEqual(obj, excludedAttr);
+    if (!objEqual) return objEqual;
+
+    TransMapTypes thisTrans = this->getAllTransformations();
+    TransMapTypes objTrans  = obj->getAllTransformations();
+
+    TransMapTypes::const_iterator it, itb, ite;
+    std::vector<ETranformationType> thisTransType, objTransType;
+    for (it = thisTrans.begin(); it != thisTrans.end(); ++it)
+      thisTransType.push_back(it->first);
+    for (it = objTrans.begin(); it != objTrans.end(); ++it)
+      objTransType.push_back(it->first);
+
+    if (thisTransType.size() != objTransType.size()) return false;
+    for (int idx = 0; idx < thisTransType.size(); ++idx)
+      objEqual &= (thisTransType[idx] == objTransType[idx]);
+
+    return objEqual;
   }
 

XIOS/dev/dev_olga/src/node/scalar.hpp

@@ -76 +76 @@
            void duplicateTransformation(CScalar*);
            CTransformation<CScalar>* addTransformation(ETranformationType transType, const StdString& id="");
+           bool isEqual(CScalar* scalar);
 
          private:
            std::set<StdString> relFiles;
+           TransMapTypes transformationMap_;
 
-         private:
-            TransMapTypes transformationMap_;            
             void setTransformations(const TransMapTypes&);
 

XIOS/dev/dev_olga/src/node/variable.cpp

@@ -40 +40 @@
       if (!node.getContent(this->content))
       {
+        xml::THashAttributes attributes = node.getAttributes();
+        StdString variableName = attributes["name"];
+
+        node.goToParentElement();
+        StdString parentName = node.getElementName();
+        attributes = node.getAttributes();
+        error << "The variable id = " << id << " and name = " << variableName << " does not have any content. Please define it!" << std::endl
+              << "This variable is inside another element whose attributes are :" << std::endl;
+
+        for (xml::THashAttributes::iterator it = attributes.begin(); it != attributes.end(); ++it)
+        {
+           error << it->first << "=\"" << it->second.c_str() << "\" ";
+        }
+        error << std::endl; 
+
          ERROR("CVariable::parse(xml::CXMLNode & node)",
                << "[ variable id = " << id
-               << " ] variable is not defined !");
+               << " ] variable is not defined !. It does not have any content. See error log for more details.");
       }
       content = boost::trim_copy(content) ;
@@ -108 +123 @@
       }
      }
-
-    //  if (!context->hasServer)
-    //  {
-    //    CContextClient* client=context->client ;
-
-    //    CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ;
-    //    if (client->isServerLeader())
-    //    {
-    //      CMessage msg ;
-    //      msg<<this->getId() ;
-    //      msg<<content ;
-    //      const std::list<int>& ranks = client->getRanksServerLeader();
-    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
-    //        event.push(*itRank,1,msg);
-    //      client->sendEvent(event) ;
-    //    }
-    //    else client->sendEvent(event) ;
-    // }
    }
 

XIOS/dev/dev_olga/src/node/variable.hpp

@@ -9 +9 @@
 #include "attribute_enum.hpp"
 #include "attribute_enum_impl.hpp"
+#include "declare_attribute.hpp"
 
 namespace xios