Context Navigation

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

Last change on this file since 612 was 612, checked in by rlacroix, 9 years ago

Improve CF compliance: Write the "cell_methods" metadata.

Also try to use the time units defined by the UDUnits specification.

Property copyright set to
Software name : XIOS (Xml I/O Server)
http://forge.ipsl.jussieu.fr/ioserver
Creation date : January 2009
Licence : CeCCIL version2
see license file in root directory : Licence_CeCILL_V2-en.txt
or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
CNRS/IPSL (Institut Pierre Simon Laplace)
Project Manager : Yann Meurdesoif
yann.meurdesoif@cea.fr

File size: 79.0 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	#include "netCdfException.hpp"
13	#include "exception.hpp"
14
15	namespace xios
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, bool useClassicFormat,
32	MPI_Comm comm_file,bool multifile, bool isCollective)
33	: SuperClass()
34	, SuperClassWriter(filename, exist, useClassicFormat, &comm_file, multifile)
35	, comm_file(comm_file)
36	, filename(filename)
37	, isCollective(isCollective)
38	{
39	StdString timeid = StdString("time_counter");
40
41	SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE;
42
43	// if (!exist)
44	// SuperClassWriter::addDimension(timeid);
45	}
46
47
48	CNc4DataOutput::~CNc4DataOutput(void)
49	{ /* Ne rien faire de plus */ }
50
51	///--------------------------------------------------------------
52
53	const StdString & CNc4DataOutput::getFileName(void) const
54	{
55	return (this->filename);
56	}
57
58	//---------------------------------------------------------------
59
60	void CNc4DataOutput::writeDomain_(CDomain* domain)
61	{
62	if (domain->type == CDomain::type_attr::unstructured)
63	{
64	writeUnstructuredDomain(domain) ;
65	return ;
66	}
67
68	CContext* context = CContext::getCurrent() ;
69	CContextServer* server=context->server ;
70
71	if (domain->IsWritten(this->filename)) return;
72	domain->checkAttributes();
73
74	if (domain->isEmpty())
75	if (SuperClass::type==MULTI_FILE) return ;
76
77	std::vector<StdString> dim0, dim1;
78	StdString domid = (!domain->name.isEmpty())
79	? domain->name.getValue() : domain->getId();
80	StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
81
82
83	StdString dimXid, dimYid ;
84
85	switch (domain->type)
86	{
87	case CDomain::type_attr::curvilinear :
88	dimXid = StdString("x").append(appendDomid);
89	dimYid = StdString("y").append(appendDomid);
90	break ;
91	case CDomain::type_attr::regular :
92	dimXid = StdString("lon").append(appendDomid);
93	dimYid = StdString("lat").append(appendDomid);
94	break;
95	case CDomain::type_attr::unstructured :
96	dimXid = StdString("cell").append(appendDomid);
97	break;
98	}
99
100	string lonid,latid,bounds_lonid,bounds_latid ;
101	string areaId = "area" + appendDomid;
102	/*
103	StdString lonid_loc = (server->intraCommSize > 1)
104	? StdString("lon").append(appendDomid).append("_local")
105	: lonid;
106	StdString latid_loc = (server->intraCommSize > 1)
107	? StdString("lat").append(appendDomid).append("_local")
108	: latid;
109	*/
110
111	try
112	{
113	switch (SuperClass::type)
114	{
115	case (MULTI_FILE) :
116	{
117	// if (domain->isEmpty()) return;
118
119	if (server->intraCommSize > 1)
120	{
121	// SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
122	// SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
123	}
124
125	switch (domain->type)
126	{
127	case CDomain::type_attr::curvilinear :
128	dim0.push_back(dimYid); dim0.push_back(dimXid);
129	lonid = StdString("nav_lon").append(appendDomid);
130	latid = StdString("nav_lat").append(appendDomid);
131	break ;
132	case CDomain::type_attr::regular :
133	lonid = StdString("lon").append(appendDomid);
134	latid = StdString("lat").append(appendDomid);
135	dim0.push_back(dimYid);
136	dim1.push_back(dimXid);
137	break;
138	case CDomain::type_attr::unstructured :
139	lonid = StdString("lon").append(appendDomid);
140	latid = StdString("lat").append(appendDomid);
141	bounds_lonid=string("bounds_lon").append(appendDomid);
142	bounds_latid=string("bounds_lat").append(appendDomid);
143	dim0.push_back(dimXid);
144	break;
145	}
146
147	if (domain->type == CDomain::type_attr::unstructured)
148	{
149	SuperClassWriter::addDimension(dimXid, domain->nj_glo);
150	}
151	else
152	{
153	SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
154	SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv);
155	}
156
157	if (server->intraCommSize > 1)
158	{
159	if (domain->type != CDomain::type_attr::unstructured)
160	{
161	this->writeLocalAttributes(domain->zoom_ibegin_srv,
162	domain->zoom_ni_srv,
163	domain->zoom_jbegin_srv,
164	domain->zoom_nj_srv,
165	appendDomid);
166
167	if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv,
168	domain->zoom_ni_srv,
169	domain->zoom_jbegin_srv,
170	domain->zoom_nj_srv,
171	domain->ni_glo,domain->nj_glo,
172	server->intraCommRank,server->intraCommSize);
173	}
174	}
175
176	switch (domain->type)
177	{
178	case CDomain::type_attr::curvilinear :
179	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
180	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
181	break ;
182	case CDomain::type_attr::regular :
183	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
184	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
185	break ;
186	case CDomain::type_attr::unstructured :
187	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
188	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
189	}
190
191	this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid);
192	this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid);
193
194	dim0.clear();
195	if (domain->type != CDomain::type_attr::unstructured) dim0.push_back(dimYid);
196	dim0.push_back(dimXid);
197
198
199	// supress mask if (server->intraCommSize > 1)
200	// supress mask {
201	// supress mask SuperClassWriter::addVariable(maskid, NC_INT, dim0);
202	// supress mask
203	// supress mask this->writeMaskAttributes(maskid,
204	// supress mask domain->data_dim.getValue()/*,
205	// supress mask domain->data_ni.getValue(),
206	// supress mask domain->data_nj.getValue(),
207	// supress mask domain->data_ibegin.getValue(),
208	// supress mask domain->data_jbegin.getValue()*/);
209	// supress mask }
210
211	//SuperClassWriter::setDefaultValue(maskid, &dvm);
212
213	if (domain->hasArea)
214	{
215	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
216	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
217	}
218
219	SuperClassWriter::definition_end();
220
221	switch (domain->type)
222	{
223	case CDomain::type_attr::curvilinear :
224	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
225	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
226	break;
227	case CDomain::type_attr::regular :
228	CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
229	SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
230	CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
231	SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0);
232	break;
233	}
234
235	if (domain->hasArea)
236	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
237
238	SuperClassWriter::definition_start();
239
240	break;
241	}
242	case (ONE_FILE) :
243	{
244	SuperClassWriter::addDimension(dimXid, domain->zoom_ni.getValue());
245	SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue());
246
247	switch (domain->type)
248	{
249	case CDomain::type_attr::curvilinear :
250	dim0.push_back(dimYid); dim0.push_back(dimXid);
251	lonid = StdString("nav_lon").append(appendDomid);
252	latid = StdString("nav_lat").append(appendDomid);
253	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
254	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
255	break;
256
257	case CDomain::type_attr::regular :
258	dim0.push_back(dimYid);
259	dim1.push_back(dimXid);
260	lonid = StdString("lon").append(appendDomid);
261	latid = StdString("lat").append(appendDomid);
262	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
263	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
264	break;
265	}
266
267	if (domain->hasArea)
268	{
269	dim0.clear();
270	dim0.push_back(dimYid); dim0.push_back(dimXid);
271	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
272	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
273	dim0.clear();
274	}
275
276	this->writeAxisAttributes
277	(lonid, "X", "longitude", "Longitude", "degrees_east", domid);
278	this->writeAxisAttributes
279	(latid, "Y", "latitude", "Latitude", "degrees_north", domid);
280
281	SuperClassWriter::definition_end();
282
283	switch (domain->type)
284	{
285	case CDomain::type_attr::curvilinear :
286	{
287	std::vector<StdSize> start(2) ;
288	std::vector<StdSize> count(2) ;
289	if (domain->isEmpty())
290	{
291	start[0]=0 ; start[1]=0 ;
292	count[0]=0 ; count[1]=0 ;
293	}
294	else
295	{
296	start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
297	count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
298	}
299
300	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
301	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
302	break;
303	}
304	case CDomain::type_attr::regular :
305	{
306	std::vector<StdSize> start(1) ;
307	std::vector<StdSize> count(1) ;
308	if (domain->isEmpty())
309	{
310	start[0]=0 ;
311	count[0]=0 ;
312	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
313	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); }
314	else
315	{
316	start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
317	count[0]=domain->zoom_nj_srv ;
318	CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
319	SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
320
321	start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ;
322	count[0]=domain->zoom_ni_srv ;
323	CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
324	SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
325	}
326	break;
327	}
328	}
329
330	if (domain->hasArea)
331	{
332	std::vector<StdSize> start(2);
333	std::vector<StdSize> count(2);
334
335	if (domain->isEmpty())
336	{
337	start[0] = 0; start[1] = 0;
338	count[0] = 0; count[1] = 0;
339	}
340	else
341	{
342	start[1] = domain->zoom_ibegin_srv - domain->zoom_ibegin.getValue();
343	start[0] = domain->zoom_jbegin_srv - domain->zoom_jbegin.getValue();
344	count[1] = domain->zoom_ni_srv;
345	count[0] = domain->zoom_nj_srv;
346	}
347
348	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
349	}
350
351	SuperClassWriter::definition_start();
352	break;
353	}
354	default :
355	ERROR("CNc4DataOutput::writeDomain(domain)",
356	<< "[ type = " << SuperClass::type << "]"
357	<< " not implemented yet !");
358	}
359	}
360	catch (CNetCdfException& e)
361	{
362	StdString msg("On writing the domain : ");
363	msg.append(domid); msg.append("\n");
364	msg.append("In the context : ");
365	msg.append(context->getId()); msg.append("\n");
366	msg.append(e.what());
367	ERROR("CNc4DataOutput::writeDomain_(CDomain* domain)", << msg);
368	}
369
370	domain->addRelFile(this->filename);
371	}
372
373	void CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)
374	{
375	CContext* context = CContext::getCurrent() ;
376	CContextServer* server=context->server ;
377
378	if (domain->IsWritten(this->filename)) return;
379	domain->checkAttributes();
380
381	if (domain->isEmpty())
382	if (SuperClass::type==MULTI_FILE) return ;
383
384	std::vector<StdString> dim0, dim1;
385	StdString domid = (!domain->name.isEmpty())
386	? domain->name.getValue() : domain->getId();
387	StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
388
389
390	StdString dimXid = StdString("cell").append(appendDomid);
391	StdString dimVertId = StdString("nvertex").append(appendDomid);
392
393	string lonid,latid,bounds_lonid,bounds_latid ;
394	string areaId = "area" + appendDomid;
395
396	try
397	{
398	switch (SuperClass::type)
399	{
400	case (MULTI_FILE) :
401	{
402	lonid = StdString("lon").append(appendDomid);
403	latid = StdString("lat").append(appendDomid);
404	dim0.push_back(dimXid);
405
406	SuperClassWriter::addDimension(dimXid, domain->zoom_nj_srv);
407	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
408	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
409
410	bounds_lonid = StdString("bounds_lon").append(appendDomid);
411	bounds_latid = StdString("bounds_lat").append(appendDomid);
412
413
414	this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid);
415	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
416	this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid);
417	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
418	if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
419	dim0.clear();
420	if (domain->hasBounds)
421	{
422	dim0.push_back(dimXid);
423	dim0.push_back(dimVertId);
424	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
425	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
426	}
427
428	dim0.clear();
429	dim0.push_back(dimXid);
430
431	if (domain->hasArea)
432	{
433	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
434	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
435	}
436
437	SuperClassWriter::definition_end();
438
439	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
440	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
441
442	if (domain->hasBounds)
443	{
444	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
445	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
446	}
447
448	if (domain->hasArea)
449	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
450
451	SuperClassWriter::definition_start();
452	break ;
453	}
454
455	case (ONE_FILE) :
456	{
457	lonid = StdString("lon").append(appendDomid);
458	latid = StdString("lat").append(appendDomid);
459	bounds_lonid = StdString("bounds_lon").append(appendDomid);
460	bounds_latid = StdString("bounds_lat").append(appendDomid);
461	dim0.push_back(dimXid);
462	SuperClassWriter::addDimension(dimXid, domain->nj_glo);
463	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
464	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
465	this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid);
466	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
467	this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid);
468	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
469	if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
470	dim0.clear();
471
472	if (domain->hasBounds)
473	{
474	dim0.push_back(dimXid);
475	dim0.push_back(dimVertId);
476	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
477	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
478	}
479
480	if (domain->hasArea)
481	{
482	dim0.clear();
483	dim0.push_back(dimXid);
484	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
485	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
486	}
487
488	SuperClassWriter::definition_end();
489
490	std::vector<StdSize> start(1), startBounds(2) ;
491	std::vector<StdSize> count(1), countBounds(2) ;
492	if (domain->isEmpty())
493	{
494	start[0]=0 ;
495	count[0]=0 ;
496	startBounds[1]=0 ;
497	countBounds[1]=domain->nvertex ;
498	startBounds[0]=0 ;
499	countBounds[0]=0 ;
500	}
501	else
502	{
503	start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;
504	count[0]=domain->zoom_nj_srv ;
505	startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;
506	startBounds[1]=0 ;
507	countBounds[0]=domain->zoom_nj_srv ;
508	countBounds[1]=domain->nvertex ;
509	}
510	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
511	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
512	if (domain->hasBounds)
513	{
514	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
515	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds);
516	}
517
518	if (domain->hasArea)
519	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
520
521	SuperClassWriter::definition_start();
522
523	break;
524	}
525	default :
526	ERROR("CNc4DataOutput::writeDomain(domain)",
527	<< "[ type = " << SuperClass::type << "]"
528	<< " not implemented yet !");
529	}
530	}
531	catch (CNetCdfException& e)
532	{
533	StdString msg("On writing the domain : ");
534	msg.append(domid); msg.append("\n");
535	msg.append("In the context : ");
536	msg.append(context->getId()); msg.append("\n");
537	msg.append(e.what());
538	ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
539	}
540	domain->addRelFile(this->filename);
541	}
542	//--------------------------------------------------------------
543
544	void CNc4DataOutput::writeAxis_(CAxis* axis)
545	{
546	if (axis->IsWritten(this->filename)) return;
547	axis->checkAttributes();
548	int zoom_size_srv = axis->zoom_size_srv;
549	int zoom_begin_srv = axis->zoom_begin_srv;
550	int zoom_size = (MULTI_FILE == SuperClass::type) ? zoom_size_srv : axis->zoom_size;
551	int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv : axis->zoom_begin;
552
553
554	std::vector<StdString> dims;
555	StdString axisid = !axis->name.isEmpty() ? axis->name.getValue() : axis->getId();
556	try
557	{
558	SuperClassWriter::addDimension(axisid, zoom_size);
559	dims.push_back(axisid);
560
561	switch (SuperClass::type)
562	{
563	case MULTI_FILE:
564	case ONE_FILE:
565	{
566	SuperClassWriter::addVariable(axisid, NC_FLOAT, dims);
567
568	SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid);
569
570	if (!axis->name.isEmpty())
571	SuperClassWriter::addAttribute("name", axis->name.getValue(), &axisid);
572
573	if (!axis->standard_name.isEmpty())
574	SuperClassWriter::addAttribute("standard_name", axis->standard_name.getValue(), &axisid);
575
576	if (!axis->long_name.isEmpty())
577	SuperClassWriter::addAttribute("long_name", axis->long_name.getValue(), &axisid);
578
579	if (!axis->unit.isEmpty())
580	SuperClassWriter::addAttribute("units", axis->unit.getValue(), &axisid);
581
582	if (!axis->positive.isEmpty())
583	if (axis->positive == CAxis::positive_attr::up) SuperClassWriter::addAttribute("positive", string("up"), &axisid);
584	else SuperClassWriter::addAttribute("positive", string("down"), &axisid);
585
586	StdString axisBoundsId = axisid + "_bounds";
587	if (!axis->bounds.isEmpty())
588	{
589	dims.push_back("axis_nbounds");
590	SuperClassWriter::addVariable(axisBoundsId, NC_FLOAT, dims);
591	SuperClassWriter::addAttribute("bounds", axisBoundsId, &axisid);
592	}
593
594	SuperClassWriter::definition_end();
595
596	CArray<double,1> axis_value(zoom_size);
597	for (int i = 0; i < zoom_size_srv; i++) axis_value(i) = axis->value(i + zoom_begin_srv);
598	SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
599
600	if (!axis->bounds.isEmpty())
601	{
602	CArray<double,2> axisBounds(zoom_size, 2);
603	for (int i = 0; i < zoom_size_srv; i++)
604	{
605	axisBounds(i, 0) = axis->bounds(i + zoom_begin_srv, 0);
606	axisBounds(i, 1) = axis->bounds(i + zoom_begin_srv, 1);
607	}
608	SuperClassWriter::writeData(axisBounds, axisBoundsId, isCollective, 0);
609	}
610
611	SuperClassWriter::definition_start();
612
613	break;
614	}
615	default :
616	ERROR("CNc4DataOutput::writeDomain(domain)",
617	<< "[ type = " << SuperClass::type << "]"
618	<< " not implemented yet !");
619	}
620	}
621	catch (CNetCdfException& e)
622	{
623	StdString msg("On writing the axis : ");
624	msg.append(axisid); msg.append("\n");
625	msg.append("In the context : ");
626	CContext* context = CContext::getCurrent() ;
627	msg.append(context->getId()); msg.append("\n");
628	msg.append(e.what());
629	ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)", << msg);
630	}
631	axis->addRelFile(this->filename);
632	}
633
634	void CNc4DataOutput::writeTimeDimension_(void)
635	{
636	try
637	{
638	SuperClassWriter::addDimension("time_counter");
639	SuperClassWriter::addDimension("time_bounds", 2);
640	}
641	catch (CNetCdfException& e)
642	{
643	StdString msg("On writing time dimension : time_couter, time_bounds \n");
644	msg.append("In the context : ");
645	CContext* context = CContext::getCurrent() ;
646	msg.append(context->getId()); msg.append("\n");
647	msg.append(e.what());
648	ERROR("CNc4DataOutput::writeTimeDimension_(void)", << msg);
649	}
650	}
651	//--------------------------------------------------------------
652
653	void CNc4DataOutput::writeField_(CField* field)
654	{
655	CContext* context = CContext::getCurrent() ;
656	CContextServer* server=context->server ;
657
658	std::vector<StdString> dims, coodinates;
659	CGrid* grid = field->grid;
660	if (!grid->doGridHaveDataToWrite())
661	if (SuperClass::type==MULTI_FILE) return ;
662
663	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
664	int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
665	std::vector<StdString> domainList = grid->getDomainList();
666	std::vector<StdString> axisList = grid->getAxisList();
667
668	StdString timeid = StdString("time_counter");
669	StdString dimXid,dimYid;
670	std::deque<StdString> dimIdList, dimCoordList;
671	bool hasArea = false;
672	StdString cellMeasures = "area:";
673
674	for (int i = 0; i < numElement; ++i)
675	{
676	if (axisDomainOrder(i))
677	{
678	CDomain* domain = CDomain::get(domainList[idxDomain]);
679	StdString domid = (!domain->name.isEmpty())
680	? domain->name.getValue() : domain->getId();
681	StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
682	switch (domain->type)
683	{
684	case CDomain::type_attr::curvilinear :
685	dimXid = StdString("x").append(appendDomid);
686	dimIdList.push_back(dimXid);
687	dimYid = StdString("y").append(appendDomid);
688	dimIdList.push_back(dimYid);
689	dimCoordList.push_back(StdString("nav_lon").append(appendDomid));
690	dimCoordList.push_back(StdString("nav_lat").append(appendDomid));
691	break ;
692	case CDomain::type_attr::regular :
693	dimXid = StdString("lon").append(appendDomid);
694	dimIdList.push_back(dimXid);
695	dimYid = StdString("lat").append(appendDomid);
696	dimIdList.push_back(dimYid);
697	break ;
698	case CDomain::type_attr::unstructured :
699	dimXid = StdString("cell").append(appendDomid);
700	dimIdList.push_back(dimXid);
701	dimCoordList.push_back(StdString("lon").append(appendDomid));
702	dimCoordList.push_back(StdString("lat").append(appendDomid));
703	break ;
704	}
705	if (domain->hasArea)
706	{
707	hasArea = true;
708	cellMeasures += " area" + appendDomid;
709	}
710	++idxDomain;
711	}
712	else
713	{
714	CAxis* axis = CAxis::get(axisList[idxAxis]);
715	StdString axisid = (!axis->name.isEmpty())
716	? axis->name.getValue() : axis->getId();
717	dimIdList.push_back(axisid);
718	dimCoordList.push_back(axisid);
719	++idxAxis;
720	}
721	}
722
723	/*
724	StdString lonid_loc = (server->intraCommSize > 1)
725	? StdString("lon").append(appendDomid).append("_local")
726	: lonid;
727	StdString latid_loc = (server->intraCommSize > 1)
728	? StdString("lat").append(appendDomid).append("_local")
729	: latid;
730	*/
731	StdString fieldid = (!field->name.isEmpty())
732	? field->name.getValue() : field->getBaseFieldReference()->getId();
733
734	// unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
735	// bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
736	// bool isCurvilinear = domain->isCurvilinear ;
737
738	nc_type type ;
739	if (field->prec.isEmpty()) type = NC_FLOAT ;
740	else
741	{
742	if (field->prec==2) type = NC_SHORT ;
743	else if (field->prec==4) type = NC_FLOAT ;
744	else if (field->prec==8) type = NC_DOUBLE ;
745	}
746
747	bool wtime = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once);
748
749	if (wtime)
750	{
751
752	//StdOStringStream oss;
753	// oss << "time_" << field->operation.getValue()
754	// << "_" << field->getRelFile()->output_freq.getValue();
755	//oss
756	if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
757	else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
758	dims.push_back(timeid);
759	}
760
761	while (!dimIdList.empty())
762	{
763	dims.push_back(dimIdList.back());
764	dimIdList.pop_back();
765	}
766
767	while (!dimCoordList.empty())
768	{
769	coodinates.push_back(dimCoordList.back());
770	dimCoordList.pop_back();
771	}
772
773	try
774	{
775	SuperClassWriter::addVariable(fieldid, type, dims);
776
777	if (!field->standard_name.isEmpty())
778	SuperClassWriter::addAttribute
779	("standard_name", field->standard_name.getValue(), &fieldid);
780
781	if (!field->long_name.isEmpty())
782	SuperClassWriter::addAttribute
783	("long_name", field->long_name.getValue(), &fieldid);
784
785	if (!field->unit.isEmpty())
786	SuperClassWriter::addAttribute
787	("units", field->unit.getValue(), &fieldid);
788
789	if (!field->valid_min.isEmpty())
790	SuperClassWriter::addAttribute
791	("valid_min", field->valid_min.getValue(), &fieldid);
792
793	if (!field->valid_max.isEmpty())
794	SuperClassWriter::addAttribute
795	("valid_max", field->valid_max.getValue(), &fieldid);
796
797	if (!field->scale_factor.isEmpty())
798	SuperClassWriter::addAttribute
799	("scale_factor", field->scale_factor.getValue(), &fieldid);
800
801	if (!field->add_offset.isEmpty())
802	SuperClassWriter::addAttribute
803	("add_offset", field->add_offset.getValue(), &fieldid);
804
805	SuperClassWriter::addAttribute
806	("online_operation", field->operation.getValue(), &fieldid);
807
808	// write child variables as attributes
809
810
811	vector<CVariable*> listVars = field->getAllVariables() ;
812	for (vector<CVariable>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(it, fieldid) ;
813
814
815	if (wtime)
816	{
817	CDuration duration = field->freq_op.getValue();
818	duration.solveTimeStep(*context->calendar);
819	StdString freqOpStr = duration.toStringUDUnits();
820	SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
821
822	duration = field->getRelFile()->output_freq.getValue();
823	duration.solveTimeStep(*context->calendar);
824	SuperClassWriter::addAttribute("interval_write", duration.toStringUDUnits(), &fieldid);
825
826	StdString cellMethods = coodinates.front() + ": ";
827	if (field->operation.getValue() == "instant") cellMethods += "point";
828	else if (field->operation.getValue() == "average") cellMethods += "mean";
829	else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
830	else cellMethods += field->operation;
831	cellMethods += " (interval: " + freqOpStr + ")";
832	SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
833	}
834
835	if (hasArea)
836	SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
837
838	if (!field->default_value.isEmpty())
839	{
840	double default_value = field->default_value.getValue();
841	float fdefault_value = (float)default_value;
842	if (type == NC_DOUBLE)
843	SuperClassWriter::setDefaultValue(fieldid, &default_value);
844	else
845	SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
846	}
847	else
848	SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
849
850	if (field->compression_level.isEmpty())
851	field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
852	SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
853
854	{ // Ecriture des coordonnÃ©es
855
856	StdString coordstr; //boost::algorithm::join(coodinates, " ")
857	std::vector<StdString>::iterator
858	itc = coodinates.begin(), endc = coodinates.end();
859
860	for (; itc!= endc; itc++)
861	{
862	StdString & coord = *itc;
863	if (itc+1 != endc)
864	coordstr.append(coord).append(" ");
865	else coordstr.append(coord);
866	}
867
868	SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
869
870	}
871	}
872	catch (CNetCdfException& e)
873	{
874	StdString msg("On writing field : ");
875	msg.append(fieldid); msg.append("\n");
876	msg.append("In the context : ");
877	msg.append(context->getId()); msg.append("\n");
878	msg.append(e.what());
879	ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
880	}
881	}
882
883
884	// void CNc4DataOutput::writeField_(CField* field)
885	// {
886	// CContext* context = CContext::getCurrent() ;
887	// CContextServer* server=context->server ;
888	//
889	// std::vector<StdString> dims, coodinates;
890	// CGrid* grid = field->grid;
891	// CDomain* domain = grid->domain;
892	//
893	// if (domain->isEmpty())
894	// if (SuperClass::type==MULTI_FILE) return ;
895	//
896	// StdString timeid = StdString("time_counter");
897	// StdString domid = (!domain->name.isEmpty())
898	// ? domain->name.getValue() : domain->getId();
899	// StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
900	//
901	//// bool isCurvilinear = domain->isCurvilinear ;
902	//// bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ;
903	//
904	// StdString dimXid,dimYid ;
905	//
906	// switch (domain->type)
907	// {
908	// case CDomain::type_attr::curvilinear :
909	// dimXid = StdString("x").append(appendDomid);
910	// dimYid = StdString("y").append(appendDomid);
911	// break ;
912	// case CDomain::type_attr::regular :
913	// dimXid = StdString("lon").append(appendDomid);
914	// dimYid = StdString("lat").append(appendDomid);
915	// break ;
916	// case CDomain::type_attr::unstructured :
917	// dimXid = StdString("cell").append(appendDomid);
918	// break ;
919	// }
920	//
921	///*
922	// StdString lonid_loc = (server->intraCommSize > 1)
923	// ? StdString("lon").append(appendDomid).append("_local")
924	// : lonid;
925	// StdString latid_loc = (server->intraCommSize > 1)
926	// ? StdString("lat").append(appendDomid).append("_local")
927	// : latid;
928	//*/
929	// StdString fieldid = (!field->name.isEmpty())
930	// ? field->name.getValue() : field->getBaseFieldReference()->getId();
931	//
932	//// unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
933	//// bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
934	//// bool isCurvilinear = domain->isCurvilinear ;
935	//
936	// nc_type type ;
937	// if (field->prec.isEmpty()) type = NC_FLOAT ;
938	// else
939	// {
940	// if (field->prec==2) type = NC_SHORT ;
941	// else if (field->prec==4) type = NC_FLOAT ;
942	// else if (field->prec==8) type = NC_DOUBLE ;
943	// }
944	//
945	// bool wtime = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once);
946	//
947	// if (wtime)
948	// {
949	//
950	// //StdOStringStream oss;
951	// // oss << "time_" << field->operation.getValue()
952	// // << "_" << field->getRelFile()->output_freq.getValue();
953	// //oss
954	// if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
955	// else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
956	// dims.push_back(timeid);
957	// }
958	//
959	// std::vector<StdString> axisList = grid->getAxisList();
960	// if (!axisList.empty())
961	// {
962	// std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end();
963	// for (; itAxis != iteAxis; ++itAxis)
964	// {
965	// CAxis* axis = CAxis::get(*itAxis);
966	// StdString axisid = (!axis->name.isEmpty())
967	// ? axis->name.getValue() : axis->getId();
968	//
969	// dims.push_back(axisid);
970	// coodinates.push_back(axisid);
971	// }
972	// }
973	//
974	// switch (domain->type)
975	// {
976	// case CDomain::type_attr::curvilinear :
977	// coodinates.push_back(StdString("nav_lon").append(appendDomid));
978	// coodinates.push_back(StdString("nav_lat").append(appendDomid));
979	// break;
980	// case CDomain::type_attr::regular :
981	// case CDomain::type_attr::unstructured :
982	// coodinates.push_back(StdString("lon").append(appendDomid));
983	// coodinates.push_back(StdString("lat").append(appendDomid));
984	// break;
985	// }
986	//
987	// if ( domain->type == CDomain::type_attr::curvilinear \|\| domain->type == CDomain::type_attr::regular)dims.push_back(dimYid);
988	// dims.push_back(dimXid);
989	//
990	// try
991	// {
992	// SuperClassWriter::addVariable(fieldid, type, dims);
993	//
994	// if (!field->standard_name.isEmpty())
995	// SuperClassWriter::addAttribute
996	// ("standard_name", field->standard_name.getValue(), &fieldid);
997	//
998	// if (!field->long_name.isEmpty())
999	// SuperClassWriter::addAttribute
1000	// ("long_name", field->long_name.getValue(), &fieldid);
1001	//
1002	// if (!field->unit.isEmpty())
1003	// SuperClassWriter::addAttribute
1004	// ("units", field->unit.getValue(), &fieldid);
1005	//
1006	// if (!field->valid_min.isEmpty())
1007	// SuperClassWriter::addAttribute
1008	// ("valid_min", field->valid_min.getValue(), &fieldid);
1009	//
1010	// if (!field->valid_max.isEmpty())
1011	// SuperClassWriter::addAttribute
1012	// ("valid_max", field->valid_max.getValue(), &fieldid);
1013	//
1014	// if (!field->scale_factor.isEmpty())
1015	// SuperClassWriter::addAttribute
1016	// ("scale_factor", field->scale_factor.getValue(), &fieldid);
1017	//
1018	// if (!field->add_offset.isEmpty())
1019	// SuperClassWriter::addAttribute
1020	// ("add_offset", field->add_offset.getValue(), &fieldid);
1021	//
1022	// SuperClassWriter::addAttribute
1023	// ("online_operation", field->operation.getValue(), &fieldid);
1024	//
1025	// // write child variables as attributes
1026	//
1027	//
1028	// vector<CVariable*> listVars = field->getAllVariables() ;
1029	// for (vector<CVariable>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(it, fieldid) ;
1030	//
1031	//
1032	// if (wtime)
1033	// {
1034	// CDuration duration = field->freq_op.getValue();
1035	// duration.solveTimeStep(*(context->calendar));
1036	// SuperClassWriter::addAttribute("interval_operation", duration.toStringUDUnits(), &fieldid);
1037	//
1038	// duration = field->getRelFile()->output_freq.getValue();
1039	// duration.solveTimeStep(*(context->calendar));
1040	// SuperClassWriter::addAttribute("interval_write", duration.toStringUDUnits(), &fieldid);
1041	// }
1042	//
1043	// if (!field->default_value.isEmpty())
1044	// {
1045	// double default_value = field->default_value.getValue();
1046	// float fdefault_value = (float)default_value;
1047	// if (type == NC_DOUBLE)
1048	// SuperClassWriter::setDefaultValue(fieldid, &default_value);
1049	// else
1050	// SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1051	// }
1052	// else
1053	// SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1054	//
1055	// { // Ecriture des coordonnÃ©es
1056	//
1057	// StdString coordstr; //boost::algorithm::join(coodinates, " ")
1058	// std::vector<StdString>::iterator
1059	// itc = coodinates.begin(), endc = coodinates.end();
1060	//
1061	// for (; itc!= endc; itc++)
1062	// {
1063	// StdString & coord = *itc;
1064	// if (itc+1 != endc)
1065	// coordstr.append(coord).append(" ");
1066	// else coordstr.append(coord);
1067	// }
1068	//
1069	// SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1070	//
1071	// }
1072	// }
1073	// catch (CNetCdfException& e)
1074	// {
1075	// StdString msg("On writing field : ");
1076	// msg.append(fieldid); msg.append("\n");
1077	// msg.append("In the context : ");
1078	// msg.append(context->getId()); msg.append("\n");
1079	// msg.append(e.what());
1080	// ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1081	// }
1082	// }
1083
1084	//--------------------------------------------------------------
1085
1086	void CNc4DataOutput::writeFile_ (CFile* file)
1087	{
1088	StdString filename = (!file->name.isEmpty())
1089	? file->name.getValue() : file->getId();
1090	StdString description = (!file->description.isEmpty())
1091	? file->description.getValue()
1092	: StdString("Created by xios");
1093
1094	singleDomain = (file->nbDomains == 1);
1095
1096	try
1097	{
1098	this->writeFileAttributes(filename, description,
1099	StdString("CF-1.1"),
1100	StdString("An IPSL model"),
1101	this->getTimeStamp());
1102
1103	if (file->nbAxis >= 1)
1104	SuperClassWriter::addDimension("axis_nbounds", 2);
1105	}
1106	catch (CNetCdfException& e)
1107	{
1108	StdString msg("On writing file : ");
1109	msg.append(filename); msg.append("\n");
1110	msg.append("In the context : ");
1111	CContext* context = CContext::getCurrent() ;
1112	msg.append(context->getId()); msg.append("\n");
1113	msg.append(e.what());
1114	ERROR("CNc4DataOutput::writeFile_ (CFile* file)", << msg);
1115	}
1116	}
1117
1118	void CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)
1119	{
1120	string name ;
1121	if (!var->name.isEmpty()) name=var->name ;
1122	else if (var->hasId()) name=var->getId() ;
1123	else return ;
1124
1125	try
1126	{
1127	if (var->type.getValue() == CVariable::type_attr::t_int \|\| var->type.getValue() == CVariable::type_attr::t_int32)
1128	addAttribute(name, var->getData<int>(), &fieldId);
1129	else if (var->type.getValue() == CVariable::type_attr::t_int16)
1130	addAttribute(name, var->getData<short int>(), &fieldId);
1131	else if (var->type.getValue() == CVariable::type_attr::t_float)
1132	addAttribute(name, var->getData<float>(), &fieldId);
1133	else if (var->type.getValue() == CVariable::type_attr::t_double)
1134	addAttribute(name, var->getData<double>(), &fieldId);
1135	else if (var->type.getValue() == CVariable::type_attr::t_string)
1136	addAttribute(name, var->getData<string>(), &fieldId);
1137	else
1138	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)",
1139	<< "Unsupported variable of type " << var->type.getStringValue());
1140	}
1141	catch (CNetCdfException& e)
1142	{
1143	StdString msg("On writing attributes of variable with name : ");
1144	msg.append(name); msg.append("in the field "); msg.append(fieldId); msg.append("\n");
1145	msg.append("In the context : ");
1146	CContext* context = CContext::getCurrent() ;
1147	msg.append(context->getId()); msg.append("\n");
1148	msg.append(e.what());
1149	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)", << msg);
1150	}
1151	}
1152
1153	void CNc4DataOutput::writeAttribute_ (CVariable* var)
1154	{
1155	string name ;
1156	if (!var->name.isEmpty()) name=var->name ;
1157	else if (var->hasId()) name=var->getId() ;
1158	else return ;
1159	try
1160	{
1161	if (var->type.getValue() == CVariable::type_attr::t_int \|\| var->type.getValue() == CVariable::type_attr::t_int32)
1162	addAttribute(name, var->getData<int>());
1163	else if (var->type.getValue() == CVariable::type_attr::t_int16)
1164	addAttribute(name, var->getData<short int>());
1165	else if (var->type.getValue() == CVariable::type_attr::t_float)
1166	addAttribute(name, var->getData<float>());
1167	else if (var->type.getValue() == CVariable::type_attr::t_double)
1168	addAttribute(name, var->getData<double>());
1169	else if (var->type.getValue() == CVariable::type_attr::t_string)
1170	addAttribute(name, var->getData<string>());
1171	else
1172	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)",
1173	<< "Unsupported variable of type " << var->type.getStringValue());
1174	}
1175	catch (CNetCdfException& e)
1176	{
1177	StdString msg("On writing attributes of variable with name : ");
1178	msg.append(name); msg.append("\n");
1179	msg.append("In the context : ");
1180	CContext* context = CContext::getCurrent() ;
1181	msg.append(context->getId()); msg.append("\n");
1182	msg.append(e.what());
1183	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)", << msg);
1184	}
1185	}
1186
1187	void CNc4DataOutput::syncFile_ (void)
1188	{
1189	try
1190	{
1191	SuperClassWriter::sync() ;
1192	}
1193	catch (CNetCdfException& e)
1194	{
1195	StdString msg("On synchronizing the write among processes");
1196	msg.append("In the context : ");
1197	CContext* context = CContext::getCurrent() ;
1198	msg.append(context->getId()); msg.append("\n");
1199	msg.append(e.what());
1200	ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1201	}
1202	}
1203
1204	void CNc4DataOutput::closeFile_ (void)
1205	{
1206	try
1207	{
1208	SuperClassWriter::close() ;
1209	}
1210	catch (CNetCdfException& e)
1211	{
1212	StdString msg("On closing file");
1213	msg.append("In the context : ");
1214	CContext* context = CContext::getCurrent() ;
1215	msg.append(context->getId()); msg.append("\n");
1216	msg.append(e.what());
1217	ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1218	}
1219
1220	}
1221
1222	//---------------------------------------------------------------
1223
1224	StdString CNc4DataOutput::getTimeStamp(void) const
1225	{
1226	const int buffer_size = 100;
1227	time_t rawtime;
1228	struct tm * timeinfo = NULL;
1229	char buffer [buffer_size];
1230
1231	time ( &rawtime );
1232	timeinfo = localtime ( &rawtime );
1233	strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
1234
1235	return (StdString(buffer));
1236	}
1237
1238	//---------------------------------------------------------------
1239
1240	void CNc4DataOutput::writeFieldData_ (CField* field)
1241	{
1242	CContext* context = CContext::getCurrent() ;
1243	// if (field->getRelFile()->isSyncTime()) SuperClassWriter::sync() ;
1244	CContextServer* server=context->server ;
1245
1246	CGrid* grid = field->grid ;
1247
1248	if (!grid->doGridHaveDataToWrite())
1249	if (SuperClass::type==MULTI_FILE \|\| !isCollective) return ;
1250
1251	StdString fieldid = (!field->name.isEmpty())
1252	? field->name.getValue()
1253	: field->getBaseFieldReference()->getId();
1254
1255	StdOStringStream oss;
1256	string timeAxisId ;
1257	if (field->foperation->timeType() == func::CFunctor::instant) timeAxisId="time_instant" ;
1258	else if (field->foperation->timeType() == func::CFunctor::centered) timeAxisId="time_centered" ;
1259
1260	StdString timeBoundId("time_counter_bounds");
1261
1262	StdString timeAxisBoundId;
1263	if (field->foperation->timeType() == func::CFunctor::instant) timeAxisBoundId="time_instant_bounds" ;
1264	else if (field->foperation->timeType() == func::CFunctor::centered) timeAxisBoundId="time_centered_bounds" ;
1265
1266	CArray<double,1> time_data(1) ;
1267	CArray<double,1> time_counter(1) ;
1268	CArray<double,1> time_counter_bound(2);
1269	CArray<double,1> time_data_bound(2);
1270
1271	bool wtime = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once));
1272
1273	if (wtime)
1274	{
1275	time_counter(0)= (Time(field->last_Write_srv) + Time(field->lastlast_Write_srv)) / 2;
1276	if (field->foperation->timeType() == func::CFunctor::instant)
1277	time_data(0) = Time(*field->last_Write_srv);
1278	else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0);
1279
1280	time_counter_bound(0) = Time(*field->lastlast_Write_srv);
1281	time_counter_bound(1) = Time(*field->last_Write_srv);
1282	if (field->foperation->timeType() == func::CFunctor::instant)
1283	time_data_bound(0) = time_data_bound(1) = Time(*field->last_Write_srv);
1284	else if (field->foperation->timeType() == func::CFunctor::centered)
1285	{
1286	time_data_bound(0) = time_counter_bound(0);
1287	time_data_bound(1) = time_counter_bound(1);
1288	}
1289	}
1290
1291	bool isRoot ;
1292	if (server->intraCommRank==0) isRoot=true ;
1293	else isRoot=false ;
1294
1295	if (!field->scale_factor.isEmpty() \|\| !field->add_offset.isEmpty())
1296	{
1297	double scaleFactor=1. ;
1298	double addOffset=0. ;
1299	if (!field->scale_factor.isEmpty()) scaleFactor=field->scale_factor ;
1300	if (!field->add_offset.isEmpty()) addOffset=field->add_offset ;
1301	field->scaleFactorAddOffset(scaleFactor,addOffset) ;
1302	}
1303
1304	try
1305	{
1306	CArray<double,1> fieldData(grid->getWrittenDataSize());
1307	if (!field->default_value.isEmpty()) fieldData = field->default_value;
1308	field->outputField(fieldData);
1309	if (!field->prec.isEmpty() && field->prec==2) fieldData=round(fieldData) ;
1310
1311	switch (SuperClass::type)
1312	{
1313	case (MULTI_FILE) :
1314	{
1315	SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1);
1316	if (wtime)
1317	{
1318	SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
1319	SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
1320	SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
1321	SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
1322	}
1323	break ;
1324	}
1325	case (ONE_FILE) :
1326	{
1327	std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
1328	std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
1329	std::vector<int> nZoomSizeServer = grid->getDistributionServer()->getZoomSizeServer();
1330
1331	int ssize = nZoomBeginGlobal.size();
1332
1333	std::vector<StdSize> start(ssize) ;
1334	std::vector<StdSize> count(ssize) ;
1335
1336	for (int i = 0; i < ssize; ++i)
1337	{
1338	start[i] = nZoomBeginServer[ssize-i-1] - nZoomBeginGlobal[ssize-i-1];
1339	count[i] = nZoomSizeServer[ssize-i-1];
1340	}
1341
1342	SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1,&start,&count );
1343	if (wtime)
1344	{
1345	SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot );
1346	SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot );
1347	SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot );
1348	SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
1349	}
1350
1351	break;
1352	}
1353	}
1354	}
1355	catch (CNetCdfException& e)
1356	{
1357	StdString msg("On writing field data: ");
1358	msg.append(fieldid); msg.append("\n");
1359	msg.append("In the context : ");
1360	msg.append(context->getId()); msg.append("\n");
1361	msg.append(e.what());
1362	ERROR("CNc4DataOutput::writeFieldData_ (CField* field)", << msg);
1363	}
1364	}
1365
1366	// //---------------------------------------------------------------
1367	//
1368	// void CNc4DataOutput::writeFieldData_ (CField* field)
1369	// {
1370	// CContext* context = CContext::getCurrent() ;
1371	//// if (field->getRelFile()->isSyncTime()) SuperClassWriter::sync() ;
1372	// CContextServer* server=context->server ;
1373	//
1374	// CGrid* grid = field->grid ;
1375	// CDomain* domain = grid->domain ;
1376	//
1377	// if(SuperClass::type==MULTI_FILE \|\| !isCollective) if (domain->isEmpty()) return;
1378	//
1379	//
1380	// StdString fieldid = (!field->name.isEmpty())
1381	// ? field->name.getValue()
1382	// : field->getBaseFieldReference()->getId();
1383	//
1384	// StdOStringStream oss;
1385	// string timeAxisId ;
1386	// if (field->foperation->timeType() == func::CFunctor::instant) timeAxisId="time_instant" ;
1387	// else if (field->foperation->timeType() == func::CFunctor::centered) timeAxisId="time_centered" ;
1388	//
1389	// StdString timeBoundId("time_counter_bounds");
1390	//
1391	// StdString timeAxisBoundId;
1392	// if (field->foperation->timeType() == func::CFunctor::instant) timeAxisBoundId="time_instant_bounds" ;
1393	// else if (field->foperation->timeType() == func::CFunctor::centered) timeAxisBoundId="time_centered_bounds" ;
1394	//
1395	// CArray<double,1> time_data(1) ;
1396	// CArray<double,1> time_counter(1) ;
1397	// CArray<double,1> time_counter_bound(2);
1398	// CArray<double,1> time_data_bound(2);
1399	//
1400	// bool wtime = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once));
1401	//
1402	// if (wtime)
1403	// {
1404	// time_counter(0)= (Time(field->last_Write_srv) + Time(field->lastlast_Write_srv)) / 2;
1405	// if (field->foperation->timeType() == func::CFunctor::instant)
1406	// time_data(0) = Time(*field->last_Write_srv);
1407	// else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0);
1408	//
1409	// time_counter_bound(0) = Time(*field->lastlast_Write_srv);
1410	// time_counter_bound(1) = Time(*field->last_Write_srv);
1411	// if (field->foperation->timeType() == func::CFunctor::instant)
1412	// time_data_bound(0) = time_data_bound(1) = Time(*field->last_Write_srv);
1413	// else if (field->foperation->timeType() == func::CFunctor::centered)
1414	// {
1415	// time_data_bound(0) = time_counter_bound(0);
1416	// time_data_bound(1) = time_counter_bound(1);
1417	// }
1418	// }
1419	//
1420	// bool isRoot ;
1421	// if (server->intraCommRank==0) isRoot=true ;
1422	// else isRoot=false ;
1423	//
1424	// if (!field->scale_factor.isEmpty() \|\| !field->add_offset.isEmpty())
1425	// {
1426	// double scaleFactor=1. ;
1427	// double addOffset=0. ;
1428	// if (!field->scale_factor.isEmpty()) scaleFactor=field->scale_factor ;
1429	// if (!field->add_offset.isEmpty()) addOffset=field->add_offset ;
1430	// field->scaleFactorAddOffset(scaleFactor,addOffset) ;
1431	// }
1432	//
1433	// try
1434	// {
1435	// if (grid->hasAxis()) // 3D
1436	// {
1437	// CAxis* axis = grid->axis ;
1438	// CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ;
1439	// if (!field->default_value.isEmpty()) field_data3D = field->default_value ;
1440	//
1441	// field->outputField(field_data3D);
1442	//
1443	// if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ;
1444	//
1445	// switch (SuperClass::type)
1446	// {
1447	// case (MULTI_FILE) :
1448	// {
1449	// SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1);
1450	// if (wtime)
1451	// {
1452	// SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
1453	// SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
1454	// SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
1455	// SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
1456	// }
1457	// break ;
1458	// }
1459	// case (ONE_FILE) :
1460	// {
1461	// std::vector<StdSize> start(3) ;
1462	// std::vector<StdSize> count(3) ;
1463	// if (domain->isEmpty())
1464	// {
1465	// start[0]=0 ; start[1]=0 ; start[2]=0 ;
1466	// count[0]=0 ; count[1]=0 ; start[2]=0 ;
1467	// }
1468	// else
1469	// {
1470	// // 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 ;
1471	// start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ;
1472	// count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue();
1473	// }
1474	// SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count );
1475	// if (wtime)
1476	// {
1477	// SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot );
1478	// SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot );
1479	// SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot );
1480	// SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
1481	// }
1482	// break;
1483	// }
1484	// }
1485	//
1486	// }
1487	// else // 2D
1488	// {
1489	// CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ;
1490	// if (!field->default_value.isEmpty()) field_data2D = field->default_value ;
1491	// field->outputField(field_data2D);
1492	// if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ;
1493	// switch (SuperClass::type)
1494	// {
1495	// case (MULTI_FILE) :
1496	// {
1497	// SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1);
1498	// if (wtime)
1499	// {
1500	// SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
1501	// SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
1502	// SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
1503	// SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
1504	// }
1505	// break;
1506	// }
1507	// case (ONE_FILE) :
1508	// {
1509	// std::vector<StdSize> start(2) ;
1510	// std::vector<StdSize> count(2) ;
1511	// if (domain->isEmpty())
1512	// {
1513	// start[0]=0 ; start[1]=0 ;
1514	// count[0]=0 ; count[1]=0 ;
1515	// }
1516	// else
1517	// {
1518	// start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
1519	// count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
1520	// }
1521	//
1522	// SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count);
1523	// if (wtime)
1524	// {
1525	// SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot);
1526	// SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot);
1527	// SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot);
1528	// SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
1529	// }
1530	// break;
1531	//
1532	// }
1533	// }
1534	// }
1535	// }
1536	// catch (CNetCdfException& e)
1537	// {
1538	// StdString msg("On writing field data: ");
1539	// msg.append(fieldid); msg.append("\n");
1540	// msg.append("In the context : ");
1541	// msg.append(context->getId()); msg.append("\n");
1542	// msg.append(e.what());
1543	// ERROR("CNc4DataOutput::writeFieldData_ (CField* field)", << msg);
1544	// }
1545	// }
1546
1547	//---------------------------------------------------------------
1548
1549	void CNc4DataOutput::writeTimeAxis_
1550	(CField* field,
1551	const boost::shared_ptr<CCalendar> cal)
1552	{
1553	StdOStringStream oss;
1554
1555	// if (field->operation.getValue().compare("once") == 0) return ;
1556	if (field->foperation->timeType() == func::CFunctor::once) return ;
1557
1558	// oss << "time_" << field->operation.getValue()
1559	// << "_" << field->getRelFile()->output_freq.getValue();
1560
1561	// StdString axisid = oss.str();
1562	// if (field->foperation->timeType() == func::CFunctor::centered) axisid="time_centered" ;
1563	// else if (field->foperation->timeType() == func::CFunctor::instant) axisid="time_instant" ;
1564
1565	StdString axisid("time_centered") ;
1566	StdString axisBoundId("time_centered_bounds");
1567	StdString timeid("time_counter");
1568	StdString timeBoundId("time_bounds");
1569
1570	if (field->foperation->timeType() == func::CFunctor::instant)
1571	{
1572	axisid = "time_instant";
1573	axisBoundId = "time_instant_bounds";
1574	}
1575
1576	try
1577	{
1578	// Adding time_instant or time_centered
1579	std::vector<StdString> dims;
1580	dims.push_back(timeid);
1581	if (!SuperClassWriter::varExist(axisid))
1582	{
1583	SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
1584
1585	CDate timeOrigin=cal->getTimeOrigin() ;
1586	StdOStringStream oss2;
1587	// oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" "
1588	// <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ;
1589	StdString strInitdate=oss2.str() ;
1590	StdString strTimeOrigin=timeOrigin.toString() ;
1591	this->writeTimeAxisAttributes
1592	(axisid, cal->getType(),
1593	StdString("seconds since ").append(strTimeOrigin),
1594	strTimeOrigin, axisBoundId);
1595	}
1596
1597	// Adding time_instant_bounds or time_centered_bounds variables
1598	if (!SuperClassWriter::varExist(axisBoundId))
1599	{
1600	dims.clear() ;
1601	dims.push_back(timeid);
1602	dims.push_back(timeBoundId);
1603	SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
1604	}
1605
1606	// Adding time_counter
1607	axisid = "time_counter" ;
1608	axisBoundId = "time_counter_bounds" ;
1609	dims.clear() ;
1610	dims.push_back(timeid);
1611	if (!SuperClassWriter::varExist(axisid))
1612	{
1613	SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
1614	SuperClassWriter::addAttribute("axis", string("T"), &axisid);
1615	CDate timeOrigin=cal->getTimeOrigin() ;
1616	StdString strTimeOrigin=timeOrigin.toString() ;
1617
1618	this->writeTimeAxisAttributes
1619	(axisid, cal->getType(),
1620	StdString("seconds since ").append(strTimeOrigin),
1621	strTimeOrigin, axisBoundId);
1622	}
1623
1624	// Adding time_counter_bound dimension
1625	if (!SuperClassWriter::varExist(axisBoundId))
1626	{
1627	dims.clear();
1628	dims.push_back(timeid);
1629	dims.push_back(timeBoundId);
1630	SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
1631	}
1632	}
1633	catch (CNetCdfException& e)
1634	{
1635	StdString msg("On writing time axis data: ");
1636	msg.append("In the context : ");
1637	CContext* context = CContext::getCurrent() ;
1638	msg.append(context->getId()); msg.append("\n");
1639	msg.append(e.what());
1640	ERROR("CNc4DataOutput::writeTimeAxis_ (CField* field, \
1641	const boost::shared_ptr<CCalendar> cal)", << msg);
1642	}
1643	}
1644
1645	//---------------------------------------------------------------
1646
1647	void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
1648	const StdString & calendar,
1649	const StdString & units,
1650	const StdString & time_origin,
1651	const StdString & time_bounds,
1652	const StdString & standard_name,
1653	const StdString & long_name,
1654	const StdString & title)
1655	{
1656	try
1657	{
1658	SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
1659	SuperClassWriter::addAttribute("long_name", long_name , &axis_name);
1660	SuperClassWriter::addAttribute("title", title , &axis_name);
1661	SuperClassWriter::addAttribute("calendar", calendar , &axis_name);
1662	SuperClassWriter::addAttribute("units", units , &axis_name);
1663	SuperClassWriter::addAttribute("time_origin", time_origin , &axis_name);
1664	SuperClassWriter::addAttribute("bounds", time_bounds , &axis_name);
1665	}
1666	catch (CNetCdfException& e)
1667	{
1668	StdString msg("On writing time axis Attribute: ");
1669	msg.append("In the context : ");
1670	CContext* context = CContext::getCurrent() ;
1671	msg.append(context->getId()); msg.append("\n");
1672	msg.append(e.what());
1673	ERROR("CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, \
1674	const StdString & calendar,\
1675	const StdString & units, \
1676	const StdString & time_origin, \
1677	const StdString & time_bounds, \
1678	const StdString & standard_name, \
1679	const StdString & long_name, \
1680	const StdString & title)", << msg);
1681	}
1682	}
1683
1684	//---------------------------------------------------------------
1685
1686	void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
1687	const StdString & axis,
1688	const StdString & standard_name,
1689	const StdString & long_name,
1690	const StdString & units,
1691	const StdString & nav_model)
1692	{
1693	try
1694	{
1695	SuperClassWriter::addAttribute("axis" , axis , &axis_name);
1696	SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
1697	SuperClassWriter::addAttribute("long_name" , long_name , &axis_name);
1698	SuperClassWriter::addAttribute("units" , units , &axis_name);
1699	SuperClassWriter::addAttribute("nav_model" , nav_model , &axis_name);
1700	}
1701	catch (CNetCdfException& e)
1702	{
1703	StdString msg("On writing Axis Attribute: ");
1704	msg.append("In the context : ");
1705	CContext* context = CContext::getCurrent() ;
1706	msg.append(context->getId()); msg.append("\n");
1707	msg.append(e.what());
1708	ERROR("CNc4DataOutput::writeAxisAttributes(const StdString & axis_name, \
1709	const StdString & axis, \
1710	const StdString & standard_name, \
1711	const StdString & long_name, \
1712	const StdString & units, \
1713	const StdString & nav_model)", << msg);
1714	}
1715	}
1716
1717	//---------------------------------------------------------------
1718
1719	void CNc4DataOutput::writeLocalAttributes
1720	(int ibegin, int ni, int jbegin, int nj, StdString domid)
1721	{
1722	try
1723	{
1724	SuperClassWriter::addAttribute(StdString("ibegin").append(domid), ibegin);
1725	SuperClassWriter::addAttribute(StdString("ni" ).append(domid), ni);
1726	SuperClassWriter::addAttribute(StdString("jbegin").append(domid), jbegin);
1727	SuperClassWriter::addAttribute(StdString("nj" ).append(domid), nj);
1728	}
1729	catch (CNetCdfException& e)
1730	{
1731	StdString msg("On writing Local Attributes: ");
1732	msg.append("In the context : ");
1733	CContext* context = CContext::getCurrent() ;
1734	msg.append(context->getId()); msg.append("\n");
1735	msg.append(e.what());
1736	ERROR("CNc4DataOutput::writeLocalAttributes \
1737	(int ibegin, int ni, int jbegin, int nj, StdString domid)", << msg);
1738	}
1739
1740	}
1741
1742	void CNc4DataOutput::writeLocalAttributes_IOIPSL
1743	(int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)
1744	{
1745	CArray<int,1> array(2) ;
1746
1747	try
1748	{
1749	SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ;
1750	SuperClassWriter::addAttribute("DOMAIN_number", rank) ;
1751	array=1,2 ;
1752	SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ;
1753	array=ni_glo,nj_glo ;
1754	SuperClassWriter::addAttribute("DOMAIN_size_global", array) ;
1755	array=ni,nj ;
1756	SuperClassWriter::addAttribute("DOMAIN_size_local", array) ;
1757	array=ibegin,jbegin ;
1758	SuperClassWriter::addAttribute("DOMAIN_position_first", array) ;
1759	array=ibegin+ni-1,jbegin+nj-1 ;
1760	SuperClassWriter::addAttribute("DOMAIN_position_last",array) ;
1761	array=0,0 ;
1762	SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ;
1763	SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array);
1764	SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ;
1765	/*
1766	SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ;
1767	SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ;
1768	SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ;
1769	SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ;
1770	*/
1771	}
1772	catch (CNetCdfException& e)
1773	{
1774	StdString msg("On writing Local Attributes IOI PSL \n");
1775	msg.append("In the context : ");
1776	CContext* context = CContext::getCurrent() ;
1777	msg.append(context->getId()); msg.append("\n");
1778	msg.append(e.what());
1779	ERROR("CNc4DataOutput::writeLocalAttributes_IOIPSL \
1780	(int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)", << msg);
1781	}
1782	}
1783	//---------------------------------------------------------------
1784
1785	void CNc4DataOutput:: writeFileAttributes(const StdString & name,
1786	const StdString & description,
1787	const StdString & conventions,
1788	const StdString & production,
1789	const StdString & timeStamp)
1790	{
1791	try
1792	{
1793	SuperClassWriter::addAttribute("name" , name);
1794	SuperClassWriter::addAttribute("description", description);
1795	SuperClassWriter::addAttribute("conventions", conventions);
1796	SuperClassWriter::addAttribute("production" , production);
1797	SuperClassWriter::addAttribute("timeStamp" , timeStamp);
1798	}
1799	catch (CNetCdfException& e)
1800	{
1801	StdString msg("On writing File Attributes \n ");
1802	msg.append("In the context : ");
1803	CContext* context = CContext::getCurrent() ;
1804	msg.append(context->getId()); msg.append("\n");
1805	msg.append(e.what());
1806	ERROR("CNc4DataOutput:: writeFileAttributes(const StdString & name, \
1807	const StdString & description, \
1808	const StdString & conventions, \
1809	const StdString & production, \
1810	const StdString & timeStamp)", << msg);
1811	}
1812	}
1813
1814	//---------------------------------------------------------------
1815
1816	void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
1817	int data_dim,
1818	int data_ni,
1819	int data_nj,
1820	int data_ibegin,
1821	int data_jbegin)
1822	{
1823	try
1824	{
1825	SuperClassWriter::addAttribute("data_dim" , data_dim , &mask_name);
1826	SuperClassWriter::addAttribute("data_ni" , data_ni , &mask_name);
1827	SuperClassWriter::addAttribute("data_nj" , data_nj , &mask_name);
1828	SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
1829	SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
1830	}
1831	catch (CNetCdfException& e)
1832	{
1833	StdString msg("On writing Mask Attributes \n ");
1834	msg.append("In the context : ");
1835	CContext* context = CContext::getCurrent() ;
1836	msg.append(context->getId()); msg.append("\n");
1837	msg.append(e.what());
1838	ERROR("CNc4DataOutput::writeMaskAttributes(const StdString & mask_name, \
1839	int data_dim, \
1840	int data_ni, \
1841	int data_nj, \
1842	int data_ibegin, \
1843	int data_jbegin)", << msg);
1844	}
1845	}
1846
1847	///--------------------------------------------------------------
1848
1849	} // namespace xios

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

Download in other formats: