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

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

mise en conformite norm CF pour les attribut de l'axe des temps.

YM

File size: 27.3 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            date::CDate initDate=cal->getInitDate() ;
563            StdOStringStream oss2;
564            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" "
565                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ;
566            StdString strInitdate=oss2.str() ;
567            this->writeTimeAxisAttributes
568               (axisid, cal->getType(),
569                StdString("seconds since ").append(strInitdate),
570                strInitdate);
571         }
572
573      }
574
575      //---------------------------------------------------------------
576     
577      void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
578                                                   const StdString & calendar,
579                                                   const StdString & units,
580                                                   const StdString & time_origin,
581                                                   const StdString & standard_name,
582                                                   const StdString & long_name,
583                                                   const StdString & title)
584      {
585         SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
586         SuperClassWriter::addAttribute("long_name",     long_name    , &axis_name);
587         SuperClassWriter::addAttribute("title",         title        , &axis_name);
588         SuperClassWriter::addAttribute("calendar",      calendar     , &axis_name);
589         SuperClassWriter::addAttribute("units",         units        , &axis_name);
590         SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name);
591      }
592     
593      //---------------------------------------------------------------
594
595      void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
596                                               const StdString & axis,
597                                               const StdString & standard_name,
598                                               const StdString & long_name,
599                                               const StdString & units,
600                                               const StdString & nav_model)
601      {
602         SuperClassWriter::addAttribute("axis"         , axis         , &axis_name);
603         SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
604         SuperClassWriter::addAttribute("long_name"    , long_name    , &axis_name);
605         SuperClassWriter::addAttribute("units"        , units        , &axis_name);
606         SuperClassWriter::addAttribute("nav_model"    , nav_model    , &axis_name);
607      }
608
609      //---------------------------------------------------------------
610     
611      void CNc4DataOutput::writeLocalAttributes
612         (int ibegin, int ni, int jbegin, int nj, StdString domid)
613      {
614         SuperClassWriter::addAttribute(StdString("ibegin_").append(domid), ibegin);
615         SuperClassWriter::addAttribute(StdString("ni_"    ).append(domid), ni);
616         SuperClassWriter::addAttribute(StdString("jbegin_").append(domid), jbegin);
617         SuperClassWriter::addAttribute(StdString("nj_"    ).append(domid), nj);
618      }
619
620      //---------------------------------------------------------------
621
622      void CNc4DataOutput:: writeFileAttributes(const StdString & name,
623                                                const StdString & description,
624                                                const StdString & conventions,
625                                                const StdString & production,
626                                                const StdString & timeStamp)
627      {
628         SuperClassWriter::addAttribute("name"       , name);
629         SuperClassWriter::addAttribute("description", description);
630         SuperClassWriter::addAttribute("conventions", conventions);
631         SuperClassWriter::addAttribute("production" , production);
632         SuperClassWriter::addAttribute("timeStamp"  , timeStamp);
633      }
634
635      //---------------------------------------------------------------
636
637      void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
638                                               int data_dim,
639                                               int data_ni,
640                                               int data_nj,
641                                               int data_ibegin,
642                                               int data_jbegin)
643      {
644         SuperClassWriter::addAttribute("data_dim"   , data_dim   , &mask_name);
645         SuperClassWriter::addAttribute("data_ni"    , data_ni    , &mask_name);
646         SuperClassWriter::addAttribute("data_nj"    , data_nj    , &mask_name);
647         SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
648         SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
649      }
650
651      ///--------------------------------------------------------------
652
653   } // namespace io
654} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.