Context Navigation

source: XIOS1/branches/xios-1.0-alpha1/src/output/nc4_data_output.cpp

Last change on this file was 292, checked in by ymipsl, 13 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
13	namespace 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.

Download in other formats: