Changeset 2019 for XIOS/dev/dev_trunk_graph/src/io

Timestamp:

01/22/21 12:00:29 (3 years ago)

Author:

yushan

Message:

Graph intermedia commit to a tmp branch

Location:

XIOS/dev/dev_trunk_graph/src/io

Files:

• nc4_data_input.cpp (modified) (3 diffs)
• nc4_data_input.hpp (modified) (1 diff)
• nc4_data_output.cpp (modified) (52 diffs)
• nc4_data_output.hpp (modified) (1 diff)
• netCdfInterface.cpp (modified) (4 diffs)
• netCdfInterface_decl.cpp (modified) (3 diffs)
• onetcdf4.cpp (modified) (1 diff)
• onetcdf4_decl.cpp (modified) (1 diff)
• onetcdf4_impl.hpp (modified) (2 diffs)

XIOS/dev/dev_trunk_graph/src/io/nc4_data_input.cpp

@@ -43 +43 @@
   CATCH
 
-  void CNc4DataInput::readFieldData_(CField* field)
+  void CNc4DataInput::readFieldData_(CField* field, int record, CArray<double,1>& dataOut)
   TRY
   {
     CContext* context = CContext::getCurrent();
-    CContextServer* server = context->server;
-
-    CGrid* grid = field->grid;
-
-    if (!grid->doGridHaveDataToWrite())
-      if (SuperClass::type==MULTI_FILE || !isCollective) return;
+
+    CGrid* grid = field->getGrid();
+
+    if (!grid->doGridHaveDataToWrite())  if (SuperClass::type==MULTI_FILE || !isCollective) return;
 
     StdString fieldId = field->getFieldOutputName();
 
-    CArray<double,1> fieldData(grid->getWrittenDataSize());
-    if (!field->default_value.isEmpty()) fieldData = field->default_value;
-
     switch (SuperClass::type)
     {
       case MULTI_FILE:
-        SuperClassWriter::getData(fieldData, fieldId, isCollective, (field->getNStep() - 1)%field->nstepMax );
+        SuperClassWriter::getData(dataOut, fieldId, isCollective, record );
         break;
       case ONE_FILE:
@@ -109 +104 @@
         }
 
-        SuperClassWriter::getData(fieldData, fieldId, isCollective, (field->getNStep() - 1)%field->nstepMax, &start, &count);
+        SuperClassWriter::getData(dataOut, fieldId, isCollective, record, &start, &count);
         break;
       }
     }
-
-    field->inputField(fieldData);
-
-    if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
-    {
-      double scaleFactor = 1.0, addOffset = 0.0;
-      if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
-      if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
-      field->invertScaleFactorAddOffset(scaleFactor, addOffset);
-    }
   }
   CATCH
@@ -131 +116 @@
     StdString fieldId = field->getFieldOutputName();
 
-    CGrid* grid = field->grid;
+    CGrid* grid = field->getGrid();
 
     std::vector<CDomain*> domainP = grid->getDomains();

XIOS/dev/dev_trunk_graph/src/io/nc4_data_input.hpp

@@ -37 +37 @@
     // Read methods
     virtual StdSize getFieldNbRecords_(CField* field);
-    virtual void readFieldData_(CField* field);
+    virtual void readFieldData_(CField* field, int record, CArray<double,1>& data);
     virtual void readFieldAttributes_(CField* field, bool readAttributeValues);
     virtual void closeFile_(void);

XIOS/dev/dev_trunk_graph/src/io/nc4_data_output.cpp

@@ -57 +57 @@
       {
         StdString lonName,latName ;
-         
-        domain->computeWrittenIndex();
-        domain->computeWrittenCompressedIndex(comm_file);
 
         if (domain->type == CDomain::type_attr::unstructured)
@@ -71 +68 @@
 
          CContext* context = CContext::getCurrent() ;
-         CContextServer* server=context->server ;
 
          if (domain->IsWritten(this->filename)) return;
@@ -146 +142 @@
          string lonid,latid,bounds_lonid,bounds_latid ;
          string areaId = "area" + appendDomid;
-/*
-         StdString lonid_loc = (server->intraCommSize > 1)
-                             ? StdString("lon").append(appendDomid).append("_local")
-                             : lonid;
-         StdString latid_loc = (server->intraCommSize > 1)
-                             ? StdString("lat").append(appendDomid).append("_local")
-                             : latid;
-*/
-
-         CArray<int, 1>& indexToWrite = domain->localIndexToWriteOnServer;
-         int nbWritten = indexToWrite.numElements();
-         CArray<double,1> writtenLat, writtenLon;
-         CArray<double,2> writtenBndsLat, writtenBndsLon;
-         CArray<double,1> writtenArea;
-
-         if (domain->hasLonLat)
-         {
-           writtenLat.resize(nbWritten);
-           writtenLon.resize(nbWritten);
-           for (int idx = 0; idx < nbWritten; ++idx)
-           {
-             if (indexToWrite(idx) < 0)
-             {
-               writtenLat(idx) = -1.;   // hole
-               writtenLon(idx) = -1.;
-             }
-             else
-             {
-               writtenLat(idx) = domain->latvalue(indexToWrite(idx));
-               writtenLon(idx) = domain->lonvalue(indexToWrite(idx));
-             }
-           }
-
-           if (domain->hasBounds)
-           {         
-             int nvertex = domain->nvertex, idx;
-             writtenBndsLat.resize(nvertex, nbWritten);
-             writtenBndsLon.resize(nvertex, nbWritten);
-             CArray<double,2>& boundslat = domain->bounds_latvalue;
-             CArray<double,2>& boundslon = domain->bounds_lonvalue;   
-             for (idx = 0; idx < nbWritten; ++idx)
-               for (int nv = 0; nv < nvertex; ++nv)
-               {
-                 if (indexToWrite(idx) < 0)
-                 {
-                   writtenBndsLat(nv, idx) = -1.;  // hole
-                   writtenBndsLon(nv, idx) = -1.;
-                 }
-                 else
-                 {
-                   writtenBndsLat(nv, idx) = boundslat(nv, int(indexToWrite(idx)));
-                   writtenBndsLon(nv, idx) = boundslon(nv, int(indexToWrite(idx)));
-                 }
-               }
-           }
-         }
-
-         if (domain->hasArea)
-         {
-           writtenArea.resize(nbWritten);           
-           for (int idx = 0; idx < nbWritten; ++idx)
-           {
-                  if (indexToWrite(idx) < 0)
-              writtenArea(idx) = -1.;
-                  else
-              writtenArea(idx) = domain->areavalue(indexToWrite(idx));
-           }
-         }
 
          try
@@ -246 +174 @@
                    SuperClassWriter::addDimension(dimVertId, domain->nvertex);
 
-                 if (server->intraCommSize > 1)
+                 if (context->intraCommSize_ > 1)
                  {
                    this->writeLocalAttributes(domain->ibegin,
@@ -261 +189 @@
                                                       domain->nj,
                                                       domain->ni_glo,domain->nj_glo,
-                                                      server->intraCommRank,server->intraCommSize);
+                                                      context->intraCommRank_,context->intraCommSize_);
                  }
 
@@ -299 +227 @@
                  dim0.push_back(dimXid);
 
-
-  // supress mask               if (server->intraCommSize > 1)
-  // supress mask               {
-  // supress mask                  SuperClassWriter::addVariable(maskid, NC_INT, dim0);
-  // supress mask
-  // supress mask                  this->writeMaskAttributes(maskid,
-  // supress mask                     domain->data_dim.getValue()/*,
-  // supress mask                     domain->data_ni.getValue(),
-  // supress mask                     domain->data_nj.getValue(),
-  // supress mask                     domain->data_ibegin.getValue(),
-  // supress mask                     domain->data_jbegin.getValue()*/);
-  // supress mask               }
-
-                 //SuperClassWriter::setDefaultValue(maskid, &dvm);
-
                  if (domain->hasArea)
                  {
@@ -328 +241 @@
                    {
                      case CDomain::type_attr::curvilinear :                       
-                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0);
-                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0);
+                       SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0);
+                       SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0);
                        break;
                      case CDomain::type_attr::rectilinear :
-                       CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->ni)) ;
+                       CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->ni)) ;
                        SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
-                       CArray<double,1> lon = writtenLon(Range(0,domain->ni-1)) ;
+                       CArray<double,1> lon = domain->lonvalue(Range(0,domain->ni-1)) ;
                        SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0);
                        break;
@@ -341 +254 @@
                    if (domain->hasBounds)
                    {
-                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0);
-                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0);
+                     SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0);
+                     SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0);
                    }
                  }
@@ -348 +261 @@
                  if (domain->hasArea)
                  {
-                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0);                   
+                   SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0);                   
                  }
 
@@ -426 +339 @@
                      std::vector<StdSize> start(2) ;
                      std::vector<StdSize> count(2) ;
-// Comment out: it is not working for a hole
-//                     if (domain->isEmpty())
-//                     {
-//                       start[0]=0 ; start[1]=0 ;
-//                       count[0]=0 ; count[1]=0 ;
-//                     }
-//                     else
-                     {
-                       start[1]=domain->ibegin;
-                       start[0]=domain->jbegin;
-                       count[1]=domain->ni ; count[0]=domain->nj ;
-                     }
+                     start[1]=domain->ibegin;
+                     start[0]=domain->jbegin;
+                     count[1]=domain->ni ; count[0]=domain->nj ;
 
                      if (domain->hasLonLat)
                      {
-                       SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count);
-                       SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count);
+                       SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count);
+                       SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count);
                      }
                      break;
@@ -452 +356 @@
                        std::vector<StdSize> start(1) ;
                        std::vector<StdSize> count(1) ;
-                       if (domain->isEmpty())
-                       {
-                         start[0]=0 ;
-                         count[0]=0 ;
-                         SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count);
-                         SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count);
-                       }
-                       else
-                       { 
-                         start[0]=domain->jbegin;
-                         count[0]=domain->nj;
-                         CArray<double,1> lat = writtenLat(Range(fromStart,toEnd,domain->ni));
-                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
-
-                         start[0]=domain->ibegin;
-                         count[0]=domain->ni;
-                         CArray<double,1> lon = writtenLon(Range(0,domain->ni-1));
-                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
-                       }
+                       
+                       start[0]=domain->jbegin;
+                       count[0]=domain->nj;
+                       CArray<double,1> lat = domain->latvalue(Range(fromStart,toEnd,domain->ni));
+                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
+
+                       start[0]=domain->ibegin;
+                       count[0]=domain->ni;
+                       CArray<double,1> lon = domain->lonvalue(Range(0,domain->ni-1));
+                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
                      }
                      break;
@@ -495 +390 @@
                    }
                  
-                   SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0, &start, &count);
-                   SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0, &start, &count);
+                   SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0, &start, &count); // will probably not working for rectilinear
+                   SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0, &start, &count);
                  }
 
@@ -504 +399 @@
                    std::vector<StdSize> count(2);
 
-                   if (domain->isEmpty())
-                   {
-                     start[0] = 0; start[1] = 0;
-                     count[0] = 0; count[1] = 0;
-                   }
-                   else
-                   {
-                     start[1] = domain->ibegin;
-                     start[0] = domain->jbegin;
-                     count[1] = domain->ni;
-                     count[0] = domain->nj;
-                   }
+                   start[1] = domain->ibegin;
+                   start[0] = domain->jbegin;
+                   count[1] = domain->ni;
+                   count[0] = domain->nj;
                    
-                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0, &start, &count);
+                   SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0, &start, &count);
                  }
 
