Context Navigation

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, 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: