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

Last change on this file since 796 was 796, checked in by mhnguyen, 8 years ago

Fixing minor bug on writing axis_bounds

+) Use the correct start and count for axis bounds

Test
+) On Curie
+) test with NEMO passed

  • 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: 82.9 KB
Line 
1
2#include "nc4_data_output.hpp"
3
4#include <boost/lexical_cast.hpp>
5#include "attribute_template.hpp"
6#include "group_template.hpp"
7
8#include "file.hpp"
9#include "calendar.hpp"
10#include "context.hpp"
11#include "context_server.hpp"
12#include "netCdfException.hpp"
13#include "exception.hpp"
14
15namespace xios
16{
17      /// ////////////////////// Définitions ////////////////////// ///
18      CNc4DataOutput::CNc4DataOutput
19         (const StdString & filename, bool exist)
20            : SuperClass()
21            , SuperClassWriter(filename, exist)
22            , filename(filename)
23      {
24         StdString timeid = StdString("time_counter");
25         SuperClass::type = MULTI_FILE;
26      }
27
28      CNc4DataOutput::CNc4DataOutput
29         (const StdString & filename, bool exist, bool useClassicFormat,
30          MPI_Comm comm_file,bool multifile, bool isCollective)
31            : SuperClass()
32            , SuperClassWriter(filename, exist, useClassicFormat, &comm_file, multifile)
33            , comm_file(comm_file)
34            , filename(filename)
35            , isCollective(isCollective)
36      {
37         StdString timeid = StdString("time_counter");
38
39         SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE;
40      }
41
42
43      CNc4DataOutput::~CNc4DataOutput(void)
44      { /* Ne rien faire de plus */ }
45
46      ///--------------------------------------------------------------
47
48      const StdString & CNc4DataOutput::getFileName(void) const
49      {
50         return (this->filename);
51      }
52
53      //---------------------------------------------------------------
54
55      void CNc4DataOutput::writeDomain_(CDomain* domain)
56      {
57         if (domain->type == CDomain::type_attr::unstructured)
58         {
59           writeUnstructuredDomain(domain) ;
60           return ;
61         }
62
63         CContext* context = CContext::getCurrent() ;
64         CContextServer* server=context->server ;
65
66         if (domain->IsWritten(this->filename)) return;
67         domain->checkAttributes();
68
69         if (domain->isEmpty())
70           if (SuperClass::type==MULTI_FILE) return ;
71
72         std::vector<StdString> dim0, dim1;
73         StdString domid = domain->getDomainOutputName();
74         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
75         if (isWrittenDomain(domid)) return ;
76         else setWrittenDomain(domid);
77
78
79         StdString dimXid, dimYid ;
80
81         bool isRegularDomain = (domain->type == CDomain::type_attr::rectilinear);
82         switch (domain->type)
83         {
84           case CDomain::type_attr::curvilinear :
85             dimXid     = StdString("x").append(appendDomid);
86             dimYid     = StdString("y").append(appendDomid);
87             break ;
88           case CDomain::type_attr::rectilinear :
89             dimXid     = StdString("lon").append(appendDomid);
90             dimYid     = StdString("lat").append(appendDomid);
91             break;
92         }
93
94         StdString dimVertId = StdString("nvertex").append(appendDomid);
95
96         string lonid,latid,bounds_lonid,bounds_latid ;
97         string areaId = "area" + appendDomid;
98/*
99         StdString lonid_loc = (server->intraCommSize > 1)
100                             ? StdString("lon").append(appendDomid).append("_local")
101                             : lonid;
102         StdString latid_loc = (server->intraCommSize > 1)
103                             ? StdString("lat").append(appendDomid).append("_local")
104                             : latid;
105*/
106
107         try
108         {
109           switch (SuperClass::type)
110           {
111              case (MULTI_FILE) :
112              {
113  //               if (domain->isEmpty()) return;
114
115                 if (server->intraCommSize > 1)
116                 {
117  //                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
118  //                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
119                 }
120
121                 switch (domain->type)
122                 {
123                   case CDomain::type_attr::curvilinear :
124                     dim0.push_back(dimYid); dim0.push_back(dimXid);
125                     lonid = StdString("nav_lon").append(appendDomid);
126                     latid = StdString("nav_lat").append(appendDomid);
127                     break ;
128                   case CDomain::type_attr::rectilinear :
129                     lonid = StdString("lon").append(appendDomid);
130                     latid = StdString("lat").append(appendDomid);
131                     dim0.push_back(dimYid);
132                     dim1.push_back(dimXid);
133                     break;
134                 }
135
136                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
137                 bounds_latid = StdString("bounds_lat").append(appendDomid);
138
139                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
140                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv);
141
142                 if (domain->hasBounds)
143                   SuperClassWriter::addDimension(dimVertId, domain->nvertex);
144
145                 if (server->intraCommSize > 1)
146                 {
147                   this->writeLocalAttributes(domain->zoom_ibegin_srv,
148                                              domain->zoom_ni_srv,
149                                              domain->zoom_jbegin_srv,
150                                              domain->zoom_nj_srv,
151                                              appendDomid);
152
153                   if (singleDomain)
154                    this->writeLocalAttributes_IOIPSL(dimXid, dimYid,
155                                                      domain->zoom_ibegin_srv,
156                                                      domain->zoom_ni_srv,
157                                                      domain->zoom_jbegin_srv,
158                                                      domain->zoom_nj_srv,
159                                                      domain->ni_glo,domain->nj_glo,
160                                                      server->intraCommRank,server->intraCommSize);
161                 }
162
163                 if (domain->hasLonLat)
164                 {
165                   switch (domain->type)
166                   {
167                     case CDomain::type_attr::curvilinear :
168                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
169                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
170                       break ;
171                      case CDomain::type_attr::rectilinear :
172                        SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
173                        SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
174                        break ;
175                   }
176
177                   this->writeAxisAttributes(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
178                   this->writeAxisAttributes(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
179
180                   if (domain->hasBounds)
181                   {
182                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
183                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
184
185                     dim0.clear();
186                     dim0.push_back(dimYid);
187                     dim0.push_back(dimXid);
188                     dim0.push_back(dimVertId);
189                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
190                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
191                   }
192                 }
193
194                 dim0.clear();
195                 dim0.push_back(dimYid);
196                 dim0.push_back(dimXid);
197
198
199  // supress mask               if (server->intraCommSize > 1)
200  // supress mask               {
201  // supress mask                  SuperClassWriter::addVariable(maskid, NC_INT, dim0);
202  // supress mask
203  // supress mask                  this->writeMaskAttributes(maskid,
204  // supress mask                     domain->data_dim.getValue()/*,
205  // supress mask                     domain->data_ni.getValue(),
206  // supress mask                     domain->data_nj.getValue(),
207  // supress mask                     domain->data_ibegin.getValue(),
208  // supress mask                     domain->data_jbegin.getValue()*/);
209  // supress mask               }
210
211                 //SuperClassWriter::setDefaultValue(maskid, &dvm);
212
213                 if (domain->hasArea)
214                 {
215                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
216                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
217                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
218                 }
219
220                 SuperClassWriter::definition_end();
221
222                 if (domain->hasLonLat)
223                 {
224                   switch (domain->type)
225                   {
226                     case CDomain::type_attr::curvilinear :
227                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
228                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
229                       break;
230                     case CDomain::type_attr::rectilinear :
231                       CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
232                       SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
233                       CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
234                       SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0);
235                       break;
236                   }
237
238                   if (domain->hasBounds)
239                   {
240                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
241                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
242                   }
243                 }
244
245                 if (domain->hasArea)
246                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
247
248                 SuperClassWriter::definition_start();
249
250                 break;
251              }
252              case (ONE_FILE) :
253              {
254                 SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni);
255                 SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj);
256
257                 if (domain->hasBounds)
258                   SuperClassWriter::addDimension(dimVertId, domain->nvertex);
259
260                 if (domain->hasLonLat)
261                 {
262                   switch (domain->type)
263                   {
264                     case CDomain::type_attr::curvilinear :
265                       dim0.push_back(dimYid); dim0.push_back(dimXid);
266                       lonid = StdString("nav_lon").append(appendDomid);
267                       latid = StdString("nav_lat").append(appendDomid);
268                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
269                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
270                       break;
271
272                     case CDomain::type_attr::rectilinear :
273                       dim0.push_back(dimYid);
274                       dim1.push_back(dimXid);
275                       lonid = StdString("lon").append(appendDomid);
276                       latid = StdString("lat").append(appendDomid);
277                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
278                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
279                       break;
280                   }
281
282                   bounds_lonid = StdString("bounds_lon").append(appendDomid);
283                   bounds_latid = StdString("bounds_lat").append(appendDomid);
284
285                   this->writeAxisAttributes
286                      (lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
287                   this->writeAxisAttributes
288                      (latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
289
290                   if (domain->hasBounds)
291                   {
292                     SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
293                     SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
294
295                     dim0.clear();
296                     dim0.push_back(dimYid);
297                     dim0.push_back(dimXid);
298                     dim0.push_back(dimVertId);
299                     SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
300                     SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
301                   }
302                 }
303
304                 if (domain->hasArea)
305                 {
306                   dim0.clear();
307                   dim0.push_back(dimYid); dim0.push_back(dimXid);
308                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
309                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
310                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
311                   dim0.clear();
312                 }
313
314                 SuperClassWriter::definition_end();
315
316                 switch (domain->type)
317                 {
318                   case CDomain::type_attr::curvilinear :
319                   {
320                     std::vector<StdSize> start(2) ;
321                     std::vector<StdSize> count(2) ;
322                     if (domain->isEmpty())
323                     {
324                       start[0]=0 ; start[1]=0 ;
325                       count[0]=0 ; count[1]=0 ;
326                     }
327                     else
328                     {
329                       start[1]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
330                       start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
331                       count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
332                     }
333
334                     if (domain->hasLonLat)
335                     {
336                       SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
337                       SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
338                     }
339                     break;
340                   }
341                   case CDomain::type_attr::rectilinear :
342                   {
343                     if (domain->hasLonLat)
344                     {
345                       std::vector<StdSize> start(1) ;
346                       std::vector<StdSize> count(1) ;
347                       if (domain->isEmpty())
348                       {
349                         start[0]=0 ;
350                         count[0]=0 ;
351                         SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
352                         SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
353
354                       }
355                       else
356                       {
357                         start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
358                         count[0]=domain->zoom_nj_srv ;
359                         CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
360                         SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
361
362                         start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
363                         count[0]=domain->zoom_ni_srv ;
364                         CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
365                         SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
366                       }
367                     }
368                     break;
369                   }
370                 }
371
372                 if (domain->hasBounds)
373                 {
374                   std::vector<StdSize> start(3);
375                   std::vector<StdSize> count(3);
376                   if (domain->isEmpty())
377                   {
378                     start[2] = start[1] = start[0] = 0;
379                     count[2] = count[1] = count[0] = 0;
380                   }
381                   else
382                   {
383                     start[2] = 0;
384                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
385                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
386                     count[2] = domain->nvertex;
387                     count[1] = domain->zoom_ni_srv;
388                     count[0] = domain->zoom_nj_srv;
389                   }
390
391                   SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0, &start, &count);
392                   SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0, &start, &count);
393                 }
394
395                 if (domain->hasArea)
396                 {
397                   std::vector<StdSize> start(2);
398                   std::vector<StdSize> count(2);
399
400                   if (domain->isEmpty())
401                   {
402                     start[0] = 0; start[1] = 0;
403                     count[0] = 0; count[1] = 0;
404                   }
405                   else
406                   {
407                     start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
408                     start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
409                     count[1] = domain->zoom_ni_srv;
410                     count[0] = domain->zoom_nj_srv;
411                   }
412
413                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
414                 }
415
416                 SuperClassWriter::definition_start();
417                 break;
418              }
419              default :
420                 ERROR("CNc4DataOutput::writeDomain(domain)",
421                       << "[ type = " << SuperClass::type << "]"
422                       << " not implemented yet !");
423           }
424         }
425         catch (CNetCdfException& e)
426         {
427           StdString msg("On writing the domain : ");
428           msg.append(domid); msg.append("\n");
429           msg.append("In the context : ");
430           msg.append(context->getId()); msg.append("\n");
431           msg.append(e.what());
432           ERROR("CNc4DataOutput::writeDomain_(CDomain* domain)", << msg);
433         }
434
435         domain->addRelFile(this->filename);
436      }
437
438      void CNc4DataOutput::writeUnstructuredDomain(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
446         if (domain->isEmpty())
447           if (SuperClass::type==MULTI_FILE) return ;
448
449         std::vector<StdString> dim0, dim1;
450         StdString domid = domain->getDomainOutputName();
451         if (isWrittenDomain(domid)) return ;
452         else setWrittenDomain(domid);
453
454         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
455
456
457         StdString dimXid = StdString("cell").append(appendDomid);
458         StdString dimVertId = StdString("nvertex").append(appendDomid);
459
460         string lonid,latid,bounds_lonid,bounds_latid ;
461         string areaId = "area" + appendDomid;
462
463         try
464         {
465           switch (SuperClass::type)
466           {
467              case (MULTI_FILE) :
468              {
469                 dim0.push_back(dimXid);
470                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
471
472                 lonid = StdString("lon").append(appendDomid);
473                 latid = StdString("lat").append(appendDomid);
474                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
475                 bounds_latid = StdString("bounds_lat").append(appendDomid);
476                 if (domain->hasLonLat)
477                 {
478                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
479                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
480                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
481                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
482                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
483                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
484                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
485                 }
486
487                 dim0.clear();
488                 if (domain->hasBounds)
489                 {
490                   dim0.push_back(dimXid);
491                   dim0.push_back(dimVertId);
492                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
493                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
494                 }
495
496                 dim0.clear();
497                 dim0.push_back(dimXid);
498                 if (domain->hasArea)
499                 {
500                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
501                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
502                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
503                 }
504
505                 SuperClassWriter::definition_end();
506
507                 if (domain->hasLonLat)
508                 {
509                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
510                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
511                   if (domain->hasBounds)
512                   {
513                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
514                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
515                   }
516                 }
517
518                 if (domain->hasArea)
519                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
520
521                 SuperClassWriter::definition_start();
522                 break ;
523              }
524
525              case (ONE_FILE) :
526              {
527                 lonid = StdString("lon").append(appendDomid);
528                 latid = StdString("lat").append(appendDomid);
529                 bounds_lonid = StdString("bounds_lon").append(appendDomid);
530                 bounds_latid = StdString("bounds_lat").append(appendDomid);
531                 dim0.push_back(dimXid);
532                 SuperClassWriter::addDimension(dimXid, domain->ni_glo);
533                 if (domain->hasLonLat)
534                 {
535                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
536                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
537
538                   this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
539                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
540                   this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
541                   if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
542                   if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
543                 }
544                 dim0.clear();
545
546                 if (domain->hasBounds)
547                 {
548                   dim0.push_back(dimXid);
549                   dim0.push_back(dimVertId);
550                   SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
551                   SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
552                 }
553
554                 if (domain->hasArea)
555                 {
556                   dim0.clear();
557                   dim0.push_back(dimXid);
558                   SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
559                   SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
560                   SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
561                 }
562
563                 SuperClassWriter::definition_end();
564
565                 std::vector<StdSize> start(1), startBounds(2) ;
566                 std::vector<StdSize> count(1), countBounds(2) ;
567                 if (domain->isEmpty())
568                 {
569                   start[0]=0 ;
570                   count[0]=0 ;
571                   startBounds[1]=0 ;
572                   countBounds[1]=domain->nvertex ;
573                   startBounds[0]=0 ;
574                   countBounds[0]=0 ;
575                 }
576                 else
577                 {
578                   start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
579                   count[0]=domain->zoom_ni_srv ;
580                   startBounds[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
581                   startBounds[1]=0 ;
582                   countBounds[0]=domain->zoom_ni_srv ;
583                   countBounds[1]=domain->nvertex ;
584                 }
585
586                 if (domain->hasLonLat)
587                 {
588                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
589                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
590                   if (domain->hasBounds)
591                   {
592                     SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
593                     SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds);
594                   }
595                 }
596
597                 if (domain->hasArea)
598                   SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
599
600                 SuperClassWriter::definition_start();
601
602                 break;
603              }
604              default :
605                 ERROR("CNc4DataOutput::writeDomain(domain)",
606                       << "[ type = " << SuperClass::type << "]"
607                       << " not implemented yet !");
608           }
609         }
610         catch (CNetCdfException& e)
611         {
612           StdString msg("On writing the domain : ");
613           msg.append(domid); msg.append("\n");
614           msg.append("In the context : ");
615           msg.append(context->getId()); msg.append("\n");
616           msg.append(e.what());
617           ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
618         }
619         domain->addRelFile(this->filename);
620      }
621      //--------------------------------------------------------------
622
623      void CNc4DataOutput::writeAxis_(CAxis* axis)
624      {
625        if (axis->IsWritten(this->filename)) return;
626        axis->checkAttributes();
627        int zoom_size_srv  = axis->zoom_size_srv;
628        int zoom_begin_srv = axis->zoom_begin_srv;
629        int zoom_size  = (MULTI_FILE == SuperClass::type) ? zoom_size_srv
630                                                              : axis->global_zoom_size;
631        int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv
632                                                              : axis->global_zoom_begin;
633
634        if ((0 == zoom_size_srv) && (MULTI_FILE == SuperClass::type)) return;
635
636        std::vector<StdString> dims;
637        StdString axisid = axis->getAxisOutputName();
638        if (isWrittenAxis(axisid)) return ;
639        else setWrittenAxis(axisid);
640
641        try
642        {
643          SuperClassWriter::addDimension(axisid, zoom_size);
644          dims.push_back(axisid);
645          SuperClassWriter::addVariable(axisid, NC_FLOAT, dims);
646
647          if (!axis->name.isEmpty())
648            SuperClassWriter::addAttribute("name", axis->name.getValue(), &axisid);
649
650          if (!axis->standard_name.isEmpty())
651            SuperClassWriter::addAttribute("standard_name", axis->standard_name.getValue(), &axisid);
652
653          if (!axis->long_name.isEmpty())
654            SuperClassWriter::addAttribute("long_name", axis->long_name.getValue(), &axisid);
655
656          if (!axis->unit.isEmpty())
657            SuperClassWriter::addAttribute("units", axis->unit.getValue(), &axisid);
658
659          if (!axis->positive.isEmpty())
660          {
661            SuperClassWriter::addAttribute("axis", string("Z"), &axisid);
662            SuperClassWriter::addAttribute("positive",
663                                           (axis->positive == CAxis::positive_attr::up) ? string("up") : string("down"),
664                                           &axisid);
665          }
666
667          StdString axisBoundsId = axisid + "_bounds";
668          if (!axis->bounds.isEmpty())
669          {
670            dims.push_back("axis_nbounds");
671            SuperClassWriter::addVariable(axisBoundsId, NC_FLOAT, dims);
672            SuperClassWriter::addAttribute("bounds", axisBoundsId, &axisid);
673          }
674
675          SuperClassWriter::definition_end();
676          switch (SuperClass::type)
677          {
678            case MULTI_FILE:
679            {
680              CArray<double,1> axis_value(zoom_size_srv);
681              for (int i = 0; i < zoom_size_srv; i++) axis_value(i) = axis->value_srv(i);
682              SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
683
684              if (!axis->bounds.isEmpty())
685                SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0);
686
687              SuperClassWriter::definition_start();
688
689              break;
690            }
691            case ONE_FILE:
692            {
693              CArray<double,1> axis_value(zoom_size_srv);
694              axis_value = axis->value_srv;
695
696              std::vector<StdSize> start(1), startBounds(2) ;
697              std::vector<StdSize> count(1), countBounds(2) ;
698              start[0] = startBounds[0] = zoom_begin_srv-axis->global_zoom_begin;
699              count[0] = countBounds[0] = zoom_size_srv;
700              startBounds[1] = 0;
701              countBounds[1] = 2;
702              SuperClassWriter::writeData(axis_value, axisid, isCollective, 0, &start, &count);
703
704              if (!axis->bounds.isEmpty())
705                SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0, &startBounds, &countBounds);
706
707              SuperClassWriter::definition_start();
708
709              break;
710            }
711            default :
712              ERROR("CNc4DataOutput::writeDomain(domain)",
713                    << "[ type = " << SuperClass::type << "]"
714                    << " not implemented yet !");
715          }
716        }
717        catch (CNetCdfException& e)
718        {
719          StdString msg("On writing the axis : ");
720          msg.append(axisid); msg.append("\n");
721          msg.append("In the context : ");
722          CContext* context = CContext::getCurrent() ;
723          msg.append(context->getId()); msg.append("\n");
724          msg.append(e.what());
725          ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)", << msg);
726        }
727        axis->addRelFile(this->filename);
728     }
729
730     //--------------------------------------------------------------
731
732     void CNc4DataOutput::writeGridCompressed_(CGrid* grid)
733     {
734       if (grid->isScalarGrid() || grid->isWrittenCompressed(this->filename)) return;
735
736       try
737       {
738         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
739         std::vector<StdString> domainList = grid->getDomainList();
740         std::vector<StdString> axisList   = grid->getAxisList();
741         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
742
743         std::vector<StdString> dims;
744
745         if (grid->isCompressible())
746         {
747           StdString varId = grid->getId() + "_points";
748
749           int nbIndexes = (SuperClass::type == MULTI_FILE) ? grid->getNumberWrittenIndexes() : grid->getTotalNumberWrittenIndexes();
750           SuperClassWriter::addDimension(varId, nbIndexes);
751
752           dims.push_back(varId);
753           SuperClassWriter::addVariable(varId, NC_INT, dims);
754
755           StdOStringStream compress;
756           for (int i = numElement - 1; i >= 0; --i)
757           {
758             if (axisDomainOrder(i))
759             {
760               CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]);
761               StdString domId = domain->getDomainOutputName();
762               StdString appendDomId  = singleDomain ? "" : "_" + domId;
763
764               switch (domain->type)
765               {
766                 case CDomain::type_attr::curvilinear:
767                   compress << "y" << appendDomId << " x" << appendDomId;
768                   break;
769                 case CDomain::type_attr::rectilinear:
770                   compress << "lat" << appendDomId << " lon" << appendDomId;
771                   break;
772                 case CDomain::type_attr::unstructured:
773                   compress << "cell" << appendDomId;
774                   break;
775               }
776               ++idxDomain;
777             }
778             else
779             {
780               CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]);
781               compress << axis->getAxisOutputName();
782               ++idxAxis;
783             }
784
785             if (i != 0) compress << ' ';
786           }
787           SuperClassWriter::addAttribute("compress", compress.str(), &varId);
788
789           grid->computeCompressedIndex();
790
791           CArray<int, 1> indexes(grid->getNumberWrittenIndexes());
792           std::map<int, CArray<size_t, 1> >::const_iterator it;
793           for (it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
794           {
795             const CArray<size_t, 1> compressedIndexes = grid->compressedOutIndexFromClient[it->first];
796             for (int i = 0; i < it->second.numElements(); i++)
797               indexes(compressedIndexes(i)) = it->second(i);
798           }
799
800           switch (SuperClass::type)
801           {
802             case (MULTI_FILE):
803             {
804               SuperClassWriter::writeData(indexes, varId, isCollective, 0);
805               break;
806             }
807             case (ONE_FILE):
808             {
809               if (grid->doGridHaveDataDistributed())
810                 grid->getDistributionServer()->computeGlobalIndex(indexes);
811
812               std::vector<StdSize> start, count;
813               start.push_back(grid->getOffsetWrittenIndexes());
814               count.push_back(grid->getNumberWrittenIndexes());
815
816               SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
817               break;
818             }
819           }
820         }
821         else
822         {
823           for (int i = 0; i < numElement; ++i)
824           {
825             StdString varId, compress;
826             CArray<int, 1> indexes;
827             bool isDistributed;
828             StdSize nbIndexes, totalNbIndexes, offset;
829             int firstGlobalIndex;
830
831             if (axisDomainOrder(i))
832             {
833               CDomain* domain = CDomain::get(domainList[idxDomain]);
834               StdString domId = domain->getDomainOutputName();
835
836               if (!domain->isCompressible()
837                    || domain->type == CDomain::type_attr::unstructured
838                    || domain->isWrittenCompressed(this->filename)
839                    || isWrittenCompressedDomain(domId))
840                 continue;
841
842               StdString appendDomId  = singleDomain ? "" : "_" + domId;
843
844               varId = domId + "_points";
845               switch (domain->type)
846               {
847                 case CDomain::type_attr::curvilinear:
848                   compress = "y" + appendDomId + " x" + appendDomId;
849                   break;
850                 case CDomain::type_attr::rectilinear:
851                   compress = "lat" + appendDomId + " lon" + appendDomId;
852                   break;
853               }
854
855               const std::vector<int>& indexesToWrite = domain->getIndexesToWrite();
856               indexes.resize(indexesToWrite.size());
857               for (int n = 0; n < indexes.numElements(); ++n)
858                 indexes(n) = indexesToWrite[n];
859
860               isDistributed = domain->isDistributed();
861               nbIndexes = domain->getNumberWrittenIndexes();
862               totalNbIndexes = domain->getTotalNumberWrittenIndexes();
863               offset = domain->getOffsetWrittenIndexes();
864               firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
865
866               domain->addRelFileCompressed(this->filename);
867               setWrittenCompressedDomain(domId);
868               ++idxDomain;
869             }
870             else
871             {
872               CAxis* axis = CAxis::get(axisList[idxAxis]);
873               StdString axisId = axis->getAxisOutputName();
874
875               if (!axis->isCompressible()
876                    || axis->isWrittenCompressed(this->filename)
877                    || isWrittenCompressedAxis(axisId))
878                 continue;
879
880               varId = axisId + "_points";
881               compress = axisId;
882
883               const std::vector<int>& indexesToWrite = axis->getIndexesToWrite();
884               indexes.resize(indexesToWrite.size());
885               for (int n = 0; n < indexes.numElements(); ++n)
886                 indexes(n) = indexesToWrite[n];
887
888               isDistributed = axis->isDistributed();
889               nbIndexes = axis->getNumberWrittenIndexes();
890               totalNbIndexes = axis->getTotalNumberWrittenIndexes();
891               offset = axis->getOffsetWrittenIndexes();
892               firstGlobalIndex = axis->begin;
893
894               axis->addRelFileCompressed(this->filename);
895               setWrittenCompressedAxis(axisId);
896               ++idxAxis;
897             }
898
899             if (!varId.empty())
900             {
901               SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
902
903               dims.clear();
904               dims.push_back(varId);
905               SuperClassWriter::addVariable(varId, NC_INT, dims);
906
907               SuperClassWriter::addAttribute("compress", compress, &varId);
908
909               switch (SuperClass::type)
910               {
911                 case (MULTI_FILE):
912                 {
913                   indexes -= firstGlobalIndex;
914                   SuperClassWriter::writeData(indexes, varId, isCollective, 0);
915                   break;
916                 }
917                 case (ONE_FILE):
918                 {
919                   std::vector<StdSize> start, count;
920                   start.push_back(offset);
921                   count.push_back(nbIndexes);
922
923                   SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
924                   break;
925                 }
926               }
927             }
928           }
929
930           if (!dims.empty())
931             grid->computeCompressedIndex();
932         }
933
934         grid->addRelFileCompressed(this->filename);
935       }
936       catch (CNetCdfException& e)
937       {
938         StdString msg("On writing compressed grid : ");
939         msg.append(grid->getId()); msg.append("\n");
940         msg.append("In the context : ");
941         CContext* context = CContext::getCurrent();
942         msg.append(context->getId()); msg.append("\n");
943         msg.append(e.what());
944         ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
945       }
946     }
947
948     //--------------------------------------------------------------
949
950     void CNc4DataOutput::writeTimeDimension_(void)
951     {
952       try
953       {
954        SuperClassWriter::addDimension("time_counter");
955       }
956       catch (CNetCdfException& e)
957       {
958         StdString msg("On writing time dimension : time_couter\n");
959         msg.append("In the context : ");
960         CContext* context = CContext::getCurrent() ;
961         msg.append(context->getId()); msg.append("\n");
962         msg.append(e.what());
963         ERROR("CNc4DataOutput::writeTimeDimension_(void)", << msg);
964       }
965     }
966
967      //--------------------------------------------------------------
968
969      void CNc4DataOutput::writeField_(CField* field)
970      {
971         CContext* context = CContext::getCurrent() ;
972         CContextServer* server=context->server ;
973
974         std::vector<StdString> dims, coodinates;
975         CGrid* grid = field->grid;
976         if (!grid->doGridHaveDataToWrite())
977          if (SuperClass::type==MULTI_FILE) return ;
978
979         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
980         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
981         std::vector<StdString> domainList = grid->getDomainList();
982         std::vector<StdString> axisList   = grid->getAxisList();
983
984         StdString timeid  = StdString("time_counter");
985         StdString dimXid,dimYid;
986         std::deque<StdString> dimIdList, dimCoordList;
987         bool hasArea = false;
988         StdString cellMeasures = "area:";
989         bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
990
991         for (int i = 0; i < numElement; ++i)
992         {
993           if (axisDomainOrder(i))
994           {
995             CDomain* domain = CDomain::get(domainList[idxDomain]);
996             StdString domId = domain->getDomainOutputName();
997             StdString appendDomId  = singleDomain ? "" : "_" + domId ;
998
999             if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
1000             {
1001               dimIdList.push_back(domId + "_points");
1002               field->setUseCompressedOutput();
1003             }
1004
1005             switch (domain->type)
1006             {
1007               case CDomain::type_attr::curvilinear:
1008                 if (!compressedOutput || !domain->isCompressible())
1009                 {
1010                   dimXid     = StdString("x").append(appendDomId);
1011                   dimIdList.push_back(dimXid);
1012                   dimYid     = StdString("y").append(appendDomId);
1013                   dimIdList.push_back(dimYid);
1014                 }
1015                 dimCoordList.push_back(StdString("nav_lon").append(appendDomId));
1016                 dimCoordList.push_back(StdString("nav_lat").append(appendDomId));
1017                 break ;
1018               case CDomain::type_attr::rectilinear:
1019                 if (!compressedOutput || !domain->isCompressible())
1020                 {
1021                   dimXid     = StdString("lon").append(appendDomId);
1022                   dimIdList.push_back(dimXid);
1023                   dimYid     = StdString("lat").append(appendDomId);
1024                   dimIdList.push_back(dimYid);
1025                 }
1026                 break ;
1027               case CDomain::type_attr::unstructured:
1028                 dimXid     = StdString("cell").append(appendDomId);
1029                 dimIdList.push_back(dimXid);
1030                 dimCoordList.push_back(StdString("lon").append(appendDomId));
1031                 dimCoordList.push_back(StdString("lat").append(appendDomId));
1032                 break ;
1033             }
1034             if (domain->hasArea)
1035             {
1036               hasArea = true;
1037               cellMeasures += " area" + appendDomId;
1038             }
1039             ++idxDomain;
1040           }
1041           else
1042           {
1043             CAxis* axis = CAxis::get(axisList[idxAxis]);
1044             StdString axisId = axis->getAxisOutputName();
1045
1046             if (compressedOutput && axis->isCompressible())
1047             {
1048               dimIdList.push_back(axisId + "_points");
1049               field->setUseCompressedOutput();
1050             }
1051             else
1052               dimIdList.push_back(axisId);
1053
1054             dimCoordList.push_back(axisId);
1055             ++idxAxis;
1056           }
1057         }
1058
1059/*
1060         StdString lonid_loc = (server->intraCommSize > 1)
1061                             ? StdString("lon").append(appendDomid).append("_local")
1062                             : lonid;
1063         StdString latid_loc = (server->intraCommSize > 1)
1064                             ? StdString("lat").append(appendDomid).append("_local")
1065                             : latid;
1066*/
1067         StdString fieldid = field->getFieldOutputName();
1068
1069//         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
1070//         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
1071//          bool isCurvilinear = domain->isCurvilinear ;
1072
1073         nc_type type ;
1074         if (field->prec.isEmpty()) type =  NC_FLOAT ;
1075         else
1076         {
1077           if (field->prec==2) type = NC_SHORT ;
1078           else if (field->prec==4)  type =  NC_FLOAT ;
1079           else if (field->prec==8)   type =  NC_DOUBLE ;
1080         }
1081
1082         bool wtime   = !(!field->operation.isEmpty() && field->getOperationTimeType() == func::CFunctor::once);
1083
1084         if (wtime)
1085         {
1086
1087            //StdOStringStream oss;
1088           // oss << "time_" << field->operation.getValue()
1089           //     << "_" << field->getRelFile()->output_freq.getValue();
1090          //oss
1091            if (field->getOperationTimeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
1092            else if (field->getOperationTimeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
1093            dims.push_back(timeid);
1094         }
1095
1096         if (compressedOutput && grid->isCompressible())
1097         {
1098           dims.push_back(grid->getId() + "_points");
1099           field->setUseCompressedOutput();
1100         }
1101         else
1102         {
1103           while (!dimIdList.empty())
1104           {
1105             dims.push_back(dimIdList.back());
1106             dimIdList.pop_back();
1107           }
1108         }
1109
1110         while (!dimCoordList.empty())
1111         {
1112           coodinates.push_back(dimCoordList.back());
1113           dimCoordList.pop_back();
1114         }
1115
1116         try
1117         {
1118           SuperClassWriter::addVariable(fieldid, type, dims);
1119
1120           if (!field->standard_name.isEmpty())
1121              SuperClassWriter::addAttribute
1122                 ("standard_name",  field->standard_name.getValue(), &fieldid);
1123
1124           if (!field->long_name.isEmpty())
1125              SuperClassWriter::addAttribute
1126                 ("long_name", field->long_name.getValue(), &fieldid);
1127
1128           if (!field->unit.isEmpty())
1129              SuperClassWriter::addAttribute
1130                 ("units", field->unit.getValue(), &fieldid);
1131
1132            if (!field->valid_min.isEmpty())
1133              SuperClassWriter::addAttribute
1134                 ("valid_min", field->valid_min.getValue(), &fieldid);
1135
1136           if (!field->valid_max.isEmpty())
1137              SuperClassWriter::addAttribute
1138                 ("valid_max", field->valid_max.getValue(), &fieldid);
1139
1140            if (!field->scale_factor.isEmpty())
1141              SuperClassWriter::addAttribute
1142                 ("scale_factor", field->scale_factor.getValue(), &fieldid);
1143
1144             if (!field->add_offset.isEmpty())
1145              SuperClassWriter::addAttribute
1146                 ("add_offset", field->add_offset.getValue(), &fieldid);
1147
1148           SuperClassWriter::addAttribute
1149                 ("online_operation", field->operation.getValue(), &fieldid);
1150
1151          // write child variables as attributes
1152
1153
1154           vector<CVariable*> listVars = field->getAllVariables() ;
1155           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ;
1156
1157
1158           if (wtime)
1159           {
1160              CDuration freqOp = field->freq_op.getValue();
1161              freqOp.solveTimeStep(*context->calendar);
1162              StdString freqOpStr = freqOp.toStringUDUnits();
1163              SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
1164
1165              CDuration freqOut = field->getRelFile()->output_freq.getValue();
1166              freqOut.solveTimeStep(*context->calendar);
1167              SuperClassWriter::addAttribute("interval_write", freqOut.toStringUDUnits(), &fieldid);
1168
1169              StdString cellMethods = "time: ";
1170              if (field->operation.getValue() == "instant") cellMethods += "point";
1171              else if (field->operation.getValue() == "average") cellMethods += "mean";
1172              else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
1173              else cellMethods += field->operation;
1174              if (freqOp.resolve(*context->calendar) != freqOut.resolve(*context->calendar))
1175                cellMethods += " (interval: " + freqOpStr + ")";
1176              SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
1177           }
1178
1179           if (hasArea)
1180             SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
1181
1182           if (!field->default_value.isEmpty())
1183           {
1184              double default_value = field->default_value.getValue();
1185              float fdefault_value = (float)default_value;
1186              if (type == NC_DOUBLE)
1187                 SuperClassWriter::setDefaultValue(fieldid, &default_value);
1188              else
1189                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1190           }
1191           else
1192              SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1193
1194            if (field->compression_level.isEmpty())
1195              field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
1196            SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
1197
1198           {  // Ecriture des coordonnées
1199
1200              StdString coordstr; //boost::algorithm::join(coodinates, " ")
1201              std::vector<StdString>::iterator
1202                 itc = coodinates.begin(), endc = coodinates.end();
1203
1204              for (; itc!= endc; itc++)
1205              {
1206                 StdString & coord = *itc;
1207                 if (itc+1 != endc)
1208                       coordstr.append(coord).append(" ");
1209                 else  coordstr.append(coord);
1210              }
1211
1212              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1213
1214           }
1215         }
1216         catch (CNetCdfException& e)
1217         {
1218           StdString msg("On writing field : ");
1219           msg.append(fieldid); msg.append("\n");
1220           msg.append("In the context : ");
1221           msg.append(context->getId()); msg.append("\n");
1222           msg.append(e.what());
1223           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1224         }
1225      }
1226
1227      //--------------------------------------------------------------
1228
1229      void CNc4DataOutput::writeFile_ (CFile* file)
1230      {
1231         StdString filename = file->getFileOutputName();
1232         StdString description = (!file->description.isEmpty())
1233                               ? file->description.getValue()
1234                               : StdString("Created by xios");
1235
1236         singleDomain = (file->nbDomains == 1);
1237
1238         try
1239         {
1240           this->writeFileAttributes(filename, description,
1241                                     StdString("CF-1.5"),
1242                                     StdString("An IPSL model"),
1243                                     this->getTimeStamp());
1244
1245           if (!appendMode)
1246             SuperClassWriter::addDimension("axis_nbounds", 2);
1247         }
1248         catch (CNetCdfException& e)
1249         {
1250           StdString msg("On writing file : ");
1251           msg.append(filename); msg.append("\n");
1252           msg.append("In the context : ");
1253           CContext* context = CContext::getCurrent() ;
1254           msg.append(context->getId()); msg.append("\n");
1255           msg.append(e.what());
1256           ERROR("CNc4DataOutput::writeFile_ (CFile* file)", << msg);
1257         }
1258      }
1259
1260      void CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)
1261      {
1262        StdString name = var->getVariableOutputName();
1263
1264        try
1265        {
1266          if (var->type.getValue() == CVariable::type_attr::t_int || var->type.getValue() == CVariable::type_attr::t_int32)
1267            addAttribute(name, var->getData<int>(), &fieldId);
1268          else if (var->type.getValue() == CVariable::type_attr::t_int16)
1269            addAttribute(name, var->getData<short int>(), &fieldId);
1270          else if (var->type.getValue() == CVariable::type_attr::t_float)
1271            addAttribute(name, var->getData<float>(), &fieldId);
1272          else if (var->type.getValue() == CVariable::type_attr::t_double)
1273            addAttribute(name, var->getData<double>(), &fieldId);
1274          else if (var->type.getValue() == CVariable::type_attr::t_string)
1275            addAttribute(name, var->getData<string>(), &fieldId);
1276          else
1277            ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)",
1278                  << "Unsupported variable of type " << var->type.getStringValue());
1279        }
1280       catch (CNetCdfException& e)
1281       {
1282         StdString msg("On writing attributes of variable with name : ");
1283         msg.append(name); msg.append("in the field "); msg.append(fieldId); msg.append("\n");
1284         msg.append("In the context : ");
1285         CContext* context = CContext::getCurrent() ;
1286         msg.append(context->getId()); msg.append("\n");
1287         msg.append(e.what());
1288         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)", << msg);
1289       }
1290     }
1291
1292     void CNc4DataOutput::writeAttribute_ (CVariable* var)
1293     {
1294        StdString name = var->getVariableOutputName();
1295
1296        try
1297        {
1298          if (var->type.getValue() == CVariable::type_attr::t_int || var->type.getValue() == CVariable::type_attr::t_int32)
1299            addAttribute(name, var->getData<int>());
1300          else if (var->type.getValue() == CVariable::type_attr::t_int16)
1301            addAttribute(name, var->getData<short int>());
1302          else if (var->type.getValue() == CVariable::type_attr::t_float)
1303            addAttribute(name, var->getData<float>());
1304          else if (var->type.getValue() == CVariable::type_attr::t_double)
1305            addAttribute(name, var->getData<double>());
1306          else if (var->type.getValue() == CVariable::type_attr::t_string)
1307            addAttribute(name, var->getData<string>());
1308          else
1309            ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)",
1310                  << "Unsupported variable of type " << var->type.getStringValue());
1311        }
1312       catch (CNetCdfException& e)
1313       {
1314         StdString msg("On writing attributes of variable with name : ");
1315         msg.append(name); msg.append("\n");
1316         msg.append("In the context : ");
1317         CContext* context = CContext::getCurrent() ;
1318         msg.append(context->getId()); msg.append("\n");
1319         msg.append(e.what());
1320         ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)", << msg);
1321       }
1322     }
1323
1324      void CNc4DataOutput::syncFile_ (void)
1325      {
1326        try
1327        {
1328          SuperClassWriter::sync() ;
1329        }
1330        catch (CNetCdfException& e)
1331        {
1332         StdString msg("On synchronizing the write among processes");
1333         msg.append("In the context : ");
1334         CContext* context = CContext::getCurrent() ;
1335         msg.append(context->getId()); msg.append("\n");
1336         msg.append(e.what());
1337         ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1338        }
1339      }
1340
1341      void CNc4DataOutput::closeFile_ (void)
1342      {
1343        try
1344        {
1345          SuperClassWriter::close() ;
1346        }
1347        catch (CNetCdfException& e)
1348        {
1349         StdString msg("On closing file");
1350         msg.append("In the context : ");
1351         CContext* context = CContext::getCurrent() ;
1352         msg.append(context->getId()); msg.append("\n");
1353         msg.append(e.what());
1354         ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1355        }
1356
1357      }
1358
1359      //---------------------------------------------------------------
1360
1361      StdString CNc4DataOutput::getTimeStamp(void) const
1362      {
1363         const int buffer_size = 100;
1364         time_t rawtime;
1365         struct tm * timeinfo = NULL;
1366         char buffer [buffer_size];
1367
1368         time ( &rawtime );
1369         timeinfo = localtime ( &rawtime );
1370         strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
1371
1372         return (StdString(buffer));
1373      }
1374
1375      //---------------------------------------------------------------
1376
1377      void CNc4DataOutput::writeFieldData_ (CField*  field)
1378      {
1379        CContext* context = CContext::getCurrent();
1380        CContextServer* server = context->server;
1381        CGrid* grid = field->grid;
1382
1383        if (!grid->doGridHaveDataToWrite())
1384          if (SuperClass::type == MULTI_FILE || !isCollective) return;
1385
1386        StdString fieldid = field->getFieldOutputName();
1387
1388        StdOStringStream oss;
1389        string timeAxisId;
1390        if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisId = "time_instant";
1391        else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisId = "time_centered";
1392
1393        StdString timeBoundId("time_counter_bounds");
1394
1395        StdString timeAxisBoundId;
1396        if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisBoundId = "time_instant_bounds";
1397        else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisBoundId = "time_centered_bounds";
1398
1399        if (!field->wasWritten())
1400        {
1401          if (appendMode && field->file->record_offset.isEmpty())
1402          {
1403            field->resetNStep(getRecordFromTime(field->last_Write_srv) + 1);
1404          }
1405
1406          field->setWritten();
1407        }
1408
1409
1410        CArray<double,1> time_data(1);
1411        CArray<double,1> time_data_bound(2);
1412        CArray<double,1> time_counter(1);
1413        CArray<double,1> time_counter_bound(2);
1414
1415        bool wtime = (field->getOperationTimeType() != func::CFunctor::once);
1416
1417        if (wtime)
1418        {
1419          Time lastWrite = field->last_Write_srv;
1420          Time lastLastWrite = field->lastlast_Write_srv;
1421
1422          if (field->getOperationTimeType() == func::CFunctor::instant)
1423            time_data(0) = lastWrite;
1424          else if (field->getOperationTimeType() == func::CFunctor::centered)
1425            time_data(0) = (lastWrite + lastLastWrite) / 2;
1426
1427          if (field->getOperationTimeType() == func::CFunctor::instant)
1428            time_data_bound(0) = time_data_bound(1) = lastWrite;
1429          else if (field->getOperationTimeType() == func::CFunctor::centered)
1430          {
1431            time_data_bound(0) = lastLastWrite;
1432            time_data_bound(1) = lastWrite;
1433          }
1434
1435          if (field->file->time_counter == CFile::time_counter_attr::instant)
1436            time_counter(0) = lastWrite;
1437          else if (field->file->time_counter == CFile::time_counter_attr::centered)
1438            time_counter(0) = (lastWrite + lastLastWrite) / 2;
1439          else if (field->file->time_counter == CFile::time_counter_attr::record)
1440            time_counter(0) = field->getNStep() - 1;
1441
1442
1443          if (field->file->time_counter == CFile::time_counter_attr::instant)
1444            time_counter_bound(0) = time_counter_bound(1) = lastWrite;
1445          else if (field->file->time_counter == CFile::time_counter_attr::centered)
1446          {
1447            time_counter_bound(0) = lastLastWrite;
1448            time_counter_bound(1) = lastWrite;
1449          }
1450          else if (field->file->time_counter == CFile::time_counter_attr::record)
1451            time_counter_bound(0) = time_counter_bound(1) = field->getNStep() - 1;
1452        }
1453
1454         bool isRoot = (server->intraCommRank == 0);
1455
1456         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
1457         {
1458           double scaleFactor = 1.0;
1459           double addOffset = 0.0;
1460           if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
1461           if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
1462           field->scaleFactorAddOffset(scaleFactor, addOffset);
1463         }
1464
1465         try
1466         {
1467           size_t writtenSize;
1468           if (field->getUseCompressedOutput())
1469             writtenSize = grid->getNumberWrittenIndexes();
1470           else
1471             writtenSize = grid->getWrittenDataSize();
1472
1473           CArray<double,1> fieldData(writtenSize);
1474           if (!field->default_value.isEmpty()) fieldData = field->default_value;
1475
1476           if (field->getUseCompressedOutput())
1477             field->outputCompressedField(fieldData);
1478           else
1479             field->outputField(fieldData);
1480
1481           if (!field->prec.isEmpty() && field->prec == 2) fieldData = round(fieldData);
1482
1483           switch (SuperClass::type)
1484           {
1485              case (MULTI_FILE) :
1486              {
1487                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1);
1488                 if (wtime)
1489                 {
1490                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep() - 1);
1491                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1);
1492                   if (field->file->time_counter != CFile::time_counter_attr::none)
1493                   {
1494                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep() - 1);
1495                     if (field->file->time_counter != CFile::time_counter_attr::record)
1496                       SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1);
1497                   }
1498                 }
1499                 break;
1500              }
1501              case (ONE_FILE) :
1502              {
1503                const std::vector<int>& nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
1504                const std::vector<int>& nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
1505                const std::vector<int>& nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
1506
1507                std::vector<StdSize> start, count;
1508
1509                if (field->getUseCompressedOutput())
1510                {
1511                  if (grid->isCompressible())
1512                  {
1513                    start.push_back(grid->getOffsetWrittenIndexes());
1514                    count.push_back(grid->getNumberWrittenIndexes());
1515                  }
1516                  else
1517                  {
1518                    CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1519                    std::vector<StdString> domainList = grid->getDomainList();
1520                    std::vector<StdString> axisList   = grid->getAxisList();
1521                    int numElement = axisDomainOrder.numElements();
1522                    int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
1523                    int idx = nZoomBeginGlobal.size() - 1;
1524
1525                    start.reserve(nZoomBeginGlobal.size());
1526                    count.reserve(nZoomBeginGlobal.size());
1527
1528
1529                    for (int i = numElement - 1; i >= 0; --i)
1530                    {
1531                      if (axisDomainOrder(i))
1532                      {
1533                        CDomain* domain = CDomain::get(domainList[idxDomain]);
1534
1535                        if (domain->isCompressible())
1536                        {
1537                          start.push_back(domain->getOffsetWrittenIndexes());
1538                          count.push_back(domain->getNumberWrittenIndexes());
1539                          idx -= 2;
1540                        }
1541                        else
1542                        {
1543                          if ((domain->type) != CDomain::type_attr::unstructured)
1544                          {
1545                            start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1546                            count.push_back(nZoomSizeServer[idx]);
1547                          }
1548                          --idx;
1549                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1550                          count.push_back(nZoomSizeServer[idx]);
1551                          --idx;
1552                        }
1553                        --idxDomain;
1554                      }
1555                      else
1556                      {
1557                        CAxis* axis = CAxis::get(axisList[idxAxis]);
1558
1559                        if (axis->isCompressible())
1560                        {
1561                          start.push_back(axis->getOffsetWrittenIndexes());
1562                          count.push_back(axis->getNumberWrittenIndexes());
1563                        }
1564                        else
1565                        {
1566                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1567                          count.push_back(nZoomSizeServer[idx]);
1568                        }
1569
1570                        --idxAxis;
1571                        --idx;
1572                      }
1573                    }
1574                  }
1575                }
1576                else
1577                {
1578
1579                  CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1580                  std::vector<StdString> domainList = grid->getDomainList();
1581                  std::vector<StdString> axisList   = grid->getAxisList();
1582                  int numElement = axisDomainOrder.numElements();
1583                  int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
1584                  int idx = nZoomBeginGlobal.size() - 1;
1585
1586                  start.reserve(nZoomBeginGlobal.size());
1587                  count.reserve(nZoomBeginGlobal.size());
1588
1589                  for (int i = numElement - 1; i >= 0; --i)
1590                  {
1591                    if (axisDomainOrder(i))
1592                    {
1593                      CDomain* domain = CDomain::get(domainList[idxDomain]);
1594                      if ((domain->type) != CDomain::type_attr::unstructured)
1595                      {
1596                        start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1597                        count.push_back(nZoomSizeServer[idx]);
1598                      }
1599                      --idx ;
1600                      start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1601                      count.push_back(nZoomSizeServer[idx]);
1602                      --idx ;
1603                      --idxDomain;
1604                    }
1605                    else
1606                    {
1607                      start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
1608                      count.push_back(nZoomSizeServer[idx]);
1609                      --idx;
1610                     }
1611                  }
1612                }
1613
1614                SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1, &start, &count);
1615                if (wtime)
1616                {
1617                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot);
1618                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot);
1619                   if (field->file->time_counter != CFile::time_counter_attr::none)
1620                   {
1621                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep() - 1, isRoot);
1622                     if (field->file->time_counter != CFile::time_counter_attr::record)
1623                       SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot);
1624                   }
1625                }
1626
1627                break;
1628              }
1629            }
1630         }
1631         catch (CNetCdfException& e)
1632         {
1633           StdString msg("On writing field data: ");
1634           msg.append(fieldid); msg.append("\n");
1635           msg.append("In the context : ");
1636           msg.append(context->getId()); msg.append("\n");
1637           msg.append(e.what());
1638           ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg);
1639         }
1640      }
1641
1642      //---------------------------------------------------------------
1643
1644      void CNc4DataOutput::writeTimeAxis_
1645                  (CField*    field,
1646                   const boost::shared_ptr<CCalendar> cal)
1647      {
1648         StdOStringStream oss;
1649
1650         if (field->getOperationTimeType() == func::CFunctor::once) return ;
1651
1652//         oss << "time_" << field->operation.getValue()
1653//             << "_" << field->getRelFile()->output_freq.getValue();
1654
1655//         StdString axisid = oss.str();
1656//         if (field->getOperationTimeType() == func::CFunctor::centered) axisid="time_centered" ;
1657//         else if (field->getOperationTimeType() == func::CFunctor::instant) axisid="time_instant" ;
1658
1659         StdString axisid("time_centered") ;
1660         StdString axisBoundId("time_centered_bounds");
1661         StdString timeid("time_counter");
1662         StdString timeBoundId("axis_nbounds");
1663
1664         if (field->getOperationTimeType() == func::CFunctor::instant)
1665         {
1666            axisid = "time_instant";
1667            axisBoundId = "time_instant_bounds";
1668         }
1669
1670         try
1671         {
1672          // Adding time_instant or time_centered
1673           std::vector<StdString> dims;
1674           dims.push_back(timeid);
1675           if (!SuperClassWriter::varExist(axisid))
1676           {
1677              SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
1678
1679              CDate timeOrigin=cal->getTimeOrigin() ;
1680              StdOStringStream oss2;
1681  //            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" "
1682  //                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ;
1683              StdString strInitdate=oss2.str() ;
1684              StdString strTimeOrigin=timeOrigin.toString() ;
1685              this->writeTimeAxisAttributes
1686                 (axisid, cal->getType(),
1687                  StdString("seconds since ").append(strTimeOrigin),
1688                  strTimeOrigin, axisBoundId);
1689           }
1690
1691           // Adding time_instant_bounds or time_centered_bounds variables
1692           if (!SuperClassWriter::varExist(axisBoundId))
1693           {
1694              dims.clear() ;
1695              dims.push_back(timeid);
1696              dims.push_back(timeBoundId);
1697              SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
1698           }
1699
1700           if (field->file->time_counter != CFile::time_counter_attr::none)
1701           {
1702             // Adding time_counter
1703             axisid = "time_counter";
1704             axisBoundId = "time_counter_bounds";
1705             dims.clear();
1706             dims.push_back(timeid);
1707             if (!SuperClassWriter::varExist(axisid))
1708             {
1709                SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
1710                SuperClassWriter::addAttribute("axis", string("T"), &axisid);
1711
1712                if (field->file->time_counter != CFile::time_counter_attr::record)
1713                {
1714                  CDate timeOrigin = cal->getTimeOrigin();
1715                  StdString strTimeOrigin = timeOrigin.toString();
1716
1717                  this->writeTimeAxisAttributes(axisid, cal->getType(),
1718                                                StdString("seconds since ").append(strTimeOrigin),
1719                                                strTimeOrigin, axisBoundId);
1720                }
1721             }
1722
1723             // Adding time_counter_bound dimension
1724             if (field->file->time_counter != CFile::time_counter_attr::record)
1725             {
1726                if (!SuperClassWriter::varExist(axisBoundId))
1727                {
1728                  dims.clear();
1729                  dims.push_back(timeid);
1730                  dims.push_back(timeBoundId);
1731                  SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
1732                }
1733             }
1734           }
1735         }
1736         catch (CNetCdfException& e)
1737         {
1738           StdString msg("On writing time axis data: ");
1739           msg.append("In the context : ");
1740           CContext* context = CContext::getCurrent() ;
1741           msg.append(context->getId()); msg.append("\n");
1742           msg.append(e.what());
1743           ERROR("CNc4DataOutput::writeTimeAxis_ (CField*    field, \
1744                  const boost::shared_ptr<CCalendar> cal)", << msg);
1745         }
1746      }
1747
1748      //---------------------------------------------------------------
1749
1750      void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
1751                                                   const StdString & calendar,
1752                                                   const StdString & units,
1753                                                   const StdString & time_origin,
1754                                                   const StdString & time_bounds,
1755                                                   const StdString & standard_name,
1756                                                   const StdString & long_name)
1757      {
1758         try
1759         {
1760           SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
1761           SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name);
1762           SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name);
1763           SuperClassWriter::addAttribute("units",         units        , &axis_name);
1764           SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name);
1765           SuperClassWriter::addAttribute("bounds",        time_bounds  , &axis_name);
1766         }
1767         catch (CNetCdfException& e)
1768         {
1769           StdString msg("On writing time axis Attribute: ");
1770           msg.append("In the context : ");
1771           CContext* context = CContext::getCurrent() ;
1772           msg.append(context->getId()); msg.append("\n");
1773           msg.append(e.what());
1774           ERROR("CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, \
1775                                                          const StdString & calendar,\
1776                                                          const StdString & units, \
1777                                                          const StdString & time_origin, \
1778                                                          const StdString & time_bounds, \
1779                                                          const StdString & standard_name, \
1780                                                          const StdString & long_name)", << msg);
1781         }
1782      }
1783
1784      //---------------------------------------------------------------
1785
1786      void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
1787                                               const StdString & axis,
1788                                               const StdString & standard_name,
1789                                               const StdString & long_name,
1790                                               const StdString & units,
1791                                               const StdString & nav_model)
1792      {
1793         try
1794         {
1795          if (!axis.empty())
1796            SuperClassWriter::addAttribute("axis"       , axis         , &axis_name);
1797
1798          SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
1799          SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name);
1800          SuperClassWriter::addAttribute("units"        , units        , &axis_name);
1801          SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name);
1802         }
1803         catch (CNetCdfException& e)
1804         {
1805           StdString msg("On writing Axis Attribute: ");
1806           msg.append("In the context : ");
1807           CContext* context = CContext::getCurrent() ;
1808           msg.append(context->getId()); msg.append("\n");
1809           msg.append(e.what());
1810           ERROR("CNc4DataOutput::writeAxisAttributes(const StdString & axis_name, \
1811                                                      const StdString & axis, \
1812                                                      const StdString & standard_name, \
1813                                                      const StdString & long_name, \
1814                                                      const StdString & units, \
1815                                                      const StdString & nav_model)", << msg);
1816         }
1817      }
1818
1819      //---------------------------------------------------------------
1820
1821      void CNc4DataOutput::writeLocalAttributes
1822         (int ibegin, int ni, int jbegin, int nj, StdString domid)
1823      {
1824        try
1825        {
1826         SuperClassWriter::addAttribute(StdString("ibegin").append(domid), ibegin);
1827         SuperClassWriter::addAttribute(StdString("ni"    ).append(domid), ni);
1828         SuperClassWriter::addAttribute(StdString("jbegin").append(domid), jbegin);
1829         SuperClassWriter::addAttribute(StdString("nj"    ).append(domid), nj);
1830        }
1831        catch (CNetCdfException& e)
1832        {
1833           StdString msg("On writing Local Attributes: ");
1834           msg.append("In the context : ");
1835           CContext* context = CContext::getCurrent() ;
1836           msg.append(context->getId()); msg.append("\n");
1837           msg.append(e.what());
1838           ERROR("CNc4DataOutput::writeLocalAttributes \
1839                  (int ibegin, int ni, int jbegin, int nj, StdString domid)", << msg);
1840        }
1841
1842      }
1843
1844      void CNc4DataOutput::writeLocalAttributes_IOIPSL(const StdString& dimXid, const StdString& dimYid,
1845                                                       int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)
1846      {
1847         CArray<int,1> array(2) ;
1848
1849         try
1850         {
1851           SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ;
1852           SuperClassWriter::addAttribute("DOMAIN_number", rank) ;
1853           array = SuperClassWriter::getDimension(dimXid) + 1, SuperClassWriter::getDimension(dimYid) + 1;
1854           SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ;
1855           array=ni_glo,nj_glo ;
1856           SuperClassWriter::addAttribute("DOMAIN_size_global", array) ;
1857           array=ni,nj ;
1858           SuperClassWriter::addAttribute("DOMAIN_size_local", array) ;
1859           array=ibegin,jbegin ;
1860           SuperClassWriter::addAttribute("DOMAIN_position_first", array) ;
1861           array=ibegin+ni-1,jbegin+nj-1 ;
1862           SuperClassWriter::addAttribute("DOMAIN_position_last",array) ;
1863           array=0,0 ;
1864           SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ;
1865           SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array);
1866           SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ;
1867  /*
1868           SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ;
1869           SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ;
1870           SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ;
1871           SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ;
1872  */
1873         }
1874         catch (CNetCdfException& e)
1875         {
1876           StdString msg("On writing Local Attributes IOIPSL \n");
1877           msg.append("In the context : ");
1878           CContext* context = CContext::getCurrent() ;
1879           msg.append(context->getId()); msg.append("\n");
1880           msg.append(e.what());
1881           ERROR("CNc4DataOutput::writeLocalAttributes_IOIPSL \
1882                  (int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)", << msg);
1883         }
1884      }
1885      //---------------------------------------------------------------
1886
1887      void CNc4DataOutput:: writeFileAttributes(const StdString & name,
1888                                                const StdString & description,
1889                                                const StdString & conventions,
1890                                                const StdString & production,
1891                                                const StdString & timeStamp)
1892      {
1893         try
1894         {
1895           SuperClassWriter::addAttribute("name"       , name);
1896           SuperClassWriter::addAttribute("description", description);
1897           SuperClassWriter::addAttribute("title"      , description);
1898           SuperClassWriter::addAttribute("Conventions", conventions);
1899           SuperClassWriter::addAttribute("production" , production);
1900           SuperClassWriter::addAttribute("timeStamp"  , timeStamp);
1901         }
1902         catch (CNetCdfException& e)
1903         {
1904           StdString msg("On writing File Attributes \n ");
1905           msg.append("In the context : ");
1906           CContext* context = CContext::getCurrent() ;
1907           msg.append(context->getId()); msg.append("\n");
1908           msg.append(e.what());
1909           ERROR("CNc4DataOutput:: writeFileAttributes(const StdString & name, \
1910                                                const StdString & description, \
1911                                                const StdString & conventions, \
1912                                                const StdString & production, \
1913                                                const StdString & timeStamp)", << msg);
1914         }
1915      }
1916
1917      //---------------------------------------------------------------
1918
1919      void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
1920                                               int data_dim,
1921                                               int data_ni,
1922                                               int data_nj,
1923                                               int data_ibegin,
1924                                               int data_jbegin)
1925      {
1926         try
1927         {
1928           SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name);
1929           SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name);
1930           SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name);
1931           SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
1932           SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
1933         }
1934         catch (CNetCdfException& e)
1935         {
1936           StdString msg("On writing Mask Attributes \n ");
1937           msg.append("In the context : ");
1938           CContext* context = CContext::getCurrent() ;
1939           msg.append(context->getId()); msg.append("\n");
1940           msg.append(e.what());
1941           ERROR("CNc4DataOutput::writeMaskAttributes(const StdString & mask_name, \
1942                                               int data_dim, \
1943                                               int data_ni, \
1944                                               int data_nj, \
1945                                               int data_ibegin, \
1946                                               int data_jbegin)", << msg);
1947         }
1948      }
1949
1950      ///--------------------------------------------------------------
1951
1952      StdSize CNc4DataOutput::getRecordFromTime(Time time)
1953      {
1954        std::map<Time, StdSize>::const_iterator it = timeToRecordCache.find(time);
1955        if (it == timeToRecordCache.end())
1956        {
1957          StdString timeAxisBoundsId("time_counter_bounds");
1958          if (!SuperClassWriter::varExist(timeAxisBoundsId))
1959            timeAxisBoundsId = "time_instant_bounds";
1960
1961          CArray<double,2> timeAxisBounds;
1962          SuperClassWriter::getTimeAxisBounds(timeAxisBounds, timeAxisBoundsId, isCollective);
1963
1964          StdSize record = 0;
1965          double dtime(time);
1966          for (int n = timeAxisBounds.extent(1) - 1; n >= 0; n--)
1967          {
1968            if (timeAxisBounds(1, n) < dtime)
1969            {
1970              record = n + 1;
1971              break;
1972            }
1973          }
1974          it = timeToRecordCache.insert(std::make_pair(time, record)).first;
1975        }
1976        return it->second;
1977      }
1978
1979      ///--------------------------------------------------------------
1980
1981      bool CNc4DataOutput::isWrittenDomain(const std::string& domainName) const
1982      {
1983        return (this->writtenDomains.find(domainName) != this->writtenDomains.end());
1984      }
1985
1986      bool CNc4DataOutput::isWrittenCompressedDomain(const std::string& domainName) const
1987      {
1988        return (this->writtenCompressedDomains.find(domainName) != this->writtenCompressedDomains.end());
1989      }
1990
1991      bool CNc4DataOutput::isWrittenAxis(const std::string& axisName) const
1992      {
1993        return (this->writtenAxis.find(axisName) != this->writtenAxis.end());
1994      }
1995
1996      bool CNc4DataOutput::isWrittenCompressedAxis(const std::string& axisName) const
1997      {
1998        return (this->writtenCompressedAxis.find(axisName) != this->writtenCompressedAxis.end());
1999      }
2000
2001      void CNc4DataOutput::setWrittenDomain(const std::string& domainName)
2002      {
2003        this->writtenDomains.insert(domainName);
2004      }
2005
2006      void CNc4DataOutput::setWrittenCompressedDomain(const std::string& domainName)
2007      {
2008        this->writtenCompressedDomains.insert(domainName);
2009      }
2010
2011      void CNc4DataOutput::setWrittenAxis(const std::string& axisName)
2012      {
2013        this->writtenAxis.insert(axisName);
2014      }
2015
2016      void CNc4DataOutput::setWrittenCompressedAxis(const std::string& axisName)
2017      {
2018        this->writtenCompressedAxis.insert(axisName);
2019      }
2020} // namespace xios
Note: See TracBrowser for help on using the repository browser.