@@ -548 +435 @@
     {
       CContext* context = CContext::getCurrent() ;
-      CContextServer* server=context->server ;
 
       if (domain->IsWritten(this->filename)) return;
@@ -571 +457 @@
       StdString domainName = domain->name;
       domain->assignMesh(domainName, domain->nvertex);
-      domain->mesh->createMeshEpsilon(server->intraComm, domain->lonvalue, domain->latvalue, domain->bounds_lonvalue, domain->bounds_latvalue);
+      domain->mesh->createMeshEpsilon(context->intraComm_, domain->lonvalue, domain->latvalue, domain->bounds_lonvalue, domain->bounds_latvalue);
 
       StdString node_x = domainName + "_node_x";
@@ -908 +794 @@
       {
          CContext* context = CContext::getCurrent() ;
-         CContextServer* server=context->server ;
 
          if (domain->IsWritten(this->filename)) return;
@@ -944 +829 @@
 
          int nvertex = (domain->nvertex.isEmpty()) ? 0 : domain->nvertex;
-
-         CArray<int, 1>& indexToWrite = domain->localIndexToWriteOnServer;
-         int nbWritten = indexToWrite.numElements();
-         CArray<double,1> writtenLat, writtenLon;
-         CArray<double,2> writtenBndsLat, writtenBndsLon;
-         CArray<double,1> writtenArea;
-
-         if (domain->hasLonLat)
-         {
-           writtenLat.resize(nbWritten);
-           writtenLon.resize(nbWritten);
-           for (int idx = 0; idx < nbWritten; ++idx)
-           {
-             if (indexToWrite(idx) < 0)
-             {
-               writtenLat(idx) = -1.;
-               writtenLon(idx) = -1.;
-             }
-             else
-             {
-               writtenLat(idx) = domain->latvalue(indexToWrite(idx));
-               writtenLon(idx) = domain->lonvalue(indexToWrite(idx));
-             }
-           }
-         }
-         
-         if (domain->hasBounds)
-         {
-           int nvertex = domain->nvertex, idx;
-           writtenBndsLat.resize(nvertex, nbWritten);
-           writtenBndsLon.resize(nvertex, nbWritten);
-           CArray<double,2>& boundslat = domain->bounds_latvalue;
-           CArray<double,2>& boundslon = domain->bounds_lonvalue;
-           for (idx = 0; idx < nbWritten; ++idx)
-           {
-             for (int nv = 0; nv < nvertex; ++nv)
-             {
-               if (indexToWrite(idx) < 0)
-               {
-                 writtenBndsLat(nv, idx) = -1.;
-                 writtenBndsLon(nv, idx) = -1.;
-               }
-               else
-               {
-                 writtenBndsLat(nv, idx) = boundslat(nv, int(indexToWrite(idx)));
-                 writtenBndsLon(nv, idx) = boundslon(nv, int(indexToWrite(idx)));
-                }
-             }
-           }
-         }
-
-         if (domain->hasArea)
-         {
-           writtenArea.resize(nbWritten);           
-           for (int idx = 0; idx < nbWritten; ++idx)
-           {
-             if (indexToWrite(idx) < 0)
-               writtenArea(idx) = -1.;
-             else
-               writtenArea(idx) = domain->areavalue(indexToWrite(idx));
-           }
-         }
 
          try
@@ -1055 +878 @@
                  if (domain->hasLonLat)
                  {
-                   SuperClassWriter::writeData(writtenLat, latid, isCollective, 0);
-                   SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0);
+                   SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0);
+                   SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0);
                    if (domain->hasBounds)
                    {
-                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0);
-                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0);
+                     SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0);
+                     SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0);
                    }
                  }
 
                  if (domain->hasArea)
-                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0);
+                   SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0);
 
                  SuperClassWriter::definition_start();
