source: XMLIO_V2/dev/common/src/xmlio/output/nc4_data_output.cpp @ 286

Last change on this file since 286 was 286, checked in by ymipsl, 11 years ago

reprise en main de la version de H. Ozdoba. Correction de différentes erreurs de conception et bug.
Version NEMO operationnel en client/server, interoperabilita avec OASIS, reconstition de fichiers via netcdf4/HDF5

YM

File size: 27.0 KB
Line 
1
2#include "nc4_data_output.hpp"
3
4#include <boost/lexical_cast.hpp>
5#include "attribute_template_impl.hpp"
6#include "group_template_impl.hpp"
7
8#include "file.hpp"
9#include "calendar.hpp"
10#include "xios_manager.hpp"
11#include "context.hpp"
12
13namespace xmlioserver
14{
15   namespace io
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, MPI_Comm comm_server,bool multifile)
32            : SuperClass()
33            , SuperClassWriter(filename, exist, &comm_server,multifile)
34            , comm_server(comm_server)
35            , filename(filename)
36      {
37         StdString timeid = StdString("time_counter");
38
39         SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE;
40         
41         if (!exist)
42            SuperClassWriter::addDimension(timeid);
43      }
44
45
46      CNc4DataOutput::~CNc4DataOutput(void)
47      { /* Ne rien faire de plus */ }
48
49      ///--------------------------------------------------------------
50
51      const StdString & CNc4DataOutput::getFileName(void) const
52      {
53         return (this->filename);
54      }
55
56      //---------------------------------------------------------------
57
58      void CNc4DataOutput::writeDomain_(const boost::shared_ptr<tree::CDomain> domain)
59      {
60         if (domain->IsWritten(this->filename)) return;
61         domain->checkAttributes();
62         
63//         if (domain->isEmpty()) return;
64
65         std::vector<StdString> dim0, dim1;
66         StdString domid     = (!domain->name.isEmpty())
67                             ? domain->name.getValue() : domain->getId();
68         StdString lonid     = StdString("lon_").append(domid);
69         StdString latid     = StdString("lat_").append(domid);
70         StdString lonid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
71                             ? StdString("lon_").append(domid).append("_local")
72                             : lonid;
73         StdString latid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
74                             ? StdString("lat_").append(domid).append("_local")
75                             : latid;
76         StdString maskid    = StdString("mask_").append(domid).append("_local");
77
78         ARRAY(int, 2) mask = domain->getLocalMask();
79
80         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
81         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
82
83         switch (SuperClass::type)
84         {
85            case (MULTI_FILE) :
86            {
87               if (domain->isEmpty()) return;
88               
89               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
90               {
91                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
92                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
93               }
94
95               if (isCurvilinear)
96               {
97                 dim0.push_back(latid_loc); dim0.push_back(lonid_loc);
98                 lonid = StdString("nav_lon_").append(domid);
99                 latid = StdString("nav_lat_").append(domid);
100               }
101               else
102               {
103                 dim0.push_back(latid_loc);
104                 dim1.push_back(lonid_loc);
105               }
106
107               SuperClassWriter::addDimension(lonid_loc, domain->zoom_ni_loc.getValue());
108               SuperClassWriter::addDimension(latid_loc, domain->zoom_nj_loc.getValue());
109               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
110               {
111                  this->writeLocalAttributes(domain->zoom_ibegin_loc.getValue(),
112                                             domain->zoom_ni_loc.getValue(),
113                                             domain->zoom_jbegin_loc.getValue(),
114                                             domain->zoom_nj_loc.getValue(),
115                                             domid);
116               }
117               
118               if (isCurvilinear)
119               {
120                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
121                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
122               }
123               else
124               {
125                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
126                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
127               }
128               this->writeAxisAttributes
129                  (lonid, "X", "longitude", "Longitude", "degrees_east", domid);
130               this->writeAxisAttributes
131                  (latid, "Y", "latitude", "Latitude", "degrees_north", domid);
132
133               dim0.clear();
134               dim0.push_back(latid_loc);
135               dim0.push_back(lonid_loc);
136
137               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
138               {
139                  SuperClassWriter::addVariable(maskid, NC_INT, dim0);
140
141                  this->writeMaskAttributes(maskid,
142                     domain->data_dim.getValue()/*,
143                     domain->data_ni.getValue(),
144                     domain->data_nj.getValue(),
145                     domain->data_ibegin.getValue(),
146                     domain->data_jbegin.getValue()*/);
147               }
148                 
149               //SuperClassWriter::setDefaultValue(maskid, &dvm);
150
151               SuperClassWriter::definition_end();
152               SuperClassWriter::writeData(domain->latvalue.getValue(), latid, true, 0);
153               SuperClassWriter::writeData(domain->lonvalue.getValue(), lonid, true, 0);
154               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
155                  SuperClassWriter::writeData(mask, maskid);
156               SuperClassWriter::definition_start();
157
158               break;
159            }
160            case (ONE_FILE) :
161            {
162               SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
163               SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
164
165               
166               if (isCurvilinear)
167               {
168                  dim0.push_back(latid); dim0.push_back(lonid);
169                  lonid = StdString("nav_lon_").append(domid);
170                  latid = StdString("nav_lat_").append(domid);
171                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
172                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
173               }
174               else
175               {
176                  dim0.push_back(latid);
177                  dim1.push_back(lonid);
178                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
179                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
180               }
181               this->writeAxisAttributes
182                  (latid, "X", "longitude", "Longitude", "degrees_east", domid);
183               this->writeAxisAttributes
184                  (lonid, "Y", "latitude", "Latitude", "degrees_north", domid);
185
186
187               SuperClassWriter::definition_end();
188               std::vector<StdSize> start(2) ; 
189               std::vector<StdSize> count(2) ;
190               if (domain->isEmpty())
191               {
192                 start[0]=0 ; start [1]=0 ; 
193                 count[0]=0 ; count[1]=0 ; 
194               }
195               else
196               {
197                 start[1]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ; 
198                 count[1]=domain->zoom_ni_loc.getValue() ; count[0]=domain->zoom_nj_loc.getValue() ; 
199               }
200               
201               SuperClassWriter::writeData(domain->latvalue.getValue(), latid, true, 0,&start,&count);
202               SuperClassWriter::writeData(domain->lonvalue.getValue(), lonid, true, 0,&start,&count);
203               SuperClassWriter::definition_start();
204
205               break;
206            }           
207            default :
208               ERROR("CNc4DataOutput::writeDomain(domain)",
209                     << "[ type = " << SuperClass::type << "]"
210                     << " not implemented yet !");
211         }
212         domain->addRelFile(this->filename);
213      }
214
215      //--------------------------------------------------------------
216
217      void CNc4DataOutput::writeAxis_(const boost::shared_ptr<tree::CAxis> axis)
218      {
219         if (axis->IsWritten(this->filename)) return;
220         axis->checkAttributes();
221         std::vector<StdString> dims;
222         StdString axisid = (!axis->name.isEmpty())
223                           ? axis->name.getValue() : axis->getId();
224         SuperClassWriter::addDimension(axisid, axis->size.getValue());
225         dims.push_back(axisid);
226         
227         switch (SuperClass::type)
228         {
229            case (MULTI_FILE ) :
230            {}
231            case (ONE_FILE) :
232            {
233               SuperClassWriter::addVariable(axisid, NC_FLOAT, dims);
234
235               SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid);
236
237               if (!axis->standard_name.isEmpty())
238                  SuperClassWriter::addAttribute
239                     ("standard_name",  axis->standard_name.getValue(), &axisid);
240
241               if (!axis->long_name.isEmpty())
242                  SuperClassWriter::addAttribute
243                     ("long_name", axis->long_name.getValue(), &axisid);
244
245               if (!axis->unit.isEmpty())
246                  SuperClassWriter::addAttribute
247                     ("units", axis->unit.getValue(), &axisid);
248
249               SuperClassWriter::definition_end();
250               SuperClassWriter::writeData(axis->zvalue.getValue(), axisid, true, 0);
251               SuperClassWriter::definition_start();
252
253               break;
254            }
255            default :
256               ERROR("CNc4DataOutput::writeDomain(domain)",
257                     << "[ type = " << SuperClass::type << "]"
258                     << " not implemented yet !");
259         }
260         axis->addRelFile(this->filename);
261      }
262
263      //--------------------------------------------------------------
264
265      void CNc4DataOutput::writeField_(const boost::shared_ptr<tree::CField> field)
266      {
267         std::vector<StdString> dims, coodinates;
268         boost::shared_ptr<CGrid> grid =
269            CObjectFactory::GetObject<CGrid>(field->grid_ref.getValue());
270         boost::shared_ptr<CDomain> domain =
271            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue());
272           
273         if (domain->isEmpty()) 
274           if (SuperClass::type==MULTI_FILE) return ;
275
276         StdString timeid    = StdString("time_counter");
277         StdString domid     = (!domain->name.isEmpty())
278                             ? domain->name.getValue() : domain->getId();
279         StdString lonid     = StdString("lon_").append(domid);
280         StdString latid     = StdString("lat_").append(domid);
281         StdString lonid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
282                             ? StdString("lon_").append(domid).append("_local")
283                             : lonid;
284         StdString latid_loc = (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1)
285                             ? StdString("lat_").append(domid).append("_local")
286                             : latid;
287         StdString fieldid   = (!field->name.isEmpty())
288                             ? field->name.getValue() : field->getBaseFieldReference()->getId();
289
290         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
291         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
292
293         nc_type type = (!field->prec.isEmpty() &&
294                        ( field->prec.getValue() == 4))
295                        ? NC_FLOAT : NC_DOUBLE;
296         bool wtime   = !(!field->operation.isEmpty() &&
297                         ( field->operation.getValue().compare("once") == 0));
298                         
299         if (wtime)
300         {
301            StdOStringStream oss;
302            oss << "time_" << field->operation.getValue()
303                << "_" << field->getRelFile()->output_freq.getValue();
304
305            coodinates.push_back(oss.str());
306            dims.push_back(timeid);
307         }
308
309         if (!grid->axis_ref.isEmpty())
310         {
311            boost::shared_ptr<CAxis> axis =
312               CObjectFactory::GetObject<CAxis>(grid->axis_ref.getValue());
313            StdString axisid = (!axis->name.isEmpty())
314                             ? axis->name.getValue() : axis->getId();
315            dims.push_back(axisid);
316            coodinates.push_back(axisid);
317         }
318
319         if (isCurvilinear)
320         {
321            coodinates.push_back(StdString("nav_lat_").append(domid));
322            coodinates.push_back(StdString("nav_lon_").append(domid));
323         }
324         else
325         {
326            coodinates.push_back(latid);
327            coodinates.push_back(lonid);
328         }
329
330         switch (SuperClass::type)
331         {
332            case (MULTI_FILE) :
333            {
334               dims.push_back(latid_loc);
335               dims.push_back(lonid_loc);
336               break ;
337            }
338            case (ONE_FILE) :
339            {
340               dims.push_back(latid);
341               dims.push_back(lonid);
342               break;
343            }
344            default :
345               ERROR("CNc4DataOutput::writeDomain(domain)",
346                     << "[ type = " << SuperClass::type << "]"
347                     << " not implemented yet !");
348         }
349         
350         SuperClassWriter::addVariable(fieldid, type, dims);
351         
352         if (!field->standard_name.isEmpty())
353            SuperClassWriter::addAttribute
354               ("standard_name",  field->standard_name.getValue(), &fieldid);
355
356         if (!field->long_name.isEmpty())
357            SuperClassWriter::addAttribute
358               ("long_name", field->long_name.getValue(), &fieldid);
359
360         if (!field->unit.isEmpty())
361            SuperClassWriter::addAttribute
362               ("units", field->unit.getValue(), &fieldid);
363               
364         SuperClassWriter::addAttribute
365               ("online_operation", field->operation.getValue(), &fieldid);
366               
367         if (wtime)
368         {
369            SuperClassWriter::addAttribute
370                  ("interval_operation", field->freq_op.getValue(), &fieldid);
371            SuperClassWriter::addAttribute
372                  ("interval_write", field->getRelFile()->output_freq.getValue(), &fieldid);
373         }
374         
375         if (!field->default_value.isEmpty())
376         {
377            double default_value = field->default_value.getValue();
378            float fdefault_value = (float)default_value;
379            if (type == NC_DOUBLE)
380               SuperClassWriter::setDefaultValue(fieldid, &default_value);
381            else
382               SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
383         }
384         else
385         {
386            double * default_value = NULL;
387            SuperClassWriter::setDefaultValue(fieldid, default_value);
388         }             
389
390         {  // Ecriture des coordonnées
391         
392            StdString coordstr; //boost::algorithm::join(coodinates, " ")
393            std::vector<StdString>::iterator
394               itc = coodinates.begin(), endc = coodinates.end();
395           
396            for (; itc!= endc; itc++)
397            {
398               StdString & coord = *itc;
399               if (itc+1 != endc)
400                     coordstr.append(coord).append(" ");
401               else  coordstr.append(coord);
402            }
403
404            SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
405
406         }
407
408      }
409
410      //--------------------------------------------------------------
411
412      void CNc4DataOutput::writeFile_ (const boost::shared_ptr<tree::CFile> file)
413      {
414         StdString filename = (!file->name.isEmpty())
415                            ? file->name.getValue() : file->getId();
416         StdString description = (!file->description.isEmpty())
417                               ? file->description.getValue()
418                               : StdString("Created by xmlioserver");
419         this->writeFileAttributes(filename, description,
420                                   StdString ("CF-1.1"),
421                                   StdString("An IPSL model"),
422                                   this->getTimeStamp());
423      }
424
425      void CNc4DataOutput::closeFile_ (void)
426      {
427         std::cout<<"--> Close file "<<filename<<std::endl ;
428         SuperClassWriter::close() ;
429      }
430
431      //---------------------------------------------------------------
432
433      StdString CNc4DataOutput::getTimeStamp(void) const
434      {
435         const int buffer_size = 100;
436         time_t rawtime;
437         struct tm * timeinfo = NULL;
438         char buffer [buffer_size];
439
440         time ( &rawtime );
441         timeinfo = localtime ( &rawtime );
442         strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
443
444         return (StdString(buffer));
445      }
446     
447      //---------------------------------------------------------------
448     
449      void CNc4DataOutput::writeFieldData_ (const boost::shared_ptr<tree::CField>  field)
450      {
451         boost::shared_ptr<CGrid> grid =
452            CObjectFactory::GetObject<CGrid>(field->grid_ref.getValue());
453         boost::shared_ptr<CDomain> domain =
454            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue());
455         
456         if(SuperClass::type==MULTI_FILE) if (domain->isEmpty()) return;
457
458
459         StdString fieldid   = (!field->name.isEmpty())
460                             ? field->name.getValue() 
461                             : field->getBaseFieldReference()->getId();
462         boost::shared_ptr<xmlioserver::tree::CContext> context =
463            CObjectFactory::GetObject<xmlioserver::tree::CContext>
464               (CObjectFactory::GetCurrentContextId());
465                             
466         StdOStringStream oss;
467         oss << "time_" << field->operation.getValue()
468             << "_" << field->getRelFile()->output_freq.getValue();
469             
470         ARRAY(double, 1) field_data = field->getData();
471         ARRAY_CREATE(time_data, double, 1, [1]);
472         (*time_data)[0] = date::Time(*field->getLastWriteDate());
473         
474         if (grid->hasAxis()) // 3D
475         {
476            boost::shared_ptr<CAxis> axis = CObjectFactory::GetObject<CAxis>(grid->axis_ref.getValue());
477            ARRAY(double, 3) field_data3D (new CArray<double,3>(grid->getLocalShape()/*, boost::c_storage_order()*/));           
478            grid->outputField(field_data, field_data3D);
479            switch (SuperClass::type)
480           {
481              case (MULTI_FILE) :
482              {
483                 SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1);
484                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1);
485                 break ;
486              }
487              case (ONE_FILE) :
488              {
489                 std::vector<StdSize> start(3) ; 
490                 std::vector<StdSize> count(3) ;
491                 if (domain->isEmpty())
492                 {
493                   start[0]=0 ; start[1]=0 ; start[2]=0 ;
494                   count[0]=0 ; count[1]=0 ; start[2]=0 ;
495                 }
496                 else
497                 {
498//                 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 ;
499                   start[2]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
500                   count[2]=domain->zoom_ni_loc.getValue() ; count[1]=domain->zoom_nj_loc.getValue() ; count[0] = axis->size.getValue();
501                 }
502                 SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1,&start,&count );
503                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1 );
504                 break;
505              }
506            }
507           
508         }
509         else // 2D
510         {
511            ARRAY(double, 2) field_data2D (new CArray<double, 2>(grid->getLocalShape()/*, boost::c_storage_order()*/));
512            grid->outputField(field_data,  field_data2D);
513            switch (SuperClass::type)
514            {
515              case (MULTI_FILE) :
516              {
517                SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1);
518                SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1);
519                break;
520              }
521              case (ONE_FILE) :
522              {
523                 std::vector<StdSize> start(2) ; 
524                 std::vector<StdSize> count(2) ;
525                 if (domain->isEmpty())
526                 {
527                   start[0]=0 ; start[1]=0 ;
528                   count[0]=0 ; count[1]=0 ;
529                 }
530                 else
531                 {
532                   start[1]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ; 
533                   count[1]=domain->zoom_ni_loc.getValue() ; count[0]=domain->zoom_nj_loc.getValue() ; 
534                 }
535                 SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1,&start,&count);
536                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1);
537                 break;
538             
539              }
540            }
541         }
542      }
543
544      //---------------------------------------------------------------
545
546      void CNc4DataOutput::writeTimeAxis_
547                  (const boost::shared_ptr<tree::CField>    field,
548                   const boost::shared_ptr<date::CCalendar> cal)
549      {
550         StdOStringStream oss;
551         oss << "time_" << field->operation.getValue()
552             << "_" << field->getRelFile()->output_freq.getValue();
553
554         std::vector<StdString> dims;
555         StdString axisid = oss.str();
556         StdString timeid = StdString("time_counter");
557
558         dims.push_back(timeid);
559         if (!SuperClassWriter::varExist(axisid))
560         {
561            SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
562            this->writeTimeAxisAttributes
563               (axisid, cal->getId(),
564                StdString("seconds since ").append(cal->getInitDate().toString()),
565                cal->getInitDate().toString());
566         }
567
568      }
569
570      //---------------------------------------------------------------
571     
572      void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
573                                                   const StdString & calendar,
574                                                   const StdString & units,
575                                                   const StdString & time_origin,
576                                                   const StdString & standard_name,
577                                                   const StdString & long_name,
578                                                   const StdString & title)
579      {
580         SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
581         SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name);
582         SuperClassWriter::addAttribute("title",         title        , &axis_name);
583         SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name);
584         SuperClassWriter::addAttribute("units",         units        , &axis_name);
585         SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name);
586      }
587     
588      //---------------------------------------------------------------
589
590      void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
591                                               const StdString & axis,
592                                               const StdString & standard_name,
593                                               const StdString & long_name,
594                                               const StdString & units,
595                                               const StdString & nav_model)
596      {
597         SuperClassWriter::addAttribute("axis"         , axis         , &axis_name);
598         SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
599         SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name);
600         SuperClassWriter::addAttribute("units"        , units        , &axis_name);
601         SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name);
602      }
603
604      //---------------------------------------------------------------
605     
606      void CNc4DataOutput::writeLocalAttributes
607         (int ibegin, int ni, int jbegin, int nj, StdString domid)
608      {
609         SuperClassWriter::addAttribute(StdString("ibegin_").append(domid), ibegin);
610         SuperClassWriter::addAttribute(StdString("ni_"    ).append(domid), ni);
611         SuperClassWriter::addAttribute(StdString("jbegin_").append(domid), jbegin);
612         SuperClassWriter::addAttribute(StdString("nj_"    ).append(domid), nj);
613      }
614
615      //---------------------------------------------------------------
616
617      void CNc4DataOutput:: writeFileAttributes(const StdString & name,
618                                                const StdString & description,
619                                                const StdString & conventions,
620                                                const StdString & production,
621                                                const StdString & timeStamp)
622      {
623         SuperClassWriter::addAttribute("name"       , name);
624         SuperClassWriter::addAttribute("description", description);
625         SuperClassWriter::addAttribute("conventions", conventions);
626         SuperClassWriter::addAttribute("production" , production);
627         SuperClassWriter::addAttribute("timeStamp"  , timeStamp);
628      }
629
630      //---------------------------------------------------------------
631
632      void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
633                                               int data_dim,
634                                               int data_ni,
635                                               int data_nj,
636                                               int data_ibegin,
637                                               int data_jbegin)
638      {
639         SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name);
640         SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name);
641         SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name);
642         SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
643         SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
644      }
645
646      ///--------------------------------------------------------------
647
648   } // namespace io
649} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.