source: XIOS/trunk/src/io/nc4_data_output.cpp @ 878

Last change on this file since 878 was 878, checked in by oabramkina, 5 years ago

Sequential version for UGRID norms. File attribute "convention" has been added with two possible values "CF" and "UGRID". The default value is "CF".

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:executable set to *
File size: 108.3 KB
Line 
1#include "nc4_data_output.hpp"
2
3#include <boost/lexical_cast.hpp>
4#include "attribute_template.hpp"
5#include "group_template.hpp"
6
7#include "file.hpp"
8#include "calendar.hpp"
9#include "context.hpp"
10#include "context_server.hpp"
11#include "netCdfException.hpp"
12#include "exception.hpp"
13
14namespace xios
15{
16      /// ////////////////////// Dfinitions ////////////////////// ///
17      CNc4DataOutput::CNc4DataOutput
18         (const StdString & filename, bool exist)
19            : SuperClass()
20            , SuperClassWriter(filename, exist)
21            , filename(filename)
22      {
23                SuperClass::type = MULTI_FILE;
24      }
25
26      CNc4DataOutput::CNc4DataOutput
27         (const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention,
28          MPI_Comm comm_file,bool multifile, bool isCollective, const StdString& timeCounterName)
29            : SuperClass()
30            , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName)
31            , comm_file(comm_file)
32            , filename(filename)
33            , isCollective(isCollective)
34      {
35                SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE;
36      }
37
38      CNc4DataOutput::~CNc4DataOutput(void)
39          { /* Ne rien faire de plus */ }
40
41      ///--------------------------------------------------------------
42
43      const StdString & CNc4DataOutput::getFileName(void) const
44      {
45         return (this->filename);
46      }
47
48      //---------------------------------------------------------------
49
50      void CNc4DataOutput::writeDomain_(CDomain* domain)
51      {
52         if (domain->type == CDomain::type_attr::unstructured)
53         {
54                         if (SuperClassWriter::useCFConvention)
55                                writeUnstructuredDomain(domain) ;
56                        else
57                                writeUnstructuredDomainUgrid(domain) ;
58           return ;
59         }
60
61         CContext* context = CContext::getCurrent() ;
62         CContextServer* server=context->server ;
63
64         if (domain->IsWritten(this->filename)) return;
65         domain->checkAttributes();
66
67         if (domain->isEmpty())
68           if (SuperClass::type==MULTI_FILE) return ;
69
70         std::vector<StdString> dim0, dim1;
71         StdString domid = domain->getDomainOutputName();
72         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
73         if (isWrittenDomain(domid)) return ;
74         else setWrittenDomain(domid);
75
76
77         StdString dimXid, dimYid ;
78
79         bool isRegularDomain = (domain->type == CDomain::type_attr::rectilinear);
80         switch (domain->type)
81         {
82           case CDomain::type_attr::curvilinear :
83             dimXid     = StdString("x").append(appendDomid);
84             dimYid     = StdString("y").append(appendDomid);
85             break ;
86           case CDomain::type_attr::rectilinear :
87             dimXid     = StdString("lon").append(appendDomid);
88             dimYid     = StdString("lat").append(appendDomid);
89             break;
90         }
91
92         StdString dimVertId = StdString("nvertex").append(appendDomid);
93
94         string lonid,latid,bounds_lonid,bounds_latid ;
95         string areaId = "area" + appendDomid;
96/*
97         StdString lonid_loc = (server->intraCommSize > 1)
98                             ? StdString("lon").append(appendDomid).append("_local")
99                             : lonid;
100         StdString latid_loc = (server->intraCommSize > 1)
101                             ? StdString("lat").append(appendDomid).append("_local")
102                             : latid;
103*/
104
105         try
106         {
107           switch (SuperClass::type)
108           {
109              case (MULTI_FILE) :
110              {
111  //               if (domain->isEmpty()) return;
112
113                 if (server->intraCommSize > 1)
114                 {
115  //                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
116  //                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
117                 }
118
119                 switch (domain->type)
120                 {
121                   case CDomain::type_attr::curvilinear :
122                     dim0.push_back(dimYid); dim0.push_back(dimXid);
123                     lonid = StdString("nav_lon").append(appendDomid);
124                     latid = StdString("nav_lat").append(appendDomid);
125                     break ;
126                   case CDomain::type_attr::rectilinear :
127                     lonid = StdString("lon").append(appendDomid);
128                     latid = StdString("lat").append(appendDomid);
129                     dim0.push_back(dimYid);
130                     dim1.push_back(dimXid);
131                     break;
132                 }
133
134                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
135                 bounds_latid = StdString("bounds_lat").append(appendDomid);
136
137                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
138                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv);
139
140                 if (domain->hasBounds)
141                   SuperClassWriter::addDimension(dimVertId, domain->nvertex);
142
143                 if (server->intraCommSize > 1)
144                 {
145                   this->writeLocalAttributes(domain->zoom_ibegin_srv,
146                                              domain->zoom_ni_srv,
147                                              domain->zoom_jbegin_srv,
148                                              domain->zoom_nj_srv,
149                                              appendDomid);
150
151                   if (singleDomain)
152                    this->writeLocalAttributes_IOIPSL(dimXid, dimYid,
153                                                      domain->zoom_ibegin_srv,
154                                                      domain->zoom_ni_srv,
155                                                      domain->zoom_jbegin_srv,
156                                                      domain->zoom_nj_srv,
157                                                      domain->ni_glo,domain->nj_glo,
158                                                      server->intraCommRank,server->intraCommSize);
159                 }
160
161                 if (domain->hasLonLat)
162                 {
163                   switch (domain->type)
164                   {
165                     case CDomain::type_attr::curvilinear :
166                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
167                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
168                       break ;
169                      case CDomain::type_attr::rectilinear :
170                        SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
171                        SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
172                        break ;
173                   }
174
175                   this->writeAxisAttributes(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
176                   this->writeAxisAttributes(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
177
178                   if (domain->hasBounds)
179                   {
180                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
181                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
182
183                     dim0.clear();
184                     dim0.push_back(dimYid);
185                     dim0.push_back(dimXid);
186                     dim0.push_back(dimVertId);
187                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
188                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
189                   }
190                 }
191
192                 dim0.clear();
193                 dim0.push_back(dimYid);
194                 dim0.push_back(dimXid);
195
196
197  // supress mask               if (server->intraCommSize > 1)
198  // supress mask               {
199  // supress mask                  SuperClassWriter::addVariable(maskid, NC_INT, dim0);
200  // supress mask
201  // supress mask                  this->writeMaskAttributes(maskid,
202  // supress mask                     domain->data_dim.getValue()/*,
203  // supress mask                     domain->data_ni.getValue(),
204  // supress mask                     domain->data_nj.getValue(),
205  // supress mask                     domain->data_ibegin.getValue(),
206  // supress mask                     domain->data_jbegin.getValue()*/);
207  // supress mask               }
208
209                 //SuperClassWriter::setDefaultValue(maskid, &dvm);
210
211                 if (domain->hasArea)
212                 {
213                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
214                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
215                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
216                 }
217
218                 SuperClassWriter::definition_end();
219
220                 if (domain->hasLonLat)
221                 {
222                   switch (domain->type)
223                   {
224                     case CDomain::type_attr::curvilinear :
225                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
226                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
227                       break;
228                     case CDomain::type_attr::rectilinear :
229                       CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
230                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
231                       CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
232                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0);
233                       break;
234                   }
235
236                   if (domain->hasBounds)
237                   {
238                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
239                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
240                   }
241                 }
242
243                 if (domain->hasArea)
244                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
245
246                 SuperClassWriter::definition_start();
247
248                 break;
249              }
250              case (ONE_FILE) :
251              {
252                 SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni);
253                 SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj);
254
255                 if (domain->hasBounds)
256                   SuperClassWriter::addDimension(dimVertId, domain->nvertex);
257
258                 if (domain->hasLonLat)
259                 {
260                   switch (domain->type)
261                   {
262                     case CDomain::type_attr::curvilinear :
263                       dim0.push_back(dimYid); dim0.push_back(dimXid);
264                       lonid = StdString("nav_lon").append(appendDomid);
265                       latid = StdString("nav_lat").append(appendDomid);
266                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
267                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
268                       break;
269
270                     case CDomain::type_attr::rectilinear :
271                       dim0.push_back(dimYid);
272                       dim1.push_back(dimXid);
273                       lonid = StdString("lon").append(appendDomid);
274                       latid = StdString("lat").append(appendDomid);
275                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
276                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
277                       break;
278                   }
279
280                   bounds_lonid = StdString("bounds_lon").append(appendDomid);
281                   bounds_latid = StdString("bounds_lat").append(appendDomid);
282
283                   this->writeAxisAttributes
284                      (lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
285                   this->writeAxisAttributes
286                      (latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
287
288                   if (domain->hasBounds)
289                   {
290                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
291                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
292
293                     dim0.clear();
294                     dim0.push_back(dimYid);
295                     dim0.push_back(dimXid);
296                     dim0.push_back(dimVertId);
297                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
298                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
299                   }
300                 }
301
302                 if (domain->hasArea)
303                 {
304                   dim0.clear();
305                   dim0.push_back(dimYid); dim0.push_back(dimXid);
306                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
307                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
308                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
309                   dim0.clear();
310                 }
311
312                 SuperClassWriter::definition_end();
313
314                 switch (domain->type)
315                 {
316                   case CDomain::type_attr::curvilinear :
317                   {
318                     std::vector<StdSize> start(2) ;
319                     std::vector<StdSize> count(2) ;
320                     if (domain->isEmpty())
321                     {
322                       start[0]=0 ; start[1]=0 ;
323                       count[0]=0 ; count[1]=0 ;
324                     }
325                     else
326                     {
327                       start[1]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
328                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
329                       count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
330                     }
331
332                     if (domain->hasLonLat)
333                     {
334                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
335                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
336                     }
337                     break;
338                   }
339                   case CDomain::type_attr::rectilinear :
340                   {
341                     if (domain->hasLonLat)
342                     {
343                       std::vector<StdSize> start(1) ;
344                       std::vector<StdSize> count(1) ;
345                       if (domain->isEmpty())
346                       {
347                         start[0]=0 ;
348                         count[0]=0 ;
349                         SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
350                         SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
351
352                       }
353                       else
354                       {
355                         start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
356                         count[0]=domain->zoom_nj_srv ;
357                         CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
358                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
359
360                         start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
361                         count[0]=domain->zoom_ni_srv ;
362                         CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
363                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
364                       }
365                     }
366                     break;
367                   }
368                 }
369
370                 if (domain->hasBounds)
371                 {
372                   std::vector<StdSize> start(3);
373                   std::vector<StdSize> count(3);
374                   if (domain->isEmpty())
375                   {
376                     start[2] = start[1] = start[0] = 0;
377                     count[2] = count[1] = count[0] = 0;
378                   }
379                   else
380                   {
381                     start[2] = 0;
382                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
383                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
384                     count[2] = domain->nvertex;
385                     count[1] = domain->zoom_ni_srv;
386                     count[0] = domain->zoom_nj_srv;
387                   }
388
389                 SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0, &start, &count);
390                 SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0, &start, &count);
391                 }
392
393                 if (domain->hasArea)
394                 {
395                   std::vector<StdSize> start(2);
396                   std::vector<StdSize> count(2);
397
398                   if (domain->isEmpty())
399                   {
400                     start[0] = 0; start[1] = 0;
401                     count[0] = 0; count[1] = 0;
402                   }
403                   else
404                   {
405                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
406                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
407                     count[1] = domain->zoom_ni_srv;
408                     count[0] = domain->zoom_nj_srv;
409                   }
410
411                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
412                 }
413
414                 SuperClassWriter::definition_start();
415                 break;
416              }
417              default :
418                 ERROR("CNc4DataOutput::writeDomain(domain)",
419                       << "[ type = " << SuperClass::type << "]"
420                       << " not implemented yet !");
421           }
422         }
423         catch (CNetCdfException& e)
424         {
425           StdString msg("On writing the domain : ");
426           msg.append(domid); msg.append("\n");
427           msg.append("In the context : ");
428           msg.append(context->getId()); msg.append("\n");
429           msg.append(e.what());
430           ERROR("CNc4DataOutput::writeDomain_(CDomain* domain)", << msg);
431         }
432
433         domain->addRelFile(this->filename);
434      }
435
436          //--------------------------------------------------------------
437
438                void CNc4DataOutput::writeUnstructuredDomainUgrid(CDomain* domain)
439                {
440                        CContext* context = CContext::getCurrent() ;
441                        CContextServer* server=context->server ;
442
443                        if (domain->IsWritten(this->filename)) return;
444                        domain->checkAttributes();
445                        if (domain->isEmpty())
446                                if (SuperClass::type==MULTI_FILE) return ;
447
448                        std::vector<StdString> dim0;
449                        StdString domid = domain->getDomainOutputName();
450                        StdString domainName = domain->name;
451
452                        if (domain->mesh->isWritten(domainName)) domain->mesh = CMesh::getMesh;
453
454                        domain->mesh->createMesh(domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv);
455                        //domain->mesh->createMeshEpsilon(domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv);
456
457                        StdString node_x = domainName + "_node_x";
458                        StdString node_y = domainName + "_node_y";
459
460                        StdString edge_x = domainName + "_edge_x";
461                        StdString edge_y = domainName + "_edge_y";
462                        StdString edge_nodes = domainName + "_edge_nodes";
463
464                        StdString face_x = domainName + "_face_x";
465                        StdString face_y = domainName + "_face_y";
466                        StdString face_nodes = domainName + "_face_nodes";
467
468                        StdString dimNode = "n" + domainName + "_node";
469                        StdString dimEdge = "n" + domainName + "_edge";
470                        StdString dimFace = "n" + domainName + "_face";
471                        StdString dimVertex = "n" + domainName + "_vertex";
472                        StdString dimTwo = "Two";
473
474                        if (!SuperClassWriter::dimExist(dimTwo)) SuperClassWriter::addDimension(dimTwo, 2);
475                        if (!isWrittenDomain(domid))
476                        {
477                                dim0.clear();
478                                SuperClassWriter::addVariable(domainName, NC_INT, dim0);
479                                SuperClassWriter::addAttribute("cf_role", StdString("mesh_topology"), &domainName);
480                                SuperClassWriter::addAttribute("node_coordinates", node_x + " " + node_y, &domainName);
481                        }
482
483                        try
484                        {
485                                switch (SuperClass::type)
486                                {
487                                        case (ONE_FILE) :
488                                        {
489                                                // Adding nodes
490                                                if (domain->nvertex == 1)
491                                                {
492                                                        if (!SuperClassWriter::varExist(node_x) || !SuperClassWriter::varExist(node_y))
493                                                        {
494                                                                SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
495                                                                dim0.clear();
496                                                                dim0.push_back(dimNode);
497                                                                SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
498                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
499                                                                SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
500                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
501                                                                SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
502                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
503                                                                SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
504                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
505                                                        }
506                                                } // domain->nvertex == 1
507
508                                                // Adding edges and nodes, if nodes have not been defined previously
509                                                if (domain->nvertex == 2)
510                                                {
511                                                        // Nodes
512                                                        if (!SuperClassWriter::varExist(node_x) || !SuperClassWriter::varExist(node_y))
513                                                        {
514                                                                SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
515                                                                dim0.clear();
516                                                                dim0.push_back(dimNode);
517                                                                SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
518                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
519                                                                SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
520                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
521                                                                SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
522                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
523                                                                SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
524                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
525                                                        }
526                                                        // Edges
527                                                        if (!SuperClassWriter::varExist(edge_x) || !SuperClassWriter::varExist(edge_y))
528                                                        {
529                                                                SuperClassWriter::addAttribute("edge_node_connectivity", edge_nodes, &domainName);
530                                                                SuperClassWriter::addAttribute("edge_coordinates", edge_x + " " + edge_y, &domainName);
531                                                                SuperClassWriter::addDimension(dimEdge, domain->mesh->nbEdges);
532                                                                dim0.clear();
533                                                                dim0.push_back(dimEdge);
534                                                                SuperClassWriter::addVariable(edge_x, NC_FLOAT, dim0);
535                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &edge_x);
536                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh edges."), &edge_x);
537                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &edge_x);
538                                                                SuperClassWriter::addVariable(edge_y, NC_FLOAT, dim0);
539                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &edge_y);
540                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh edges."), &edge_y);
541                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &edge_y);
542                                                                dim0.clear();
543                                                                dim0.push_back(dimEdge);
544                                                                dim0.push_back(dimTwo);
545                                                                SuperClassWriter::addVariable(edge_nodes, NC_INT, dim0);
546                                                                SuperClassWriter::addAttribute("cf_role", StdString("edge_node_connectivity"), &edge_nodes);
547                                                                SuperClassWriter::addAttribute("long_name", StdString("Maps every edge/link to two nodes that it connects."), &edge_nodes);
548                                                                SuperClassWriter::addAttribute("start_index", 0, &edge_nodes);
549                                                        }
550                                                } // domain->nvertex == 2
551
552                                                // Adding faces, edges, and nodes, if edges and nodes have not been defined previously
553                                                if (domain->nvertex > 2)
554                                                {
555                                                        // Nodes
556                                                        if (!SuperClassWriter::varExist(node_x) || !SuperClassWriter::varExist(node_y))
557                                                        {
558                                                                SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
559                                                                dim0.clear();
560                                                                dim0.push_back(dimNode);
561                                                                SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
562                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
563                                                                SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
564                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
565                                                                SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
566                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
567                                                                SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
568                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
569                                                        }
570                                                        // Edges
571                                                        if (!SuperClassWriter::varExist(edge_x) || !SuperClassWriter::varExist(edge_y))
572                                                        {
573                                                                SuperClassWriter::addAttribute("edge_coordinates", edge_x + " " + edge_y, &domainName);
574                                                                SuperClassWriter::addAttribute("edge_node_connectivity", edge_nodes, &domainName);
575                                                                SuperClassWriter::addDimension(dimEdge, domain->mesh->nbEdges);
576                                                                dim0.clear();
577                                                                dim0.push_back(dimEdge);
578                                                                SuperClassWriter::addVariable(edge_x, NC_FLOAT, dim0);
579                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &edge_x);
580                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh edges."), &edge_x);
581                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &edge_x);
582                                                                SuperClassWriter::addVariable(edge_y, NC_FLOAT, dim0);
583                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &edge_y);
584                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh edges."), &edge_y);
585                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &edge_y);
586                                                                dim0.clear();
587                                                                dim0.push_back(dimEdge);
588                                                                dim0.push_back(dimTwo);
589                                                                SuperClassWriter::addVariable(edge_nodes, NC_INT, dim0);
590                                                                SuperClassWriter::addAttribute("cf_role", StdString("edge_node_connectivity"), &edge_nodes);
591                                                                SuperClassWriter::addAttribute("long_name", StdString("Maps every edge/link to two nodes that it connects."), &edge_nodes);
592                                                                SuperClassWriter::addAttribute("start_index", 0, &edge_nodes);
593                                                        }
594                                                        // Faces
595                                                                SuperClassWriter::addAttribute("face_coordinates", face_x + " " + face_y, &domainName);
596                                                                SuperClassWriter::addAttribute("face_node_connectivity", face_nodes, &domainName);
597                                                                SuperClassWriter::addDimension(dimFace, domain->mesh->nbFaces);
598                                                                SuperClassWriter::addDimension(dimVertex, domain->mesh->nvertex);
599                                                                dim0.clear();
600                                                                dim0.push_back(dimFace);
601                                                                SuperClassWriter::addVariable(face_x, NC_FLOAT, dim0);
602                                                                SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &face_x);
603                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh faces."), &face_x);
604                                                                SuperClassWriter::addAttribute("units", StdString("degrees_east"), &face_x);
605                                                                SuperClassWriter::addVariable(face_y, NC_FLOAT, dim0);
606                                                                SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &face_y);
607                                                                SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh faces."), &face_y);
608                                                                SuperClassWriter::addAttribute("units", StdString("degrees_north"), &face_y);
609                                                                dim0.clear();
610                                                                dim0.push_back(dimFace);
611                                                                dim0.push_back(dimVertex);
612                                                                SuperClassWriter::addVariable(face_nodes, NC_INT, dim0);
613                                                                SuperClassWriter::addAttribute("cf_role", StdString("face_node_connectivity"), &face_nodes);
614                                                                SuperClassWriter::addAttribute("long_name", StdString("Maps every face to its corner nodes."), &face_nodes);
615                                                                SuperClassWriter::addAttribute("start_index", 0, &face_nodes);
616                                                } // domain->nvertex > 2
617
618                                                SuperClassWriter::definition_end();
619
620                                                if (!isWrittenDomain(domid))
621                                                {
622                                                        if (domain->nvertex == 1)
623                                                        {
624                                                                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
625                                                                SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
626                                                        }
627                                                        else if (domain->nvertex == 2)
628                            {
629                                                                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
630                                                                SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
631                                                                SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
632                                                                SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
633                                                                SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
634                            }
635                                                        else
636                                                        {
637                                                                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
638                                                                SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
639                                                                SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
640                                                                SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
641                                                                SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
642                                                                SuperClassWriter::writeData(domain->mesh->face_lat, face_y, isCollective, 0);
643                                                                SuperClassWriter::writeData(domain->mesh->face_lon, face_x, isCollective, 0);
644                                                                SuperClassWriter::writeData(domain->mesh->face_nodes, face_nodes);
645                                                        }
646                                                        setWrittenDomain(domid);
647                                                } // !isWrittenDomain
648                                                else
649                                                {
650                                                        if (domain->nvertex == 1)
651                                                        {
652                                if ( (!domain->mesh->edgesAreWritten) && (!domain->mesh->facesAreWritten) )
653                                                                {
654                                                                        SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
655                                                                        SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
656                                                                }
657                                                        }
658                                                        if (domain->nvertex == 2)
659                                                        {
660                                if (!domain->mesh->facesAreWritten)
661                                                                {
662                                                                        if (!domain->mesh->nodesAreWritten)
663                                                                        {
664                                                                                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
665                                                                                SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
666                                                                        }
667                                                                        SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
668                                                                        SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
669                                                                        SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
670                                                                }
671                                                        }       
672                                                        if (domain->nvertex > 2)
673                                                        {
674                                                                if (!domain->mesh->edgesAreWritten)
675                                                                {
676                                                                        if (!domain->mesh->nodesAreWritten)
677                                                                        {
678                                                                                SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
679                                                                                SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
680                                                                        }
681                                                                        SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
682                                                                        SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
683                                                                        SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
684                                                                }
685                                                                SuperClassWriter::writeData(domain->mesh->face_lat, face_y, isCollective, 0);
686                                                                SuperClassWriter::writeData(domain->mesh->face_lon, face_x, isCollective, 0);
687                                                                SuperClassWriter::writeData(domain->mesh->face_nodes, face_nodes);
688                                                        }
689                                                }// isWrittenDomain
690
691                                                SuperClassWriter::definition_start();
692
693                                                break;
694                                        } // ONE_FILE
695
696                                        case (MULTI_FILE) :
697                                        {
698                                                break;
699                                        }
700
701                                        default :
702                                        ERROR("CNc4DataOutput::writeDomain(domain)",
703                                        << "[ type = " << SuperClass::type << "]"
704                                        << " not implemented yet !");
705                                        } // switch
706                                } // try
707
708                                catch (CNetCdfException& e)
709                                {
710                                        StdString msg("On writing the domain : ");
711                                        msg.append(domid); msg.append("\n");
712                                        msg.append("In the context : ");
713                                        msg.append(context->getId()); msg.append("\n");
714                                        msg.append(e.what());
715                                        ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
716                                }
717
718        domain->addRelFile(this->filename);
719        }
720
721          //--------------------------------------------------------------
722
723          void CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)
724      {
725         CContext* context = CContext::getCurrent() ;
726         CContextServer* server=context->server ;
727
728         if (domain->IsWritten(this->filename)) return;
729         domain->checkAttributes();
730
731         if (domain->isEmpty())
732           if (SuperClass::type==MULTI_FILE) return ;
733
734         std::vector<StdString> dim0, dim1;
735         StdString domid = domain->getDomainOutputName();
736         if (isWrittenDomain(domid)) return ;
737         else setWrittenDomain(domid);
738
739         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
740
741
742         StdString dimXid = StdString("cell").append(appendDomid);
743         StdString dimVertId = StdString("nvertex").append(appendDomid);
744
745         string lonid,latid,bounds_lonid,bounds_latid ;
746         string areaId = "area" + appendDomid;
747
748         try
749         {
750           switch (SuperClass::type)
751           {
752              case (MULTI_FILE) :
753              {
754                 dim0.push_back(dimXid);
755                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
756
757                 lonid = StdString("lon").append(appendDomid);
758                 latid = StdString("lat").append(appendDomid);
759                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
760                 bounds_latid = StdString("bounds_lat").append(appendDomid);
761                 if (domain->hasLonLat)
762                 {
763                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
764                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
765                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
766                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
767                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
768                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
769                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
770                 }
771                 dim0.clear();
772                 if (domain->hasBounds)
773                 {
774                   dim0.push_back(dimXid);
775                   dim0.push_back(dimVertId);
776                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
777                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
778                 }
779
780                 dim0.clear();
781                 dim0.push_back(dimXid);
782                 if (domain->hasArea)
783                 {
784                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
785                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
786                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
787                 }
788
789                 SuperClassWriter::definition_end();
790
791                 if (domain->hasLonLat)
792                 {
793                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
794                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
795                   if (domain->hasBounds)
796                   {
797                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
798                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
799                   }
800                 }
801
802                 if (domain->hasArea)
803                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
804
805                 SuperClassWriter::definition_start();
806                 break ;
807              }
808
809              case (ONE_FILE) :
810              {
811                 lonid = StdString("lon").append(appendDomid);
812                 latid = StdString("lat").append(appendDomid);
813                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
814                 bounds_latid = StdString("bounds_lat").append(appendDomid);
815                 dim0.push_back(dimXid);
816                 SuperClassWriter::addDimension(dimXid, domain->ni_glo);
817                 if (domain->hasLonLat)
818                 {
819                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
820                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
821
822                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
823                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
824                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
825                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
826                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
827                 }
828                 dim0.clear();
829
830                 if (domain->hasBounds)
831                 {
832                   dim0.push_back(dimXid);
833                   dim0.push_back(dimVertId);
834                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
835                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
836                 }
837
838                 if (domain->hasArea)
839                 {
840                   dim0.clear();
841                   dim0.push_back(dimXid);
842                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
843                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
844                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
845                 }
846
847                 SuperClassWriter::definition_end();
848
849                 std::vector<StdSize> start(1), startBounds(2) ;
850                 std::vector<StdSize> count(1), countBounds(2) ;
851                 if (domain->isEmpty())
852                 {
853                   start[0]=0 ;
854                   count[0]=0 ;
855                   startBounds[1]=0 ;
856                   countBounds[1]=domain->nvertex ;
857                   startBounds[0]=0 ;
858                   countBounds[0]=0 ;
859                 }
860                 else
861                 {
862                   start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
863                   count[0]=domain->zoom_ni_srv ;
864                   startBounds[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
865                   startBounds[1]=0 ;
866                   countBounds[0]=domain->zoom_ni_srv ;
867                   countBounds[1]=domain->nvertex ;
868                 }
869
870                 if (domain->hasLonLat)
871                 {
872                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
873                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
874                   if (domain->hasBounds)
875                   {
876                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
877                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds);
878                   }
879                 }
880
881                 if (domain->hasArea)
882                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
883
884                 SuperClassWriter::definition_start();
885
886                 break;
887              }
888              default :
889                 ERROR("CNc4DataOutput::writeDomain(domain)",
890                       << "[ type = " << SuperClass::type << "]"
891                       << " not implemented yet !");
892           }
893         }
894         catch (CNetCdfException& e)
895         {
896           StdString msg("On writing the domain : ");
897           msg.append(domid); msg.append("\n");
898           msg.append("In the context : ");
899           msg.append(context->getId()); msg.append("\n");
900           msg.append(e.what());
901           ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
902         }
903         domain->addRelFile(this->filename);
904      }
905      //--------------------------------------------------------------
906
907      void CNc4DataOutput::writeAxis_(CAxis* axis)
908      {
909        if (axis->IsWritten(this->filename)) return;
910        axis->checkAttributes();
911        int zoom_size_srv  = axis->zoom_size_srv;
912        int zoom_begin_srv = axis->zoom_begin_srv;
913        int zoom_size  = (MULTI_FILE == SuperClass::type) ? zoom_size_srv
914                                                              : axis->global_zoom_n;
915        int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv
916                                                              : axis->global_zoom_begin;
917
918        if ((0 == zoom_size_srv) && (MULTI_FILE == SuperClass::type)) return;
919
920        std::vector<StdString> dims;
921        StdString axisid = axis->getAxisOutputName();
922        if (isWrittenAxis(axisid)) return ;
923        else setWrittenAxis(axisid);
924
925        try
926        {
927          SuperClassWriter::addDimension(axisid, zoom_size);
928          if (axis->hasValue)
929          {
930            dims.push_back(axisid);
931            SuperClassWriter::addVariable(axisid, NC_FLOAT, dims);
932
933            if (!axis->name.isEmpty())
934              SuperClassWriter::addAttribute("name", axis->name.getValue(), &axisid);
935
936            if (!axis->standard_name.isEmpty())
937              SuperClassWriter::addAttribute("standard_name", axis->standard_name.getValue(), &axisid);
938
939            if (!axis->long_name.isEmpty())
940              SuperClassWriter::addAttribute("long_name", axis->long_name.getValue(), &axisid);
941
942            if (!axis->unit.isEmpty())
943              SuperClassWriter::addAttribute("units", axis->unit.getValue(), &axisid);
944
945            if (!axis->positive.isEmpty())
946            {
947              SuperClassWriter::addAttribute("axis", string("Z"), &axisid);
948              SuperClassWriter::addAttribute("positive",
949                                             (axis->positive == CAxis::positive_attr::up) ? string("up") : string("down"),
950                                             &axisid);
951            }
952
953            StdString axisBoundsId = axisid + "_bounds";
954            if (!axis->bounds.isEmpty())
955            {
956              dims.push_back("axis_nbounds");
957              SuperClassWriter::addVariable(axisBoundsId, NC_FLOAT, dims);
958              SuperClassWriter::addAttribute("bounds", axisBoundsId, &axisid);
959            }
960
961            SuperClassWriter::definition_end();
962
963            switch (SuperClass::type)
964            {
965              case MULTI_FILE:
966              {
967                CArray<double,1> axis_value(zoom_size_srv);
968                for (int i = 0; i < zoom_size_srv; i++) axis_value(i) = axis->value_srv(i);
969                SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
970
971                if (!axis->bounds.isEmpty())
972                  SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0);
973
974                SuperClassWriter::definition_start();
975
976                break;
977              }
978              case ONE_FILE:
979              {
980                CArray<double,1> axis_value(zoom_size_srv);
981                axis_value = axis->value_srv;
982
983                std::vector<StdSize> start(1), startBounds(2) ;
984                std::vector<StdSize> count(1), countBounds(2) ;
985                start[0] = startBounds[0] = zoom_begin_srv-axis->global_zoom_begin;
986                count[0] = countBounds[0] = zoom_size_srv;
987                startBounds[1] = 0;
988                countBounds[1] = 2;
989                SuperClassWriter::writeData(axis_value, axisid, isCollective, 0, &start, &count);
990
991                if (!axis->bounds.isEmpty())
992                  SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0, &startBounds, &countBounds);
993
994                SuperClassWriter::definition_start();
995
996                break;
997              }
998              default :
999                ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)",
1000                      << "[ type = " << SuperClass::type << "]"
1001                      << " not implemented yet !");
1002            }
1003          }
1004        }
1005        catch (CNetCdfException& e)
1006        {
1007          StdString msg("On writing the axis : ");
1008          msg.append(axisid); msg.append("\n");
1009          msg.append("In the context : ");
1010          CContext* context = CContext::getCurrent() ;
1011          msg.append(context->getId()); msg.append("\n");
1012          msg.append(e.what());
1013          ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)", << msg);
1014        }
1015        axis->addRelFile(this->filename);
1016     }
1017
1018     //--------------------------------------------------------------
1019
1020     void CNc4DataOutput::writeGridCompressed_(CGrid* grid)
1021     {
1022       if (grid->isScalarGrid() || grid->isWrittenCompressed(this->filename)) return;
1023
1024       try
1025       {
1026         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1027         std::vector<StdString> domainList = grid->getDomainList();
1028         std::vector<StdString> axisList   = grid->getAxisList();
1029         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1030
1031         std::vector<StdString> dims;
1032
1033         if (grid->isCompressible())
1034         {
1035           StdString varId = grid->getId() + "_points";
1036
1037           int nbIndexes = (SuperClass::type == MULTI_FILE) ? grid->getNumberWrittenIndexes() : grid->getTotalNumberWrittenIndexes();
1038           SuperClassWriter::addDimension(varId, nbIndexes);
1039
1040           dims.push_back(varId);
1041           SuperClassWriter::addVariable(varId, NC_INT, dims);
1042
1043           StdOStringStream compress;
1044           for (int i = numElement - 1; i >= 0; --i)
1045           {
1046             if (axisDomainOrder(i))
1047             {
1048               CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]);
1049               StdString domId = domain->getDomainOutputName();
1050               StdString appendDomId  = singleDomain ? "" : "_" + domId;
1051
1052               switch (domain->type)
1053               {
1054                 case CDomain::type_attr::curvilinear:
1055                   compress << "y" << appendDomId << " x" << appendDomId;
1056                   break;
1057                 case CDomain::type_attr::rectilinear:
1058                   compress << "lat" << appendDomId << " lon" << appendDomId;
1059                   break;
1060                 case CDomain::type_attr::unstructured:
1061                   compress << "cell" << appendDomId;
1062                   break;
1063               }
1064               ++idxDomain;
1065             }
1066             else
1067             {
1068               CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]);
1069               compress << axis->getAxisOutputName();
1070               ++idxAxis;
1071             }
1072
1073             if (i != 0) compress << ' ';
1074           }
1075           SuperClassWriter::addAttribute("compress", compress.str(), &varId);
1076
1077           grid->computeCompressedIndex();
1078
1079           CArray<int, 1> indexes(grid->getNumberWrittenIndexes());
1080           std::map<int, CArray<size_t, 1> >::const_iterator it;
1081           for (it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
1082           {
1083             const CArray<size_t, 1> compressedIndexes = grid->compressedOutIndexFromClient[it->first];
1084             for (int i = 0; i < it->second.numElements(); i++)
1085               indexes(compressedIndexes(i)) = it->second(i);
1086           }
1087
1088           switch (SuperClass::type)
1089           {
1090             case (MULTI_FILE):
1091             {
1092               SuperClassWriter::writeData(indexes, varId, isCollective, 0);
1093               break;
1094             }
1095             case (ONE_FILE):
1096             {
1097               if (grid->doGridHaveDataDistributed())
1098                 grid->getDistributionServer()->computeGlobalIndex(indexes);
1099
1100               std::vector<StdSize> start, count;
1101               start.push_back(grid->getOffsetWrittenIndexes());
1102               count.push_back(grid->getNumberWrittenIndexes());
1103
1104               SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
1105               break;
1106             }
1107           }
1108         }
1109         else
1110         {
1111           for (int i = 0; i < numElement; ++i)
1112           {
1113             StdString varId, compress;
1114             CArray<int, 1> indexes;
1115             bool isDistributed;
1116             StdSize nbIndexes, totalNbIndexes, offset;
1117             int firstGlobalIndex;
1118
1119             if (axisDomainOrder(i))
1120             {
1121               CDomain* domain = CDomain::get(domainList[idxDomain]);
1122               StdString domId = domain->getDomainOutputName();
1123
1124               if (!domain->isCompressible()
1125                    || domain->type == CDomain::type_attr::unstructured
1126                    || domain->isWrittenCompressed(this->filename)
1127                    || isWrittenCompressedDomain(domId))
1128                 continue;
1129
1130               StdString appendDomId  = singleDomain ? "" : "_" + domId;
1131
1132               varId = domId + "_points";
1133               switch (domain->type)
1134               {
1135                 case CDomain::type_attr::curvilinear:
1136                   compress = "y" + appendDomId + " x" + appendDomId;
1137                   break;
1138                 case CDomain::type_attr::rectilinear:
1139                   compress = "lat" + appendDomId + " lon" + appendDomId;
1140                   break;
1141               }
1142
1143               const std::vector<int>& indexesToWrite = domain->getIndexesToWrite();
1144               indexes.resize(indexesToWrite.size());
1145               for (int n = 0; n < indexes.numElements(); ++n)
1146                 indexes(n) = indexesToWrite[n];
1147
1148               isDistributed = domain->isDistributed();
1149               nbIndexes = domain->getNumberWrittenIndexes();
1150               totalNbIndexes = domain->getTotalNumberWrittenIndexes();
1151               offset = domain->getOffsetWrittenIndexes();
1152               firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
1153
1154               domain->addRelFileCompressed(this->filename);
1155               setWrittenCompressedDomain(domId);
1156               ++idxDomain;
1157             }
1158             else
1159             {
1160               CAxis* axis = CAxis::get(axisList[idxAxis]);
1161               StdString axisId = axis->getAxisOutputName();
1162
1163               if (!axis->isCompressible()
1164                    || axis->isWrittenCompressed(this->filename)
1165                    || isWrittenCompressedAxis(axisId))
1166                 continue;
1167
1168               varId = axisId + "_points";
1169               compress = axisId;
1170
1171               const std::vector<int>& indexesToWrite = axis->getIndexesToWrite();
1172               indexes.resize(indexesToWrite.size());
1173               for (int n = 0; n < indexes.numElements(); ++n)
1174                 indexes(n) = indexesToWrite[n];
1175
1176               isDistributed = axis->isDistributed();
1177               nbIndexes = axis->getNumberWrittenIndexes();
1178               totalNbIndexes = axis->getTotalNumberWrittenIndexes();
1179               offset = axis->getOffsetWrittenIndexes();
1180               firstGlobalIndex = axis->begin;
1181
1182               axis->addRelFileCompressed(this->filename);
1183               setWrittenCompressedAxis(axisId);
1184               ++idxAxis;
1185             }
1186
1187             if (!varId.empty())
1188             {
1189               SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
1190
1191               dims.clear();
1192               dims.push_back(varId);
1193               SuperClassWriter::addVariable(varId, NC_INT, dims);
1194
1195               SuperClassWriter::addAttribute("compress", compress, &varId);
1196
1197               switch (SuperClass::type)
1198               {
1199                 case (MULTI_FILE):
1200                 {
1201                   indexes -= firstGlobalIndex;
1202                   SuperClassWriter::writeData(indexes, varId, isCollective, 0);
1203                   break;
1204                 }
1205                 case (ONE_FILE):
1206                 {
1207                   std::vector<StdSize> start, count;
1208                   start.push_back(offset);
1209                   count.push_back(nbIndexes);
1210
1211                   SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
1212                   break;
1213                 }
1214               }
1215             }
1216           }
1217
1218           if (!dims.empty())
1219             grid->computeCompressedIndex();
1220         }
1221
1222         grid->addRelFileCompressed(this->filename);
1223       }
1224       catch (CNetCdfException& e)
1225       {
1226         StdString msg("On writing compressed grid : ");
1227         msg.append(grid->getId()); msg.append("\n");
1228         msg.append("In the context : ");
1229         CContext* context = CContext::getCurrent();
1230         msg.append(context->getId()); msg.append("\n");
1231         msg.append(e.what());
1232         ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
1233       }
1234     }
1235
1236     //--------------------------------------------------------------
1237
1238     void CNc4DataOutput::writeTimeDimension_(void)
1239     {
1240       try
1241       {
1242        SuperClassWriter::addDimension(getTimeCounterName());
1243       }
1244       catch (CNetCdfException& e)
1245       {
1246         StdString msg("On writing time dimension : time_couter\n");
1247         msg.append("In the context : ");
1248         CContext* context = CContext::getCurrent() ;
1249         msg.append(context->getId()); msg.append("\n");
1250         msg.append(e.what());
1251         ERROR("CNc4DataOutput::writeTimeDimension_(void)", << msg);
1252       }
1253     }
1254
1255      //--------------------------------------------------------------
1256
1257      void CNc4DataOutput::writeField_(CField* field)
1258      {
1259         CContext* context = CContext::getCurrent() ;
1260         CContextServer* server=context->server ;
1261
1262         std::vector<StdString> dims, coodinates;
1263         CGrid* grid = field->grid;
1264         if (!grid->doGridHaveDataToWrite())
1265          if (SuperClass::type==MULTI_FILE) return ;
1266
1267         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1268         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1269         std::vector<StdString> domainList = grid->getDomainList();
1270         std::vector<StdString> axisList   = grid->getAxisList();
1271
1272         StdString timeid  = getTimeCounterName();
1273         StdString dimXid,dimYid;
1274         std::deque<StdString> dimIdList, dimCoordList;
1275         bool hasArea = false;
1276         StdString cellMeasures = "area:";
1277         bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
1278
1279         for (int i = 0; i < numElement; ++i)
1280         {
1281           if (axisDomainOrder(i))
1282           {
1283             CDomain* domain = CDomain::get(domainList[idxDomain]);
1284             StdString domId = domain->getDomainOutputName();
1285             StdString appendDomId  = singleDomain ? "" : "_" + domId ;
1286
1287             if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
1288             {
1289               dimIdList.push_back(domId + "_points");
1290               field->setUseCompressedOutput();
1291             }
1292
1293             switch (domain->type)
1294             {
1295               case CDomain::type_attr::curvilinear:
1296                 if (!compressedOutput || !domain->isCompressible())
1297                 {
1298                   dimXid     = StdString("x").append(appendDomId);
1299                   dimIdList.push_back(dimXid);
1300                   dimYid     = StdString("y").append(appendDomId);
1301                   dimIdList.push_back(dimYid);
1302                 }
1303                 dimCoordList.push_back(StdString("nav_lon").append(appendDomId));
1304                 dimCoordList.push_back(StdString("nav_lat").append(appendDomId));
1305                 break ;
1306               case CDomain::type_attr::rectilinear:
1307                 if (!compressedOutput || !domain->isCompressible())
1308                 {
1309                   dimXid     = StdString("lon").append(appendDomId);
1310                   dimIdList.push_back(dimXid);
1311                   dimYid     = StdString("lat").append(appendDomId);
1312                   dimIdList.push_back(dimYid);
1313                 }
1314                 break ;
1315               case CDomain::type_attr::unstructured:
1316               {
1317                                   if (SuperClassWriter::useCFConvention)
1318                                   {
1319                                                dimXid     = StdString("cell").append(appendDomId);
1320                                                dimIdList.push_back(dimXid);
1321                                                dimCoordList.push_back(StdString("lon").append(appendDomId));
1322                                                dimCoordList.push_back(StdString("lat").append(appendDomId));
1323                                        }
1324                                   else
1325                                   {
1326                                                StdString domainName = domain->name;
1327                                                if (domain->nvertex == 1)
1328                                                {
1329                                                        dimXid     = "n" + domainName + "_node";
1330                                                        dimIdList.push_back(dimXid);
1331                                                        dimCoordList.push_back(StdString(domainName + "_node_x"));
1332                                                        dimCoordList.push_back(StdString(domainName + "_node_y"));
1333                                                }
1334                                                else if (domain->nvertex == 2)
1335                                                {
1336                                                        dimXid     = "n" + domainName + "_edge";
1337                                                        dimIdList.push_back(dimXid);
1338                                                        dimCoordList.push_back(StdString(domainName + "_edge_x"));
1339                                                        dimCoordList.push_back(StdString(domainName + "_edge_y"));
1340                                                }
1341                                                else
1342                                                {
1343                                                        dimXid     = "n" + domainName + "_face";
1344                                                        dimIdList.push_back(dimXid);
1345                                                        dimCoordList.push_back(StdString(domainName + "_face_x"));
1346                                                        dimCoordList.push_back(StdString(domainName + "_face_y"));
1347                                                }
1348                                        }  // ugrid convention
1349                                }  // case unstructured domain
1350             }
1351
1352             if (domain->hasArea)
1353             {
1354               hasArea = true;
1355               cellMeasures += " area" + appendDomId;
1356             }
1357             ++idxDomain;
1358           }
1359           else
1360           {
1361             CAxis* axis = CAxis::get(axisList[idxAxis]);
1362             StdString axisId = axis->getAxisOutputName();
1363
1364             if (compressedOutput && axis->isCompressible())
1365             {
1366               dimIdList.push_back(axisId + "_points");
1367               field->setUseCompressedOutput();
1368             }
1369             else
1370               dimIdList.push_back(axisId);
1371
1372             dimCoordList.push_back(axisId);
1373             ++idxAxis;
1374           }
1375         }
1376
1377/*
1378         StdString lonid_loc = (server->intraCommSize > 1)
1379                             ? StdString("lon").append(appendDomid).append("_local")
1380                             : lonid;
1381         StdString latid_loc = (server->intraCommSize > 1)
1382                             ? StdString("lat").append(appendDomid).append("_local")
1383                             : latid;
1384*/
1385         StdString fieldid = field->getFieldOutputName();
1386
1387//         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
1388//         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
1389//          bool isCurvilinear = domain->isCurvilinear ;
1390
1391         nc_type type ;
1392         if (field->prec.isEmpty()) type =  NC_FLOAT ;
1393         else
1394         {
1395           if (field->prec==2) type = NC_SHORT ;
1396           else if (field->prec==4)  type =  NC_FLOAT ;
1397           else if (field->prec==8)   type =  NC_DOUBLE ;
1398         }
1399
1400         bool wtime   = !(!field->operation.isEmpty() && field->getOperationTimeType() == func::CFunctor::once);
1401
1402         if (wtime)
1403         {
1404
1405            //StdOStringStream oss;
1406           // oss << "time_" << field->operation.getValue()
1407           //     << "_" << field->getRelFile()->output_freq.getValue();
1408          //oss
1409            if (field->getOperationTimeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
1410            else if (field->getOperationTimeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
1411            dims.push_back(timeid);
1412         }
1413
1414         if (compressedOutput && grid->isCompressible())
1415         {
1416           dims.push_back(grid->getId() + "_points");
1417           field->setUseCompressedOutput();
1418         }
1419         else
1420         {
1421           while (!dimIdList.empty())
1422           {
1423             dims.push_back(dimIdList.back());
1424             dimIdList.pop_back();
1425           }
1426         }
1427
1428         while (!dimCoordList.empty())
1429         {
1430           coodinates.push_back(dimCoordList.back());
1431           dimCoordList.pop_back();
1432         }
1433
1434         try
1435         {
1436           SuperClassWriter::addVariable(fieldid, type, dims);
1437
1438           if (!field->standard_name.isEmpty())
1439              SuperClassWriter::addAttribute
1440                 ("standard_name",  field->standard_name.getValue(), &fieldid);
1441
1442           if (!field->long_name.isEmpty())
1443              SuperClassWriter::addAttribute
1444                 ("long_name", field->long_name.getValue(), &fieldid);
1445
1446           if (!field->unit.isEmpty())
1447              SuperClassWriter::addAttribute
1448                 ("units", field->unit.getValue(), &fieldid);
1449
1450            if (!field->valid_min.isEmpty())
1451              SuperClassWriter::addAttribute
1452                 ("valid_min", field->valid_min.getValue(), &fieldid);
1453
1454           if (!field->valid_max.isEmpty())
1455              SuperClassWriter::addAttribute
1456                 ("valid_max", field->valid_max.getValue(), &fieldid);
1457
1458            if (!field->scale_factor.isEmpty())
1459              SuperClassWriter::addAttribute
1460                 ("scale_factor", field->scale_factor.getValue(), &fieldid);
1461
1462             if (!field->add_offset.isEmpty())
1463              SuperClassWriter::addAttribute
1464                 ("add_offset", field->add_offset.getValue(), &fieldid);
1465
1466           SuperClassWriter::addAttribute
1467                 ("online_operation", field->operation.getValue(), &fieldid);
1468
1469          // write child variables as attributes
1470
1471
1472           vector<CVariable*> listVars = field->getAllVariables() ;
1473           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ;
1474
1475
1476           if (wtime)
1477           {
1478              CDuration freqOp = field->freq_op.getValue();
1479              freqOp.solveTimeStep(*context->calendar);
1480              StdString freqOpStr = freqOp.toStringUDUnits();
1481              SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
1482
1483              CDuration freqOut = field->getRelFile()->output_freq.getValue();
1484              freqOut.solveTimeStep(*context->calendar);
1485              SuperClassWriter::addAttribute("interval_write", freqOut.toStringUDUnits(), &fieldid);
1486
1487              StdString cellMethods = "time: ";
1488              if (field->operation.getValue() == "instant") cellMethods += "point";
1489              else if (field->operation.getValue() == "average") cellMethods += "mean";
1490              else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
1491              else cellMethods += field->operation;
1492              if (freqOp.resolve(*context->calendar) != freqOut.resolve(*context->calendar))
1493                cellMethods += " (interval: " + freqOpStr + ")";
1494              SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
1495           }
1496
1497           if (hasArea)
1498             SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
1499
1500           if (!field->default_value.isEmpty())
1501           {
1502              double default_value = field->default_value.getValue();
1503              float fdefault_value = (float)default_value;
1504              if (type == NC_DOUBLE)
1505                 SuperClassWriter::setDefaultValue(fieldid, &default_value);
1506              else
1507                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1508           }
1509           else
1510              SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1511
1512            if (field->compression_level.isEmpty())
1513              field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
1514            SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
1515
1516           {  // Ecriture des coordonnes
1517
1518              StdString coordstr; //boost::algorithm::join(coodinates, " ")
1519              std::vector<StdString>::iterator
1520                 itc = coodinates.begin(), endc = coodinates.end();
1521
1522              for (; itc!= endc; itc++)
1523              {
1524                 StdString & coord = *itc;
1525                 if (itc+1 != endc)
1526                       coordstr.append(coord).append(" ");
1527                 else  coordstr.append(coord);
1528              }
1529
1530              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1531
1532           }
1533         }
1534         catch (CNetCdfException& e)
1535         {
1536           StdString msg("On writing field : ");
1537           msg.append(fieldid); msg.append("\n");
1538           msg.append("In the context : ");
1539           msg.append(context->getId()); msg.append("\n");
1540           msg.append(e.what());
1541           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1542         }
1543      }
1544
1545      //--------------------------------------------------------------
1546/*
1547      void CNc4DataOutput::writeField_(CField* field)
1548      {
1549         CContext* context = CContext::getCurrent() ;
1550         CContextServer* server=context->server ;
1551
1552         std::vector<StdString> dims, coodinates;
1553         CGrid* grid = field->grid;
1554         if (!grid->doGridHaveDataToWrite())
1555          if (SuperClass::type==MULTI_FILE) return ;
1556
1557         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1558         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1559         std::vector<StdString> domainList = grid->getDomainList();
1560         std::vector<StdString> axisList   = grid->getAxisList();
1561
1562         StdString timeid  = getTimeCounterName();
1563         StdString dimXid,dimYid;
1564         std::deque<StdString> dimIdList, dimCoordList;
1565         bool hasArea = false;
1566         StdString cellMeasures = "area:";
1567         bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
1568
1569         for (int i = 0; i < numElement; ++i)
1570         {
1571           if (axisDomainOrder(i))
1572           {
1573             CDomain* domain = CDomain::get(domainList[idxDomain]);
1574             StdString domId = domain->getDomainOutputName();
1575             StdString appendDomId  = singleDomain ? "" : "_" + domId ;
1576
1577             if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
1578             {
1579               dimIdList.push_back(domId + "_points");
1580               field->setUseCompressedOutput();
1581             }
1582
1583             switch (domain->type)
1584             {
1585               case CDomain::type_attr::curvilinear:
1586                 if (!compressedOutput || !domain->isCompressible())
1587                 {
1588                   dimXid     = StdString("x").append(appendDomId);
1589                   dimIdList.push_back(dimXid);
1590                   dimYid     = StdString("y").append(appendDomId);
1591                   dimIdList.push_back(dimYid);
1592                 }
1593                 dimCoordList.push_back(StdString("nav_lon").append(appendDomId));
1594                 dimCoordList.push_back(StdString("nav_lat").append(appendDomId));
1595                 break ;
1596               case CDomain::type_attr::rectilinear:
1597                 if (!compressedOutput || !domain->isCompressible())
1598                 {
1599                   dimXid     = StdString("lon").append(appendDomId);
1600                   dimIdList.push_back(dimXid);
1601                   dimYid     = StdString("lat").append(appendDomId);
1602                   dimIdList.push_back(dimYid);
1603                 }
1604                 break ;
1605               case CDomain::type_attr::unstructured:
1606                 dimXid     = StdString("cell").append(appendDomId);
1607                 dimIdList.push_back(dimXid);
1608                 dimCoordList.push_back(StdString("lon").append(appendDomId));
1609                 dimCoordList.push_back(StdString("lat").append(appendDomId));
1610                 break ;
1611             }
1612             if (domain->hasArea)
1613             {
1614               hasArea = true;
1615               cellMeasures += " area" + appendDomId;
1616             }
1617             ++idxDomain;
1618           }
1619           else
1620           {
1621             CAxis* axis = CAxis::get(axisList[idxAxis]);
1622             StdString axisId = axis->getAxisOutputName();
1623
1624             if (compressedOutput && axis->isCompressible())
1625             {
1626               dimIdList.push_back(axisId + "_points");
1627               field->setUseCompressedOutput();
1628             }
1629             else
1630               dimIdList.push_back(axisId);
1631
1632             dimCoordList.push_back(axisId);
1633             ++idxAxis;
1634           }
1635         }
1636
1637
1638//         StdString lonid_loc = (server->intraCommSize > 1)
1639//                             ? StdString("lon").append(appendDomid).append("_local")
1640//                             : lonid;
1641//         StdString latid_loc = (server->intraCommSize > 1)
1642//                             ? StdString("lat").append(appendDomid).append("_local")
1643//                             : latid;
1644
1645         StdString fieldid = field->getFieldOutputName();
1646
1647//         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
1648//         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
1649//          bool isCurvilinear = domain->isCurvilinear ;
1650
1651         nc_type type ;
1652         if (field->prec.isEmpty()) type =  NC_FLOAT ;
1653         else
1654         {
1655           if (field->prec==2) type = NC_SHORT ;
1656           else if (field->prec==4)  type =  NC_FLOAT ;
1657           else if (field->prec==8)   type =  NC_DOUBLE ;
1658         }
1659
1660         bool wtime   = !(!field->operation.isEmpty() && field->getOperationTimeType() == func::CFunctor::once);
1661
1662         if (wtime)
1663         {
1664
1665            //StdOStringStream oss;
1666           // oss << "time_" << field->operation.getValue()
1667           //     << "_" << field->getRelFile()->output_freq.getValue();
1668          //oss
1669            if (field->getOperationTimeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
1670            else if (field->getOperationTimeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
1671            dims.push_back(timeid);
1672         }
1673
1674         if (compressedOutput && grid->isCompressible())
1675         {
1676           dims.push_back(grid->getId() + "_points");
1677           field->setUseCompressedOutput();
1678         }
1679         else
1680         {
1681           while (!dimIdList.empty())
1682           {
1683             dims.push_back(dimIdList.back());
1684             dimIdList.pop_back();
1685           }
1686         }
1687
1688         while (!dimCoordList.empty())
1689         {
1690           coodinates.push_back(dimCoordList.back());
1691           dimCoordList.pop_back();
1692         }
1693
1694         try
1695         {
1696           SuperClassWriter::addVariable(fieldid, type, dims);
1697
1698           if (!field->standard_name.isEmpty())
1699              SuperClassWriter::addAttribute
1700                 ("standard_name",  field->standard_name.getValue(), &fieldid);
1701
1702           if (!field->long_name.isEmpty())
1703              SuperClassWriter::addAttribute
1704                 ("long_name", field->long_name.getValue(), &fieldid);
1705
1706           if (!field->unit.isEmpty())
1707              SuperClassWriter::addAttribute
1708                 ("units", field->unit.getValue(), &fieldid);
1709
1710            if (!field->valid_min.isEmpty())
1711              SuperClassWriter::addAttribute
1712                 ("valid_min", field->valid_min.getValue(), &fieldid);
1713
1714           if (!field->valid_max.isEmpty())
1715              SuperClassWriter::addAttribute
1716                 ("valid_max", field->valid_max.getValue(), &fieldid);
1717
1718            if (!field->scale_factor.isEmpty())
1719              SuperClassWriter::addAttribute
1720                 ("scale_factor", field->scale_factor.getValue(), &fieldid);
1721
1722             if (!field->add_offset.isEmpty())
1723              SuperClassWriter::addAttribute
1724                 ("add_offset", field->add_offset.getValue(), &fieldid);
1725
1726           SuperClassWriter::addAttribute
1727                 ("online_operation", field->operation.getValue(), &fieldid);
1728
1729          // write child variables as attributes
1730
1731
1732           vector<CVariable*> listVars = field->getAllVariables() ;
1733           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ;
1734
1735
1736           if (wtime)
1737           {
1738              CDuration freqOp = field->freq_op.getValue();
1739              freqOp.solveTimeStep(*context->calendar);
1740              StdString freqOpStr = freqOp.toStringUDUnits();
1741              SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
1742
1743              CDuration freqOut = field->getRelFile()->output_freq.getValue();
1744              freqOut.solveTimeStep(*context->calendar);
1745              SuperClassWriter::addAttribute("interval_write", freqOut.toStringUDUnits(), &fieldid);
1746
1747              StdString cellMethods = "time: ";
1748              if (field->operation.getValue() == "instant") cellMethods += "point";
1749              else if (field->operation.getValue() == "average") cellMethods += "mean";
1750              else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
1751              else cellMethods += field->operation;
1752              if (freqOp.resolve(*context->calendar) != freqOut.resolve(*context->calendar))
1753                cellMethods += " (interval: " + freqOpStr + ")";
1754              SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
1755           }
1756
1757           if (hasArea)
1758             SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
1759
1760           if (!field->default_value.isEmpty())
1761           {
1762              double default_value = field->default_value.getValue();
1763              float fdefault_value = (float)default_value;
1764              if (type == NC_DOUBLE)
1765                 SuperClassWriter::setDefaultValue(fieldid, &default_value);
1766              else
1767                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1768           }
1769           else
1770              SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1771
1772            if (field->compression_level.isEmpty())
1773              field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
1774            SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
1775
1776           {  // Ecriture des coordonnes
1777
1778              StdString coordstr; //boost::algorithm::join(coodinates, " ")
1779              std::vector<StdString>::iterator
1780                 itc = coodinates.begin(), endc = coodinates.end();
1781
1782              for (; itc!= endc; itc++)
1783              {
1784                 StdString & coord = *itc;
1785                 if (itc+1 != endc)
1786                       coordstr.append(coord).append(" ");
1787                 else  coordstr.append(coord);
1788              }
1789
1790              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1791
1792           }
1793         }
1794         catch (CNetCdfException& e)
1795         {
1796           StdString msg("On writing field : ");
1797           msg.append(fieldid); msg.append("\n");
1798           msg.append("In the context : ");
1799           msg.append(context->getId()); msg.append("\n");
1800           msg.append(e.what());
1801           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1802         }
1803      }
1804
1805*/
1806      //--------------------------------------------------------------
1807
1808      void CNc4DataOutput::writeFile_ (CFile* file)
1809      {
1810         StdString filename = file->getFileOutputName();
1811         StdString description = (!file->description.isEmpty())
1812                               ? file->description.getValue()
1813                               : StdString("Created by xios");
1814
1815         singleDomain = (file->nbDomains == 1);
1816
1817         try
1818         {
1819                   if (SuperClassWriter::useCFConvention)
1820             this->writeFileAttributes(filename, description,
1821                                       StdString("CF-1.5"),
1822                                       StdString("An IPSL model"),
1823                                       this->getTimeStamp());
1824           else
1825             this->writeFileAttributes(filename, description,
1826                                       StdString("UGRID"),
1827                                       StdString("An IPSL model"),
1828                                       this->getTimeStamp());
1829
1830
1831           if (!appendMode)
1832             SuperClassWriter::addDimension("axis_nbounds", 2);
1833         }
1834         catch (CNetCdfException& e)
1835         {
1836           StdString msg("On writing file : ");
1837           msg.append(filename); msg.append("\n");
1838           msg.append("In the context : ");
1839           CContext* context = CContext::getCurrent() ;
1840           msg.append(context->getId()); msg.append("\n");
1841           msg.append(e.what());
1842           ERROR("CNc4DataOutput::writeFile_ (CFile* file)", << msg);
1843         }
1844      }
1845
1846      void CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)
1847      {
1848        StdString name = var->getVariableOutputName();
1849
1850        try
1851        {
1852          if (var->type.getValue() == CVariable::type_attr::t_int || var->type.getValue() == CVariable::type_attr::t_int32)
1853            addAttribute(name, var->getData<int>(), &fieldId);
1854          else if (var->type.getValue() == CVariable::type_attr::t_int16)
1855            addAttribute(name, var->getData<short int>(), &fieldId);
1856          else if (var->type.getValue() == CVariable::type_attr::t_float)
1857            addAttribute(name, var->getData<float>(), &fieldId);
1858          else if (var->type.getValue() == CVariable::type_attr::t_double)
1859            addAttribute(name, var->getData<double>(), &fieldId);
1860          else if (var->type.getValue() == CVariable::type_attr::t_string)
1861            addAttribute(name, var->getData<string>(), &fieldId);
1862          else
1863            ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)",
1864                  << "Unsupported variable of type " << var->type.getStringValue());
1865        }
1866       catch (CNetCdfException& e)
1867       {
1868         StdString msg("On writing attributes of variable with name : ");
1869         msg.append(name); msg.append("in the field "); msg.append(fieldId); msg.append("\n");
1870         msg.append("In the context : ");
1871         CContext* context = CContext::getCurrent() ;
1872         msg.append(context->getId()); msg.append("\n");
1873         msg.append(e.what());
1874         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)", << msg);
1875       }
1876     }
1877
1878     void CNc4DataOutput::writeAttribute_ (CVariable* var)
1879     {
1880        StdString name = var->getVariableOutputName();
1881
1882        try
1883        {
1884          if (var->type.getValue() == CVariable::type_attr::t_int || var->type.getValue() == CVariable::type_attr::t_int32)
1885            addAttribute(name, var->getData<int>());
1886          else if (var->type.getValue() == CVariable::type_attr::t_int16)
1887            addAttribute(name, var->getData<short int>());
1888          else if (var->type.getValue() == CVariable::type_attr::t_float)
1889            addAttribute(name, var->getData<float>());
1890          else if (var->type.getValue() == CVariable::type_attr::t_double)
1891            addAttribute(name, var->getData<double>());
1892          else if (var->type.getValue() == CVariable::type_attr::t_string)
1893            addAttribute(name, var->getData<string>());
1894          else
1895            ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)",
1896                  << "Unsupported variable of type " << var->type.getStringValue());
1897        }
1898       catch (CNetCdfException& e)
1899       {
1900         StdString msg("On writing attributes of variable with name : ");
1901         msg.append(name); msg.append("\n");
1902         msg.append("In the context : ");
1903         CContext* context = CContext::getCurrent() ;
1904         msg.append(context->getId()); msg.append("\n");
1905         msg.append(e.what());
1906         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)", << msg);
1907       }
1908     }
1909
1910      void CNc4DataOutput::syncFile_ (void)
1911      {
1912        try
1913        {
1914          SuperClassWriter::sync() ;
1915        }
1916        catch (CNetCdfException& e)
1917        {
1918         StdString msg("On synchronizing the write among processes");
1919         msg.append("In the context : ");
1920         CContext* context = CContext::getCurrent() ;
1921         msg.append(context->getId()); msg.append("\n");
1922         msg.append(e.what());
1923         ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1924        }
1925      }
1926
1927      void CNc4DataOutput::closeFile_ (void)
1928      {
1929        try
1930        {
1931          SuperClassWriter::close() ;
1932        }
1933        catch (CNetCdfException& e)
1934        {
1935         StdString msg("On closing file");
1936         msg.append("In the context : ");
1937         CContext* context = CContext::getCurrent() ;
1938         msg.append(context->getId()); msg.append("\n");
1939         msg.append(e.what());
1940         ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1941        }
1942
1943      }
1944
1945      //---------------------------------------------------------------
1946
1947      StdString CNc4DataOutput::getTimeStamp(void) const
1948      {
1949         const int buffer_size = 100;
1950         time_t rawtime;
1951         struct tm * timeinfo = NULL;
1952         char buffer [buffer_size];
1953
1954         time ( &rawtime );
1955         timeinfo = localtime ( &rawtime );
1956         strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
1957
1958         return (StdString(buffer));
1959      }
1960
1961      //---------------------------------------------------------------
1962
1963      void CNc4DataOutput::writeFieldData_ (CField*  field)
1964      {
1965        CContext* context = CContext::getCurrent();
1966        CContextServer* server = context->server;
1967        CGrid* grid = field->grid;
1968
1969        if (!grid->doGridHaveDataToWrite())
1970          if (SuperClass::type == MULTI_FILE || !isCollective) return;
1971
1972        StdString fieldid = field->getFieldOutputName();
1973
1974        StdOStringStream oss;
1975        string timeAxisId;
1976        if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisId = "time_instant";
1977        else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisId = "time_centered";
1978
1979        StdString timeBoundId = getTimeCounterName() + "_bounds";
1980
1981        StdString timeAxisBoundId;
1982        if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisBoundId = "time_instant_bounds";
1983        else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisBoundId = "time_centered_bounds";
1984
1985        if (!field->wasWritten())
1986        {
1987          if (appendMode && field->file->record_offset.isEmpty())
1988          {
1989            field->resetNStep(getRecordFromTime(field->last_Write_srv) + 1);
1990          }
1991
1992          field->setWritten();
1993        }
1994
1995
1996        CArray<double,1> time_data(1);
1997        CArray<double,1> time_data_bound(2);
1998        CArray<double,1> time_counter(1);
1999        CArray<double,1> time_counter_bound(2);
2000
2001        bool wtime = (field->getOperationTimeType() != func::CFunctor::once);
2002
2003        if (wtime)
2004        {
2005          Time lastWrite = field->last_Write_srv;
2006          Time lastLastWrite = field->lastlast_Write_srv;
2007
2008          if (field->getOperationTimeType() == func::CFunctor::instant)
2009            time_data(0) = lastWrite;
2010          else if (field->getOperationTimeType() == func::CFunctor::centered)
2011            time_data(0) = (lastWrite + lastLastWrite) / 2;
2012
2013          if (field->getOperationTimeType() == func::CFunctor::instant)
2014            time_data_bound(0) = time_data_bound(1) = lastWrite;
2015          else if (field->getOperationTimeType() == func::CFunctor::centered)
2016          {
2017            time_data_bound(0) = lastLastWrite;
2018            time_data_bound(1) = lastWrite;
2019          }
2020
2021          if (field->file->time_counter == CFile::time_counter_attr::instant)
2022            time_counter(0) = lastWrite;
2023          else if (field->file->time_counter == CFile::time_counter_attr::centered)
2024            time_counter(0) = (lastWrite + lastLastWrite) / 2;
2025          else if (field->file->time_counter == CFile::time_counter_attr::record)
2026            time_counter(0) = field->getNStep() - 1;
2027
2028
2029          if (field->file->time_counter == CFile::time_counter_attr::instant)
2030            time_counter_bound(0) = time_counter_bound(1) = lastWrite;
2031          else if (field->file->time_counter == CFile::time_counter_attr::centered)
2032          {
2033            time_counter_bound(0) = lastLastWrite;
2034            time_counter_bound(1) = lastWrite;
2035          }
2036          else if (field->file->time_counter == CFile::time_counter_attr::record)
2037            time_counter_bound(0) = time_counter_bound(1) = field->getNStep() - 1;
2038        }
2039
2040         bool isRoot = (server->intraCommRank == 0);
2041
2042         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
2043         {
2044           double scaleFactor = 1.0;
2045           double addOffset = 0.0;
2046           if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
2047           if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
2048           field->scaleFactorAddOffset(scaleFactor, addOffset);
2049         }
2050
2051         try
2052         {
2053           size_t writtenSize;
2054           if (field->getUseCompressedOutput())
2055             writtenSize = grid->getNumberWrittenIndexes();
2056           else
2057             writtenSize = grid->getWrittenDataSize();
2058
2059           CArray<double,1> fieldData(writtenSize);
2060           if (!field->default_value.isEmpty()) fieldData = field->default_value;
2061
2062           if (field->getUseCompressedOutput())
2063             field->outputCompressedField(fieldData);
2064           else
2065             field->outputField(fieldData);
2066
2067           if (!field->prec.isEmpty() && field->prec == 2) fieldData = round(fieldData);
2068
2069           switch (SuperClass::type)
2070           {
2071              case (MULTI_FILE) :
2072              {
2073                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1);
2074                 if (wtime)
2075                 {
2076                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep() - 1);
2077                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1);
2078                   if (field->file->time_counter != CFile::time_counter_attr::none)
2079                   {
2080                     SuperClassWriter::writeData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1);
2081                     if (field->file->time_counter != CFile::time_counter_attr::record)
2082                       SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1);
2083                   }
2084                 }
2085                 break;
2086              }
2087              case (ONE_FILE) :
2088              {
2089                const std::vector<int>& nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
2090                const std::vector<int>& nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
2091                const std::vector<int>& nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
2092
2093                std::vector<StdSize> start, count;
2094
2095                if (field->getUseCompressedOutput())
2096                {
2097                  if (grid->isCompressible())
2098                  {
2099                    start.push_back(grid->getOffsetWrittenIndexes());
2100                    count.push_back(grid->getNumberWrittenIndexes());
2101                  }
2102                  else
2103                  {
2104                    CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
2105                    std::vector<StdString> domainList = grid->getDomainList();
2106                    std::vector<StdString> axisList   = grid->getAxisList();
2107                    int numElement = axisDomainOrder.numElements();
2108                    int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
2109                    int idx = nZoomBeginGlobal.size() - 1;
2110
2111                    start.reserve(nZoomBeginGlobal.size());
2112                    count.reserve(nZoomBeginGlobal.size());
2113
2114
2115                    for (int i = numElement - 1; i >= 0; --i)
2116                    {
2117                      if (axisDomainOrder(i))
2118                      {
2119                        CDomain* domain = CDomain::get(domainList[idxDomain]);
2120
2121                        if (domain->isCompressible())
2122                        {
2123                          start.push_back(domain->getOffsetWrittenIndexes());
2124                          count.push_back(domain->getNumberWrittenIndexes());
2125                          idx -= 2;
2126                        }
2127                        else
2128                        {
2129                          if ((domain->type) != CDomain::type_attr::unstructured)
2130                          {
2131                            start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2132                            count.push_back(nZoomSizeServer[idx]);
2133                          }
2134                          --idx;
2135                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2136                          count.push_back(nZoomSizeServer[idx]);
2137                          --idx;
2138                        }
2139                        --idxDomain;
2140                      }
2141                      else
2142                      {
2143                        CAxis* axis = CAxis::get(axisList[idxAxis]);
2144
2145                        if (axis->isCompressible())
2146                        {
2147                          start.push_back(axis->getOffsetWrittenIndexes());
2148                          count.push_back(axis->getNumberWrittenIndexes());
2149                        }
2150                        else
2151                        {
2152                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2153                          count.push_back(nZoomSizeServer[idx]);
2154                        }
2155
2156                        --idxAxis;
2157                        --idx;
2158                      }
2159                    }
2160                  }
2161                }
2162                else
2163                {
2164
2165                  CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
2166                  std::vector<StdString> domainList = grid->getDomainList();
2167                  std::vector<StdString> axisList   = grid->getAxisList();
2168                  int numElement = axisDomainOrder.numElements();
2169                  int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
2170                  int idx = nZoomBeginGlobal.size() - 1;
2171
2172                  start.reserve(nZoomBeginGlobal.size());
2173                  count.reserve(nZoomBeginGlobal.size());
2174
2175                  for (int i = numElement - 1; i >= 0; --i)
2176                  {
2177                    if (axisDomainOrder(i))
2178                    {
2179                      CDomain* domain = CDomain::get(domainList[idxDomain]);
2180                      if ((domain->type) != CDomain::type_attr::unstructured)
2181                      {
2182                        start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2183                        count.push_back(nZoomSizeServer[idx]);
2184                      }
2185                      --idx ;
2186                      start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2187                      count.push_back(nZoomSizeServer[idx]);
2188                      --idx ;
2189                      --idxDomain;
2190                    }
2191                    else
2192                    {
2193                      start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2194                      count.push_back(nZoomSizeServer[idx]);
2195                      --idx;
2196                     }
2197                  }
2198                }
2199
2200                SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1, &start, &count);
2201                if (wtime)
2202                {
2203                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot);
2204                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot);
2205                   if (field->file->time_counter != CFile::time_counter_attr::none)
2206                   {
2207                     SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1, isRoot);
2208                     if (field->file->time_counter != CFile::time_counter_attr::record)
2209                       SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot);
2210                   }
2211                }
2212
2213                break;
2214              }
2215            }
2216         }
2217         catch (CNetCdfException& e)
2218         {
2219           StdString msg("On writing field data: ");
2220           msg.append(fieldid); msg.append("\n");
2221           msg.append("In the context : ");
2222           msg.append(context->getId()); msg.append("\n");
2223           msg.append(e.what());
2224           ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg);
2225         }
2226      }
2227
2228      //---------------------------------------------------------------
2229
2230      void CNc4DataOutput::writeTimeAxis_
2231                  (CField*    field,
2232                   const boost::shared_ptr<CCalendar> cal)
2233      {
2234         StdOStringStream oss;
2235
2236         if (field->getOperationTimeType() == func::CFunctor::once) return ;
2237
2238//         oss << "time_" << field->operation.getValue()
2239//             << "_" << field->getRelFile()->output_freq.getValue();
2240
2241//         StdString axisid = oss.str();
2242//         if (field->getOperationTimeType() == func::CFunctor::centered) axisid="time_centered" ;
2243//         else if (field->getOperationTimeType() == func::CFunctor::instant) axisid="time_instant" ;
2244
2245         StdString axisid("time_centered") ;
2246         StdString axisBoundId("time_centered_bounds");
2247         StdString timeid(getTimeCounterName());
2248         StdString timeBoundId("axis_nbounds");
2249
2250         if (field->getOperationTimeType() == func::CFunctor::instant)
2251         {
2252            axisid = "time_instant";
2253            axisBoundId = "time_instant_bounds";
2254         }
2255
2256         try
2257         {
2258          // Adding time_instant or time_centered
2259           std::vector<StdString> dims;
2260           dims.push_back(timeid);
2261           if (!SuperClassWriter::varExist(axisid))
2262           {
2263              SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
2264
2265              CDate timeOrigin=cal->getTimeOrigin() ;
2266              StdOStringStream oss2;
2267  //            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" "
2268  //                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ;
2269              StdString strInitdate=oss2.str() ;
2270              StdString strTimeOrigin=timeOrigin.toString() ;
2271              this->writeTimeAxisAttributes
2272                 (axisid, cal->getType(),
2273                  StdString("seconds since ").append(strTimeOrigin),
2274                  strTimeOrigin, axisBoundId);
2275           }
2276
2277           // Adding time_instant_bounds or time_centered_bounds variables
2278           if (!SuperClassWriter::varExist(axisBoundId))
2279           {
2280              dims.clear() ;
2281              dims.push_back(timeid);
2282              dims.push_back(timeBoundId);
2283              SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
2284           }
2285
2286           if (field->file->time_counter != CFile::time_counter_attr::none)
2287           {
2288             // Adding time_counter
2289             axisid = getTimeCounterName();
2290             axisBoundId = getTimeCounterName() + "_bounds";
2291             dims.clear();
2292             dims.push_back(timeid);
2293             if (!SuperClassWriter::varExist(axisid))
2294             {
2295                SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
2296                SuperClassWriter::addAttribute("axis", string("T"), &axisid);
2297
2298                if (field->file->time_counter != CFile::time_counter_attr::record)
2299                {
2300                  CDate timeOrigin = cal->getTimeOrigin();
2301                  StdString strTimeOrigin = timeOrigin.toString();
2302
2303                  this->writeTimeAxisAttributes(axisid, cal->getType(),
2304                                                StdString("seconds since ").append(strTimeOrigin),
2305                                                strTimeOrigin, axisBoundId);
2306                }
2307             }
2308
2309             // Adding time_counter_bound dimension
2310             if (field->file->time_counter != CFile::time_counter_attr::record)
2311             {
2312                if (!SuperClassWriter::varExist(axisBoundId))
2313                {
2314                  dims.clear();
2315                  dims.push_back(timeid);
2316                  dims.push_back(timeBoundId);
2317                  SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
2318                }
2319             }
2320           }
2321         }
2322         catch (CNetCdfException& e)
2323         {
2324           StdString msg("On writing time axis data: ");
2325           msg.append("In the context : ");
2326           CContext* context = CContext::getCurrent() ;
2327           msg.append(context->getId()); msg.append("\n");
2328           msg.append(e.what());
2329           ERROR("CNc4DataOutput::writeTimeAxis_ (CField*    field, \
2330                  const boost::shared_ptr<CCalendar> cal)", << msg);
2331         }
2332      }
2333
2334      //---------------------------------------------------------------
2335
2336      void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
2337                                                   const StdString & calendar,
2338                                                   const StdString & units,
2339                                                   const StdString & time_origin,
2340                                                   const StdString & time_bounds,
2341                                                   const StdString & standard_name,
2342                                                   const StdString & long_name)
2343      {
2344         try
2345         {
2346           SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
2347           SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name);
2348           SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name);
2349           SuperClassWriter::addAttribute("units",         units        , &axis_name);
2350           SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name);
2351           SuperClassWriter::addAttribute("bounds",        time_bounds  , &axis_name);
2352         }
2353         catch (CNetCdfException& e)
2354         {
2355           StdString msg("On writing time axis Attribute: ");
2356           msg.append("In the context : ");
2357           CContext* context = CContext::getCurrent() ;
2358           msg.append(context->getId()); msg.append("\n");
2359           msg.append(e.what());
2360           ERROR("CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, \
2361                                                          const StdString & calendar,\
2362                                                          const StdString & units, \
2363                                                          const StdString & time_origin, \
2364                                                          const StdString & time_bounds, \
2365                                                          const StdString & standard_name, \
2366                                                          const StdString & long_name)", << msg);
2367         }
2368      }
2369
2370      //---------------------------------------------------------------
2371
2372      void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
2373                                               const StdString & axis,
2374                                               const StdString & standard_name,
2375                                               const StdString & long_name,
2376                                               const StdString & units,
2377                                               const StdString & nav_model)
2378      {
2379         try
2380         {
2381          if (!axis.empty())
2382            SuperClassWriter::addAttribute("axis"       , axis         , &axis_name);
2383
2384          SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
2385          SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name);
2386          SuperClassWriter::addAttribute("units"        , units        , &axis_name);
2387          SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name);
2388         }
2389         catch (CNetCdfException& e)
2390         {
2391           StdString msg("On writing Axis Attribute: ");
2392           msg.append("In the context : ");
2393           CContext* context = CContext::getCurrent() ;
2394           msg.append(context->getId()); msg.append("\n");
2395           msg.append(e.what());
2396           ERROR("CNc4DataOutput::writeAxisAttributes(const StdString & axis_name, \
2397                                                      const StdString & axis, \
2398                                                      const StdString & standard_name, \
2399                                                      const StdString & long_name, \
2400                                                      const StdString & units, \
2401                                                      const StdString & nav_model)", << msg);
2402         }
2403      }
2404
2405      //---------------------------------------------------------------
2406
2407      void CNc4DataOutput::writeLocalAttributes
2408         (int ibegin, int ni, int jbegin, int nj, StdString domid)
2409      {
2410        try
2411        {
2412         SuperClassWriter::addAttribute(StdString("ibegin").append(domid), ibegin);
2413         SuperClassWriter::addAttribute(StdString("ni"    ).append(domid), ni);
2414         SuperClassWriter::addAttribute(StdString("jbegin").append(domid), jbegin);
2415         SuperClassWriter::addAttribute(StdString("nj"    ).append(domid), nj);
2416        }
2417        catch (CNetCdfException& e)
2418        {
2419           StdString msg("On writing Local Attributes: ");
2420           msg.append("In the context : ");
2421           CContext* context = CContext::getCurrent() ;
2422           msg.append(context->getId()); msg.append("\n");
2423           msg.append(e.what());
2424           ERROR("CNc4DataOutput::writeLocalAttributes \
2425                  (int ibegin, int ni, int jbegin, int nj, StdString domid)", << msg);
2426        }
2427
2428      }
2429
2430      void CNc4DataOutput::writeLocalAttributes_IOIPSL(const StdString& dimXid, const StdString& dimYid,
2431                                                       int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)
2432      {
2433         CArray<int,1> array(2) ;
2434
2435         try
2436         {
2437           SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ;
2438           SuperClassWriter::addAttribute("DOMAIN_number", rank) ;
2439           array = SuperClassWriter::getDimension(dimXid) + 1, SuperClassWriter::getDimension(dimYid) + 1;
2440           SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ;
2441           array=ni_glo,nj_glo ;
2442           SuperClassWriter::addAttribute("DOMAIN_size_global", array) ;
2443           array=ni,nj ;
2444           SuperClassWriter::addAttribute("DOMAIN_size_local", array) ;
2445           array=ibegin+1,jbegin+1 ;
2446           SuperClassWriter::addAttribute("DOMAIN_position_first", array) ;
2447           array=ibegin+ni-1+1,jbegin+nj-1+1 ;
2448           SuperClassWriter::addAttribute("DOMAIN_position_last",array) ;
2449           array=0,0 ;
2450           SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ;
2451           SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array);
2452           SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ;
2453  /*
2454           SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ;
2455           SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ;
2456           SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ;
2457           SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ;
2458  */
2459         }
2460         catch (CNetCdfException& e)
2461         {
2462           StdString msg("On writing Local Attributes IOIPSL \n");
2463           msg.append("In the context : ");
2464           CContext* context = CContext::getCurrent() ;
2465           msg.append(context->getId()); msg.append("\n");
2466           msg.append(e.what());
2467           ERROR("CNc4DataOutput::writeLocalAttributes_IOIPSL \
2468                  (int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)", << msg);
2469         }
2470      }
2471      //---------------------------------------------------------------
2472
2473      void CNc4DataOutput:: writeFileAttributes(const StdString & name,
2474                                                const StdString & description,
2475                                                const StdString & conventions,
2476                                                const StdString & production,
2477                                                const StdString & timeStamp)
2478      {
2479         try
2480         {
2481           SuperClassWriter::addAttribute("name"       , name);
2482           SuperClassWriter::addAttribute("description", description);
2483           SuperClassWriter::addAttribute("title"      , description);
2484           SuperClassWriter::addAttribute("Conventions", conventions);
2485           SuperClassWriter::addAttribute("production" , production);
2486           SuperClassWriter::addAttribute("timeStamp"  , timeStamp);
2487         }
2488         catch (CNetCdfException& e)
2489         {
2490           StdString msg("On writing File Attributes \n ");
2491           msg.append("In the context : ");
2492           CContext* context = CContext::getCurrent() ;
2493           msg.append(context->getId()); msg.append("\n");
2494           msg.append(e.what());
2495           ERROR("CNc4DataOutput:: writeFileAttributes(const StdString & name, \
2496                                                const StdString & description, \
2497                                                const StdString & conventions, \
2498                                                const StdString & production, \
2499                                                const StdString & timeStamp)", << msg);
2500         }
2501      }
2502
2503      //---------------------------------------------------------------
2504
2505      void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
2506                                               int data_dim,
2507                                               int data_ni,
2508                                               int data_nj,
2509                                               int data_ibegin,
2510                                               int data_jbegin)
2511      {
2512         try
2513         {
2514           SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name);
2515           SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name);
2516           SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name);
2517           SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
2518           SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
2519         }
2520         catch (CNetCdfException& e)
2521         {
2522           StdString msg("On writing Mask Attributes \n ");
2523           msg.append("In the context : ");
2524           CContext* context = CContext::getCurrent() ;
2525           msg.append(context->getId()); msg.append("\n");
2526           msg.append(e.what());
2527           ERROR("CNc4DataOutput::writeMaskAttributes(const StdString & mask_name, \
2528                                               int data_dim, \
2529                                               int data_ni, \
2530                                               int data_nj, \
2531                                               int data_ibegin, \
2532                                               int data_jbegin)", << msg);
2533         }
2534      }
2535
2536      ///--------------------------------------------------------------
2537
2538      StdSize CNc4DataOutput::getRecordFromTime(Time time)
2539      {
2540        std::map<Time, StdSize>::const_iterator it = timeToRecordCache.find(time);
2541        if (it == timeToRecordCache.end())
2542        {
2543          StdString timeAxisBoundsId(getTimeCounterName() + "_bounds");
2544          if (!SuperClassWriter::varExist(timeAxisBoundsId))
2545            timeAxisBoundsId = "time_instant_bounds";
2546
2547          CArray<double,2> timeAxisBounds;
2548          SuperClassWriter::getTimeAxisBounds(timeAxisBounds, timeAxisBoundsId, isCollective);
2549
2550          StdSize record = 0;
2551          double dtime(time);
2552          for (int n = timeAxisBounds.extent(1) - 1; n >= 0; n--)
2553          {
2554            if (timeAxisBounds(1, n) < dtime)
2555            {
2556              record = n + 1;
2557              break;
2558            }
2559          }
2560          it = timeToRecordCache.insert(std::make_pair(time, record)).first;
2561        }
2562        return it->second;
2563      }
2564
2565      ///--------------------------------------------------------------
2566
2567      bool CNc4DataOutput::isWrittenDomain(const std::string& domainName) const
2568      {
2569        return (this->writtenDomains.find(domainName) != this->writtenDomains.end());
2570      }
2571
2572      bool CNc4DataOutput::isWrittenCompressedDomain(const std::string& domainName) const
2573      {
2574        return (this->writtenCompressedDomains.find(domainName) != this->writtenCompressedDomains.end());
2575      }
2576
2577      bool CNc4DataOutput::isWrittenAxis(const std::string& axisName) const
2578      {
2579        return (this->writtenAxis.find(axisName) != this->writtenAxis.end());
2580      }
2581
2582      bool CNc4DataOutput::isWrittenCompressedAxis(const std::string& axisName) const
2583      {
2584        return (this->writtenCompressedAxis.find(axisName) != this->writtenCompressedAxis.end());
2585      }
2586
2587      void CNc4DataOutput::setWrittenDomain(const std::string& domainName)
2588      {
2589        this->writtenDomains.insert(domainName);
2590      }
2591
2592      void CNc4DataOutput::setWrittenCompressedDomain(const std::string& domainName)
2593      {
2594        this->writtenCompressedDomains.insert(domainName);
2595      }
2596
2597      void CNc4DataOutput::setWrittenAxis(const std::string& axisName)
2598      {
2599        this->writtenAxis.insert(axisName);
2600      }
2601
2602      void CNc4DataOutput::setWrittenCompressedAxis(const std::string& axisName)
2603      {
2604        this->writtenCompressedAxis.insert(axisName);
2605      }
2606} // namespace xios
Note: See TracBrowser for help on using the repository browser.