@@ -1137 +960 @@
                  if (domain->hasLonLat)
                  {
-                   SuperClassWriter::writeData(writtenLat, latid, isCollective, 0,&start,&count);
-                   SuperClassWriter::writeData(writtenLon, lonid, isCollective, 0,&start,&count);
+                   SuperClassWriter::writeData(domain->latvalue, latid, isCollective, 0,&start,&count);
+                   SuperClassWriter::writeData(domain->lonvalue, lonid, isCollective, 0,&start,&count);
                    if (domain->hasBounds)
                    {
-                     SuperClassWriter::writeData(writtenBndsLon, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
-                     SuperClassWriter::writeData(writtenBndsLat, bounds_latid, isCollective, 0,&startBounds,&countBounds);
+                     SuperClassWriter::writeData(domain->bounds_lonvalue, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
+                     SuperClassWriter::writeData(domain->bounds_latvalue, bounds_latid, isCollective, 0,&startBounds,&countBounds);
                    }
                  }
 
                  if (domain->hasArea)
-                   SuperClassWriter::writeData(writtenArea, areaId, isCollective, 0, &start, &count);
+                   SuperClassWriter::writeData(domain->areavalue, areaId, isCollective, 0, &start, &count);
 
                  SuperClassWriter::definition_start();
@@ -1177 +1000 @@
         axis->checkAttributes();
 
-        axis->computeWrittenIndex();
-        axis->computeWrittenCompressedIndex(comm_file);
-       
         int size  = (MULTI_FILE == SuperClass::type) ? axis->n.getValue()
                                                           : axis->n_glo.getValue();
@@ -1279 +1099 @@
 
           SuperClassWriter::definition_end();
-
-          CArray<int, 1>& indexToWrite = axis->localIndexToWriteOnServer;
-          int nbWritten = indexToWrite.numElements();
-          CArray<double,1> axis_value(indexToWrite.numElements());
-          if (!axis->value.isEmpty())
-          {
-            for (int i = 0; i < nbWritten; i++)
-            {
-              if (indexToWrite(i) < 0)
-                axis_value(i) = -1;   // Some value in case of a hole
-              else
-                axis_value(i) = axis->value(indexToWrite(i));
-            }
-          }
-          CArray<double,2> axis_bounds;
-          CArray<string,1> axis_label;
-          if (!axis->label.isEmpty())
-          {
-            axis_label.resize(indexToWrite.numElements());
-            for (int i = 0; i < nbWritten; i++)
-            {
-              if (indexToWrite(i) < 0)
-                axis_label(i) = boost::lexical_cast<string>(-1);  // Some value in case of a hole
-              else
-                axis_label(i) = axis->label(indexToWrite(i));
-            }
-          }
-
+          
           switch (SuperClass::type)
           {
@@ -1314 +1107 @@
               {
                 if (!axis->value.isEmpty())
-                  SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
+                  SuperClassWriter::writeData(axis->value, axisid, isCollective, 0);
 
                 if (!axis->bounds.isEmpty())
-                {
-                  axis_bounds.resize(2, indexToWrite.numElements());
-                  for (int i = 0; i < nbWritten; ++i)
-                  {
-                    if (indexToWrite(i) < 0)
-                    {
-                      axis_bounds(0, i) = -1.; // Some value in case of a hole
-                      axis_bounds(1, i) = -1.;
-                    }
-                    else
-                    {
-                      axis_bounds(0, i) = axis->bounds(0, int(indexToWrite(i)));
-                      axis_bounds(1, i) = axis->bounds(1, int(indexToWrite(i)));
-                    }
-                  }
-                  SuperClassWriter::writeData(axis_bounds, axisBoundsId, isCollective, 0);
-                }
+                  SuperClassWriter::writeData(axis->bounds, axisBoundsId, isCollective, 0);
               }
               else
-                SuperClassWriter::writeData(axis_label, axisid, isCollective, 0);
+                SuperClassWriter::writeData(axis->label, axisid, isCollective, 0);
 
               SuperClassWriter::definition_start();
@@ -1353 +1130 @@
               {
                 if (!axis->value.isEmpty())
-                  SuperClassWriter::writeData(axis_value, axisid, isCollective, 0, &start, &count);
+                  SuperClassWriter::writeData(axis->value, axisid, isCollective, 0, &start, &count);
 
                 if (!axis->bounds.isEmpty())
-                {
-                  axis_bounds.resize(2, indexToWrite.numElements());
-                  for (int i = 0; i < nbWritten; ++i)
-                  {
-                    if (indexToWrite(i) < 0)
-                    {
-                      axis_bounds(0, i) = -1.;
-                      axis_bounds(1, i) = -1.;
-                    }
-                    else
-                    {
-                      axis_bounds(0, i) = axis->bounds(0, int(indexToWrite(i)));
-                      axis_bounds(1, i) = axis->bounds(1, int(indexToWrite(i)));
-                    }
-                  }
-                  SuperClassWriter::writeData(axis_bounds, axisBoundsId, isCollective, 0, &startBounds, &countBounds);
-                }
+                  SuperClassWriter::writeData(axis->bounds, axisBoundsId, isCollective, 0, &startBounds, &countBounds);
               }
               else
@@ -1379 +1140 @@
                 startLabel[0] = start[0]; startLabel[1] = 0;
                 countLabel[0] = count[0]; countLabel[1] = stringArrayLen;
-                SuperClassWriter::writeData(axis_label, axisid, isCollective, 0, &startLabel, &countLabel);
+                SuperClassWriter::writeData(axis->label, axisid, isCollective, 0, &startLabel, &countLabel);
               }
 
@@ -1574 +1335 @@
      void CNc4DataOutput::writeGridCompressed_(CGrid* grid)
      {
-       if (grid->isScalarGrid() || grid->isWrittenCompressed(this->filename)) return;
-
-       try
-       {
-         CArray<int,1> axisDomainOrder = grid->axis_domain_order;
-         std::vector<StdString> domainList = grid->getDomainList();
-         std::vector<StdString> axisList   = grid->getAxisList();
-         std::vector<StdString> scalarList = grid->getScalarList();
-         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0, idxScalar = 0;
-
-         std::vector<StdString> dims;
-
-         if (grid->isCompressible())
-         {
-           StdString varId = grid->getId() + "_points";
-
-           int nbIndexes = (SuperClass::type == MULTI_FILE) ? grid->getNumberWrittenIndexes() : grid->getTotalNumberWrittenIndexes();
-           SuperClassWriter::addDimension(varId, nbIndexes);
-
-           dims.push_back(varId);
-           SuperClassWriter::addVariable(varId, NC_INT, dims);
-
-           StdOStringStream compress;
-           for (int i = numElement - 1; i >= 0; --i)
-           {
-             if (2 == axisDomainOrder(i))
-             {
-               CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]);
-               StdString domId = domain->getDomainOutputName();
-               StdString appendDomId  = singleDomain ? "" : "_" + domId;
-
-               switch (domain->type)
-               {
-                 case CDomain::type_attr::curvilinear:
-                   compress << "y" << appendDomId << " x" << appendDomId;
-                   break;
-                 case CDomain::type_attr::rectilinear:
-                   compress << "lat" << appendDomId << " lon" << appendDomId;
-                   break;
-                 case CDomain::type_attr::unstructured:
-                   StdString cellName = (!domain->dim_i_name.isEmpty()) ? cellName=domain->dim_i_name : "cell";
-                   compress << cellName << appendDomId;
-//                   compress << "cell" << appendDomId;
-                   break;
-               }
-               ++idxDomain;
-             }
-             else if (1 == axisDomainOrder(i))
-             {
-               CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]);
-               compress << axis->getAxisOutputName();
-               ++idxAxis;
-             }
-             else
-             {
-               CScalar* scalar = CScalar::get(scalarList[scalarList.size() - idxScalar - 1]);
-               compress << scalar->getScalarOutputName();
-               ++idxScalar;
-             }
-
-             if (i != 0) compress << ' ';
-           }
-           SuperClassWriter::addAttribute("compress", compress.str(), &varId);         
-
-           CArray<int, 1> indexes(grid->getNumberWrittenIndexes());
-           indexes = grid->localIndexToWriteOnServer;
-
-           switch (SuperClass::type)
-           {
-             case (MULTI_FILE):
-             {
-               SuperClassWriter::writeData(indexes, varId, isCollective, 0);
-               break;
-             }
-             case (ONE_FILE):
-             {
-               if (grid->doGridHaveDataDistributed())
-                 grid->getDistributionServer()->computeGlobalIndex(indexes);
-
-               std::vector<StdSize> start, count;
-               start.push_back(grid->getOffsetWrittenIndexes());
-               count.push_back(grid->getNumberWrittenIndexes());
-
-               SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
-               break;
-             }
-           }
-         }
-         else
-         {
-           for (int i = 0; i < numElement; ++i)
-           {
-             StdString varId, compress;
-             CArray<int, 1> indexes;
-             bool isDistributed;
-             StdSize nbIndexes, totalNbIndexes, offset;
-             int firstGlobalIndex;
-
-             if (2 == axisDomainOrder(i))
-             {
-               CDomain* domain = CDomain::get(domainList[idxDomain]);
-               StdString domId = domain->getDomainOutputName();
-
-               if (!domain->isCompressible()
-                    || domain->type == CDomain::type_attr::unstructured
-                    || domain->isWrittenCompressed(this->filename)
-                    || isWrittenCompressedDomain(domId))
-                 continue;
-
-               StdString appendDomId  = singleDomain ? "" : "_" + domId;
-
-               varId = domId + "_points";
-               switch (domain->type)
-               {
-                 case CDomain::type_attr::curvilinear:
-                   compress = "y" + appendDomId + " x" + appendDomId;
-                   break;
-                 case CDomain::type_attr::rectilinear:
-                   compress = "lat" + appendDomId + " lon" + appendDomId;
-                   break;
-               }
-
-               // indexes.resize(domain->compressedIndexToWriteOnServer[comm_file].numElements());
-               // indexes = domain->compressedIndexToWriteOnServer[com_file];
-               indexes.resize(domain->getCompressedIndexToWriteOnServer(comm_file).numElements());
-               indexes = domain->getCompressedIndexToWriteOnServer(comm_file);
-
-               isDistributed = domain->isDistributed();
-               nbIndexes = domain->getNumberWrittenIndexes(comm_file);
-               totalNbIndexes = domain->getTotalNumberWrittenIndexes(comm_file);
-               offset = domain->getOffsetWrittenIndexes(comm_file);
-               firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
-
-               domain->addRelFileCompressed(this->filename);
-               setWrittenCompressedDomain(domId);
-               ++idxDomain;
-             }
-             else if (1 == axisDomainOrder(i))
-             {
-               CAxis* axis = CAxis::get(axisList[idxAxis]);
-               StdString axisId = axis->getAxisOutputName();
-
-               if (!axis->isCompressible()
-                    || axis->isWrittenCompressed(this->filename)
-                    || isWrittenCompressedAxis(axisId))
-                 continue;
-
-               varId = axisId + "_points";
-               compress = axisId;
-
-               // indexes.resize(axis->compressedIndexToWriteOnServer.numElements());
-               // indexes = axis->compressedIndexToWriteOnServer;
-
-               indexes.resize(axis->getCompressedIndexToWriteOnServer(comm_file).numElements());
-               indexes = axis->getCompressedIndexToWriteOnServer(comm_file);
-
-               isDistributed = axis->isDistributed();
-               nbIndexes = axis->getNumberWrittenIndexes(comm_file);
-               totalNbIndexes = axis->getTotalNumberWrittenIndexes(comm_file);
-               offset = axis->getOffsetWrittenIndexes(comm_file);
-               firstGlobalIndex = axis->begin;
-
-               axis->addRelFileCompressed(this->filename);
-               setWrittenCompressedAxis(axisId);
-               ++idxAxis;
-             }
-             else
-             {
-             }
-
-             if (!varId.empty())
-             {
-               SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
-
-               dims.clear();
-               dims.push_back(varId);
-               SuperClassWriter::addVariable(varId, NC_INT, dims);
-
-               SuperClassWriter::addAttribute("compress", compress, &varId);
-
-               switch (SuperClass::type)
-               {
-                 case (MULTI_FILE):
-                 {
-                   indexes -= firstGlobalIndex;
-                   SuperClassWriter::writeData(indexes, varId, isCollective, 0);
-                   break;
-                 }
-                 case (ONE_FILE):
-                 {
-                   std::vector<StdSize> start, count;
-                   start.push_back(offset);
-                   count.push_back(nbIndexes);
-
-                   SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
-                   break;
-                 }
-               }
-             }
+        if (grid->isScalarGrid() || grid->isWrittenCompressed(this->filename)) return;
+        
+        // NOTA : The cuurent algorithm to write compress elements of the grid
+        //        will work pretting well when on server side you dont't get
+        //        partial overlap on elements between differents participating process
+        //        So the element must be totally distributed or non distributed
+        //        If an element is partially overlaping betwwen process then the
+        //        total compressed part will apear artificially greater than expected
+        //        For the current implementation of writer which is decomposed only on
+        //        one element, it will work as expected, but for future, it must be 
+        //        reconsidered again. 
+        try
+        {
+          CArray<int,1> axisDomainOrder = grid->axis_domain_order;
+          std::vector<StdString> domainList = grid->getDomainList();
+          std::vector<StdString> axisList   = grid->getAxisList();
+          std::vector<StdString> scalarList = grid->getScalarList();
+          int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0, idxScalar = 0;
+          int commRank ;
+          MPI_Comm_rank(comm_file,&commRank) ;
+
+          std::vector<StdString> dims;
+
+          for (int i = 0; i < numElement; ++i)
+          {
+            StdString varId, compress;
+            CArray<size_t, 1> indexes;
+            bool isDistributed;
+            size_t nbIndexes, totalNbIndexes, offset;
+            size_t firstGlobalIndex;
+            
+            if (2 == axisDomainOrder(i))
+            {
+              CDomain* domain = CDomain::get(domainList[idxDomain]);
+              StdString domId = domain->getDomainOutputName();
+
+              if (!domain->isCompressible()
+                  || domain->type == CDomain::type_attr::unstructured
+                  || domain->isWrittenCompressed(this->filename)
+                  || isWrittenCompressedDomain(domId))
+                continue;
+            
+              // unstructured grid seems not be taken into account why ?
+
+              string lonName,latName ;
+
+              if (domain->lon_name.isEmpty())
+              { 
+                if (domain->type==CDomain::type_attr::curvilinear) lonName = "nav_lon";
+                else lonName = "lon";
+              }
+              else lonName = domain->lon_name;
+
+              if (domain->lat_name.isEmpty())
+              {
+                if (domain->type==CDomain::type_attr::curvilinear) latName = "nav_lat";
+                else latName = "lat";
+              }
+              else latName = domain->lat_name;
+             
+              StdString appendDomId  = singleDomain ? "" : "_" + domId;
+
+              varId = domId + "_points";
+              compress = latName + appendDomId + " " + lonName + appendDomId;
+     
+              CLocalView* workflowView = domain->getLocalView(CElementView::WORKFLOW) ;
+              workflowView->getGlobalIndexView(indexes) ;
+              nbIndexes = workflowView->getSize() ;
+              isDistributed = domain->isDistributed();
+              if (isDistributed)
+              {
+                MPI_Exscan(&nbIndexes, &offset, 1, MPI_SIZE_T, MPI_SUM, comm_file) ;
+                if (commRank==0) offset=0 ;
+                MPI_Allreduce(&nbIndexes,&totalNbIndexes,1 , MPI_SIZE_T, MPI_SUM, comm_file) ;
+              }
+              else
+              {
+                offset=0 ;
+                totalNbIndexes = nbIndexes ;
+              }
+
+              firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
+
+              domain->addRelFileCompressed(this->filename);
+              setWrittenCompressedDomain(domId);
+              ++idxDomain;
             }
-         }
-
-         grid->addRelFileCompressed(this->filename);
-       }
-       catch (CNetCdfException& e)
-       {
-         StdString msg("On writing compressed grid : ");
-         msg.append(grid->getId()); msg.append("\n");
-         msg.append("In the context : ");
-         CContext* context = CContext::getCurrent();
-         msg.append(context->getId()); msg.append("\n");
-         msg.append(e.what());
-         ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
-       }
-     }
+            else if (1 == axisDomainOrder(i))
+            {
+              CAxis* axis = CAxis::get(axisList[idxAxis]);
+              StdString axisId = axis->getAxisOutputName();
+
+              if (!axis->isCompressible()
+                  || axis->isWrittenCompressed(this->filename)
+                  || isWrittenCompressedAxis(axisId))
+                continue;
+
+              varId = axisId + "_points";
+              compress = axisId;
+
+              CLocalView* workflowView = axis->getLocalView(CElementView::WORKFLOW) ;
+              workflowView->getGlobalIndexView(indexes) ;
+              nbIndexes = workflowView->getSize() ;
+              isDistributed = axis->isDistributed();
+              if (isDistributed)
+              {
+                MPI_Exscan(&nbIndexes, &offset, 1, MPI_SIZE_T, MPI_SUM, comm_file) ;
+                if (commRank==0) offset=0 ;
+                MPI_Allreduce(&nbIndexes,&totalNbIndexes,1 , MPI_SIZE_T, MPI_SUM, comm_file) ;
+              }
+              else
+              {
+                offset=0 ;
+                totalNbIndexes = nbIndexes ;
+              }
+              firstGlobalIndex = axis->begin;
+              
+              axis->addRelFileCompressed(this->filename);
+              setWrittenCompressedAxis(axisId);
+              ++idxAxis;
+            }
+            else
+            {
+              //for scalar 
+            }
+
+            if (!varId.empty())
+            {
+              SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
+
+              dims.clear();
+              dims.push_back(varId);
+              SuperClassWriter::addVariable(varId, NC_UINT64, dims);
+
+              SuperClassWriter::addAttribute("compress", compress, &varId);
+
+              switch (SuperClass::type)
+              {
+                case (MULTI_FILE):
+                {
+                  indexes -= firstGlobalIndex;
+                  SuperClassWriter::writeData(indexes, varId, isCollective, 0);
+                  break;
+                }
+                case (ONE_FILE):
+                {
+                  std::vector<StdSize> start, count;
+                  start.push_back(offset);
+                  count.push_back(nbIndexes);
+
+                  SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
+                  break;
+                }
+              }
+            }
+          }
+
+          grid->addRelFileCompressed(this->filename);
+        }
+        catch (CNetCdfException& e)
+        {
+          StdString msg("On writing compressed grid : ");
+          msg.append(grid->getId()); msg.append("\n");
+          msg.append("In the context : ");
+          CContext* context = CContext::getCurrent();
+          msg.append(context->getId()); msg.append("\n");
+          msg.append(e.what());
+          ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
+        }
+      }
 
      //--------------------------------------------------------------
