Context Navigation

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

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

add "positive" attribute for vertical axis.

YM

File size: 31.7 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: