source: XIOS/trunk/src/output/nc4_data_output.cpp @ 575

Last change on this file since 575 was 575, checked in by rlacroix, 9 years ago

Rename axisDomainOrder attribute to axis_domain_order.

"Snake case" is used everywhere else and camel case seems to confuse PGI compilers.

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