@@ -1814 +1530 @@
       {
         CContext* context = CContext::getCurrent() ;
-        CContextServer* server=context->server ;
 
         std::vector<StdString> dims, coodinates;
-        CGrid* grid = field->grid;
+        CGrid* grid = field->getGrid();
         if (!grid->doGridHaveDataToWrite())
           if (SuperClass::type==MULTI_FILE) return ;
@@ -1998 +1713 @@
         }
 
-        if (compressedOutput && grid->isCompressible())
+        while (!dimIdList.empty())
         {
-          dims.push_back(grid->getId() + "_points");
-          field->setUseCompressedOutput();
-        }
-        else
-        {
-          while (!dimIdList.empty())
-          {
-            dims.push_back(dimIdList.back());
-            dimIdList.pop_back();
-          }
+          dims.push_back(dimIdList.back());
+          dimIdList.pop_back();
         }
 
@@ -2156 +1863 @@
 
             if (field->compression_level.isEmpty())
-              field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
+              field->compression_level = field->getRelFile()->compression_level.isEmpty() ? 0 : field->getRelFile()->compression_level;
             SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
 
@@ -2355 +2062 @@
       //---------------------------------------------------------------
 
-      void CNc4DataOutput::writeFieldData_ (CField*  field)
+      int CNc4DataOutput::writeFieldData_ (CField*  field, const CArray<double,1>& data, const CDate& lastWrite,
+                                           const CDate& currentWrite, int nstep)
       {
         CContext* context = CContext::getCurrent();
-        CContextServer* server = context->server;
-        CGrid* grid = field->grid;
-
-        if (field->getNStep()<1) 
+        CGrid* grid = field->getGrid();
+       
+        if (nstep<1) 
         {
-          return;
+          return nstep;
         }
         
@@ -2369 +2076 @@
           if (SuperClass::type == MULTI_FILE || !isCollective)
           {
-            return;
+            return nstep;
           }
 
@@ -2387 +2094 @@
         if (!field->wasWritten())
         {
-          if (appendMode && field->file->record_offset.isEmpty() && 
+          if (appendMode && field->getRelFile()->record_offset.isEmpty() && 
               field->getOperationTimeType() != func::CFunctor::once)
           {
             double factorUnit;
-            if (!field->file->time_units.isEmpty() && field->file->time_units==CFile::time_units_attr::days)
+            if (!field->getRelFile()->time_units.isEmpty() && field->getRelFile()->time_units==CFile::time_units_attr::days)
             factorUnit=context->getCalendar()->getDayLengthInSeconds() ;
             else factorUnit=1 ;
-            field->resetNStep(getRecordFromTime(field->last_Write_srv,factorUnit) + 1);
+            nstep = getRecordFromTime(currentWrite,factorUnit) + 1;
           }
 
@@ -2413 +2120 @@
         if (wtime)
         {
-          Time lastWrite = field->last_Write_srv;
-          Time lastLastWrite = field->lastlast_Write_srv;
-
           
           if (field->hasTimeInstant)
           {
-            time_data(0) = time_data_bound(1) = lastWrite;
-            time_data_bound(0) = time_data_bound(1) = lastWrite;
+            time_data(0) = time_data_bound(1) = (Time) lastWrite;
+            time_data_bound(0) = time_data_bound(1) = (Time) currentWrite;
             if (timeCounterType==instant)
             {
@@ -2432 +2136 @@
           else if (field->hasTimeCentered)
           {
-            time_data(0) = (lastWrite + lastLastWrite) / 2;
-            time_data_bound(0) = lastLastWrite;
-            time_data_bound(1) = lastWrite;
+            time_data(0) = ((Time)currentWrite + (Time)lastWrite) / 2;
+            time_data_bound(0) = (Time)lastWrite;
+            time_data_bound(1) = (Time)currentWrite;
             if (timeCounterType==centered)
             {
@@ -2447 +2151 @@
           if (timeCounterType==record)
           {
-            time_counter(0) = field->getNStep() - 1;
-            time_counter_bound(0) = time_counter_bound(1) = field->getNStep() - 1;
+            time_counter(0) = nstep - 1;
+            time_counter_bound(0) = time_counter_bound(1) = nstep - 1;
             wtimeCounter=true ;
           }
 
-          if (!field->file->time_units.isEmpty() && field->file->time_units==CFile::time_units_attr::days)
+          if (!field->getRelFile()->time_units.isEmpty() && field->getRelFile()->time_units==CFile::time_units_attr::days)
           {
             double secByDay=context->getCalendar()->getDayLengthInSeconds() ;
@@ -2462 +2166 @@
         }
 
-         bool isRoot = (server->intraCommRank == 0);
-
-         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
-         {
-           double scaleFactor = 1.0;
-           double addOffset = 0.0;
-           if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
-           if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
-           field->scaleFactorAddOffset(scaleFactor, addOffset);
-         }
+         bool isRoot = (context->intraCommRank_ == 0);
 
          try
          {
-           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
-             field->outputField(fieldData);
-
-           if (!field->prec.isEmpty() && field->prec == 2) fieldData = round(fieldData);
-
            switch (SuperClass::type)
            {
@@ -2496 +2175 @@
               {
                  CTimer::get("Files : writing data").resume();
-                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1);
+                 SuperClassWriter::writeData(data, fieldid, isCollective, nstep - 1);
                  CTimer::get("Files : writing data").suspend();
                  if (wtime)
@@ -2503 +2182 @@
                    if ( wtimeData)
                    {
-                       SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot);
-                       SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot);
+                       SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, nstep - 1, isRoot);
+                       SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, nstep - 1, isRoot);
                   }
                    if (wtimeCounter)
                    {
-                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1,isRoot);
-                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot);
+                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, nstep - 1,isRoot);
+                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, nstep - 1, isRoot);
                    }
                    CTimer::get("Files : writing time axis").suspend();
@@ -2522 +2201 @@
                 if (field->getUseCompressedOutput())
                 {
-                  if (grid->isCompressible())
+                  CArray<int,1> axisDomainOrder = grid->axis_domain_order;
+                  std::vector<StdString> domainList = grid->getDomainList();
+                  std::vector<StdString> axisList   = grid->getAxisList();
+                  int numElement = axisDomainOrder.numElements();
+                  int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
+                  int idx = domainList.size() * 2 + axisList.size() - 1;
+                  int commRank ;
+
+                  MPI_Comm_rank(comm_file,&commRank) ;
+
+                  start.reserve(idx+1);
+                  count.reserve(idx+1);
+
+                  for (int i = numElement - 1; i >= 0; --i)
                   {
-                    start.push_back(grid->getOffsetWrittenIndexes());
-                    count.push_back(grid->getNumberWrittenIndexes());
-                  }
-                  else
-                  {
-                    CArray<int,1> axisDomainOrder = grid->axis_domain_order;
-                    std::vector<StdString> domainList = grid->getDomainList();
-                    std::vector<StdString> axisList   = grid->getAxisList();
-                    int numElement = axisDomainOrder.numElements();
-                    int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
-                    int idx = domainList.size() * 2 + axisList.size() - 1;
-
-                    start.reserve(idx+1);
-                    count.reserve(idx+1);
-
-                    for (int i = numElement - 1; i >= 0; --i)
+                    if (2 == axisDomainOrder(i))
                     {
-                      if (2 == axisDomainOrder(i))
+                      CDomain* domain = CDomain::get(domainList[idxDomain]);
+
+                      if (domain->isCompressible())
                       {
-                        CDomain* domain = CDomain::get(domainList[idxDomain]);
-
-                        if (domain->isCompressible())
+                        size_t offset ;
+                        size_t nbIndexes = domain->getLocalView(CElementView::WORKFLOW)->getSize() ;
+                        if (domain->isDistributed())
                         {
-                          start.push_back(domain->getOffsetWrittenIndexes(comm_file));
-                          count.push_back(domain->getNumberWrittenIndexes(comm_file));
-                          idx -= 2;
+                          MPI_Exscan(&nbIndexes, &offset, 1, MPI_SIZE_T, MPI_SUM, comm_file) ;
+                          if (commRank==0) offset=0 ;
                         }
-                        else
+                        else offset=0 ;
+
+                        start.push_back(offset);
+                        count.push_back(nbIndexes);
+                        idx -= 2;
+                      }
+                      else
+                      {
+                        if ((domain->type) != CDomain::type_attr::unstructured)
                         {
-                          if ((domain->type) != CDomain::type_attr::unstructured)
-                          {
-                            start.push_back(domain->jbegin);
-                            count.push_back(domain->nj);
-                          }
-                          --idx;
-                          start.push_back(domain->ibegin);
-                          count.push_back(domain->ni);
-                          --idx;
+                          start.push_back(domain->jbegin);
+                          count.push_back(domain->nj);
                         }
-                        --idxDomain;
-                      }
-                      else if (1 == axisDomainOrder(i))
-                      {
-                        CAxis* axis = CAxis::get(axisList[idxAxis]);
-
-                        if (axis->isCompressible())
-                        {
-                          start.push_back(axis->getOffsetWrittenIndexes(comm_file));
-                          count.push_back(axis->getNumberWrittenIndexes(comm_file));
-                        }
-                        else
-                        {
-                          start.push_back(axis->begin);
-                          count.push_back(axis->n);
-                        }
-                        --idxAxis;
+                        --idx;
+                        start.push_back(domain->ibegin);
+                        count.push_back(domain->ni);
                         --idx;
                       }
+                      --idxDomain;
+                    }
+                    else if (1 == axisDomainOrder(i))
+                    {
+                      CAxis* axis = CAxis::get(axisList[idxAxis]);
+
+                      if (axis->isCompressible())
+                      {
+                        size_t offset ;
+                        size_t nbIndexes = axis->getLocalView(CElementView::WORKFLOW)->getSize() ;
+                        if (axis->isDistributed())
+                        {
+                          MPI_Exscan(&nbIndexes, &offset, 1, MPI_SIZE_T, MPI_SUM, comm_file) ;
+                          if (commRank==0) offset=0 ;
+                        }
+                        else offset=0 ;
+
+                        start.push_back(offset);
+                        count.push_back(nbIndexes);
+                      }
+                      else
+                      {
+                        start.push_back(axis->begin);
+                        count.push_back(axis->n);
+                      }
+                      --idxAxis;
+                      --idx;
                     }
                   }
@@ -2636 +2328 @@
 
                 CTimer::get("Files : writing data").resume();
-                SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1, &start, &count);
+                SuperClassWriter::writeData(data, fieldid, isCollective, nstep - 1, &start, &count);
                 CTimer::get("Files : writing data").suspend();
 
@@ -2644 +2336 @@
                    if ( wtimeData)
                    {
-                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot);
-                     SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot);
+                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, nstep - 1, isRoot);
+                     SuperClassWriter::writeTimeAxisDataBounds(time_data_bound, timeAxisBoundId, isCollective, nstep - 1, isRoot);
                    }
                    if (wtimeCounter)
                    {
-                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1,isRoot);
-                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot);
+                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, nstep - 1,isRoot);
+                     if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, nstep - 1, isRoot);
 
                    }
