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

Last change on this file since 313 was 313, checked in by ymipsl, 12 years ago

Fortran attribut interface are now automaticaly generated.
Add get attribut fonctionnality from fortran.

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