@@ -2659 +2351 @@
               }
             }
+            return nstep ;
          }
          catch (CNetCdfException& e)
@@ -2691 +2384 @@
 
          StdString strTimeUnits ;
-         if (!field->file->time_units.isEmpty() && field->file->time_units==CFile::time_units_attr::days) strTimeUnits="days since " ;
+         if (!field->getRelFile()->time_units.isEmpty() && field->getRelFile()->time_units==CFile::time_units_attr::days) strTimeUnits="days since " ;
          else  strTimeUnits="seconds since " ;
  
@@ -2698 +2391 @@
 
 
-         if (field->file->time_counter.isEmpty())
+         if (field->getRelFile()->time_counter.isEmpty())
          {
            if (timeCounterType==none) createTimeCounterAxis=true ;
@@ -2712 +2405 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::instant)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::instant)
          {
            if (field->hasTimeCentered)
@@ -2725 +2418 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::centered)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::centered)
          {
            if (field->hasTimeCentered)
@@ -2738 +2431 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::instant_exclusive)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::instant_exclusive)
          {
            if (field->hasTimeCentered)
@@ -2750 +2443 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::centered_exclusive)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::centered_exclusive)
          {
            if (field->hasTimeCentered)
@@ -2762 +2455 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::exclusive)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::exclusive)
          {
            if (field->hasTimeCentered)
@@ -2783 +2476 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::none)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::none)
          {
            if (field->hasTimeCentered)
@@ -2794 +2487 @@
            }
          }
-         else if (field->file->time_counter==CFile::time_counter_attr::record)
+         else if (field->getRelFile()->time_counter==CFile::time_counter_attr::record)
          {
            if (timeCounterType==none) createTimeCounterAxis=true ;
@@ -2865 +2558 @@
                 SuperClassWriter::addAttribute("axis", string("T"), &axisId);
 
-                if (field->file->time_counter.isEmpty() || 
-                   (field->file->time_counter != CFile::time_counter_attr::record))
+                if (field->getRelFile()->time_counter.isEmpty() || 
+                   (field->getRelFile()->time_counter != CFile::time_counter_attr::record))
                 {
                   CDate timeOrigin = cal->getTimeOrigin();
@@ -2878 +2571 @@
 
              // Adding time_counter_bound dimension
-             if (field->file->time_counter.isEmpty() || (field->file->time_counter != CFile::time_counter_attr::record))
+             if (field->getRelFile()->time_counter.isEmpty() || (field->getRelFile()->time_counter != CFile::time_counter_attr::record))
              {
                 if (!SuperClassWriter::varExist(axisBoundId))

XIOS/dev/dev_trunk_graph/src/io/nc4_data_output.hpp

@@ -56 +56 @@
             virtual void writeAttribute_(CVariable* var);
             virtual void writeAttribute_(CVariable* var, const string& fieldId);
-            virtual void writeFieldData_(CField* field);
+            virtual int  writeFieldData_(CField* field, const CArray<double,1>& data, const CDate& lastWrite, const CDate& currentWrite, int nstep);
             virtual void writeFile_     (CFile* file);
             virtual void closeFile_     (void);

XIOS/dev/dev_trunk_graph/src/io/netCdfInterface.cpp

@@ -894 +894 @@
 
 template<>
+int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, size_t* data)
+{
+  return nc_get_att_ulonglong(ncid, varid, attrName, (unsigned long long*)data);
+}
+
+template<>
 int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, short* data)
 {
@@ -936 +942 @@
 template<>
 int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
+                                   StdSize numVal, const size_t* data)
+{
+  return nc_put_att_ulonglong(ncid, varid, attrName, NC_UINT64, numVal, (unsigned long long*) data);
+}
+
+template<>
+int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
                                    StdSize numVal, const short* data)
 {
@@ -968 +981 @@
 
 template<>
+int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, size_t* data)
+{
+  return nc_get_vara_ulonglong(ncid, varid, start, count, (unsigned long long*) data);
+}
+
+template<>
 int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, char* data)
 {
@@ -990 +1009 @@
 {
   return nc_put_vara_int(ncid, varid, start, count, data);
+}
+
+template<>
+int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const size_t* data)
+{
+  return nc_put_vara_ulonglong(ncid, varid, start, count, (unsigned long long*)data);
 }
 

XIOS/dev/dev_trunk_graph/src/io/netCdfInterface_decl.cpp

@@ -20 +20 @@
   macroAtt(float)
   macroAtt(int)
+  macroAtt(size_t)
   macroAtt(long)
   macroAtt(short)
@@ -33 +34 @@
   macroPutVar(float)
   macroPutVar(int)
+  macroPutVar(size_t)
   macroPutVar(char)
   
@@ -41 +43 @@
   macroType(float, NC_FLOAT)
   macroType(int, NC_INT)
+  macroType(size_t, NC_UINT64)
   macroType(long, NC_LONG)
   macroType(short, NC_SHORT)

XIOS/dev/dev_trunk_graph/src/io/onetcdf4.cpp

@@ -538 +538 @@
       
       template <>
-
       void CONetCDF4::writeData_(int grpid, int varid,
                                  const std::vector<StdSize>& sstart,
                                  const std::vector<StdSize>& scount, const int* data)
+      {
+          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);
+      }
+      //---------------------------------------------------------------
+
+      template <>
+      void CONetCDF4::writeData_(int grpid, int varid,
+                                 const std::vector<StdSize>& sstart,
+                                 const std::vector<StdSize>& scount, const size_t* data)
       {
           CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);

XIOS/dev/dev_trunk_graph/src/io/onetcdf4_decl.cpp

@@ -11 +11 @@
   macro(int, 1)
   macro(int, 2)
+  macro(size_t, 1)
+  macro(size_t, 2)
   macro(double, 1)
   macro(double, 2)

XIOS/dev/dev_trunk_graph/src/io/onetcdf4_impl.hpp

@@ -76 +76 @@
     memset (PtrArrayStr,' ',stringArrayLen*data.numElements());
     size_t offset=0 ;
-
+    
 // pb with iterator with blitz++ string array  with recent compiler
 /*
@@ -90 +90 @@
        data(i).copy(PtrArrayStr+offset,data(i).size()) ;
        PtrArrayStr[offset+data(i).size()]='\0' ;
-     } 
+     }
      CTimer::get("CONetCDF4::writeData writeData_").resume();
      this->writeData_(grpid, varid, sstart, scount, PtrArrayStr);