Context Navigation

source: XIOS/trunk/src/io/nc4_data_output.cpp @ 878

Last change on this file since 878 was 878, checked in by oabramkina, 8 years ago
Sequential version for UGRID norms. File attribute "convention" has been added with two possible values "CF" and "UGRID". The default value is "CF".
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 Property svn:executable set to ``*
File size: 108.3 KB

Line
1	#include "nc4_data_output.hpp"
2
3	#include <boost/lexical_cast.hpp>
4	#include "attribute_template.hpp"
5	#include "group_template.hpp"
6
7	#include "file.hpp"
8	#include "calendar.hpp"
9	#include "context.hpp"
10	#include "context_server.hpp"
11	#include "netCdfException.hpp"
12	#include "exception.hpp"
13
14	namespace xios
15	{
16	/// ////////////////////// Dfinitions ////////////////////// ///
17	CNc4DataOutput::CNc4DataOutput
18	(const StdString & filename, bool exist)
19	: SuperClass()
20	, SuperClassWriter(filename, exist)
21	, filename(filename)
22	{
23	SuperClass::type = MULTI_FILE;
24	}
25
26	CNc4DataOutput::CNc4DataOutput
27	(const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention,
28	MPI_Comm comm_file,bool multifile, bool isCollective, const StdString& timeCounterName)
29	: SuperClass()
30	, SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName)
31	, comm_file(comm_file)
32	, filename(filename)
33	, isCollective(isCollective)
34	{
35	SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE;
36	}
37
38	CNc4DataOutput::~CNc4DataOutput(void)
39	{ /* Ne rien faire de plus */ }
40
41	///--------------------------------------------------------------
42
43	const StdString & CNc4DataOutput::getFileName(void) const
44	{
45	return (this->filename);
46	}
47
48	//---------------------------------------------------------------
49
50	void CNc4DataOutput::writeDomain_(CDomain* domain)
51	{
52	if (domain->type == CDomain::type_attr::unstructured)
53	{
54	if (SuperClassWriter::useCFConvention)
55	writeUnstructuredDomain(domain) ;
56	else
57	writeUnstructuredDomainUgrid(domain) ;
58	return ;
59	}
60
61	CContext* context = CContext::getCurrent() ;
62	CContextServer* server=context->server ;
63
64	if (domain->IsWritten(this->filename)) return;
65	domain->checkAttributes();
66
67	if (domain->isEmpty())
68	if (SuperClass::type==MULTI_FILE) return ;
69
70	std::vector<StdString> dim0, dim1;
71	StdString domid = domain->getDomainOutputName();
72	StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
73	if (isWrittenDomain(domid)) return ;
74	else setWrittenDomain(domid);
75
76
77	StdString dimXid, dimYid ;
78
79	bool isRegularDomain = (domain->type == CDomain::type_attr::rectilinear);
80	switch (domain->type)
81	{
82	case CDomain::type_attr::curvilinear :
83	dimXid = StdString("x").append(appendDomid);
84	dimYid = StdString("y").append(appendDomid);
85	break ;
86	case CDomain::type_attr::rectilinear :
87	dimXid = StdString("lon").append(appendDomid);
88	dimYid = StdString("lat").append(appendDomid);
89	break;
90	}
91
92	StdString dimVertId = StdString("nvertex").append(appendDomid);
93
94	string lonid,latid,bounds_lonid,bounds_latid ;
95	string areaId = "area" + appendDomid;
96	/*
97	StdString lonid_loc = (server->intraCommSize > 1)
98	? StdString("lon").append(appendDomid).append("_local")
99	: lonid;
100	StdString latid_loc = (server->intraCommSize > 1)
101	? StdString("lat").append(appendDomid).append("_local")
102	: latid;
103	*/
104
105	try
106	{
107	switch (SuperClass::type)
108	{
109	case (MULTI_FILE) :
110	{
111	// if (domain->isEmpty()) return;
112
113	if (server->intraCommSize > 1)
114	{
115	// SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue());
116	// SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue());
117	}
118
119	switch (domain->type)
120	{
121	case CDomain::type_attr::curvilinear :
122	dim0.push_back(dimYid); dim0.push_back(dimXid);
123	lonid = StdString("nav_lon").append(appendDomid);
124	latid = StdString("nav_lat").append(appendDomid);
125	break ;
126	case CDomain::type_attr::rectilinear :
127	lonid = StdString("lon").append(appendDomid);
128	latid = StdString("lat").append(appendDomid);
129	dim0.push_back(dimYid);
130	dim1.push_back(dimXid);
131	break;
132	}
133
134	bounds_lonid = StdString("bounds_lon").append(appendDomid);
135	bounds_latid = StdString("bounds_lat").append(appendDomid);
136
137	SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
138	SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv);
139
140	if (domain->hasBounds)
141	SuperClassWriter::addDimension(dimVertId, domain->nvertex);
142
143	if (server->intraCommSize > 1)
144	{
145	this->writeLocalAttributes(domain->zoom_ibegin_srv,
146	domain->zoom_ni_srv,
147	domain->zoom_jbegin_srv,
148	domain->zoom_nj_srv,
149	appendDomid);
150
151	if (singleDomain)
152	this->writeLocalAttributes_IOIPSL(dimXid, dimYid,
153	domain->zoom_ibegin_srv,
154	domain->zoom_ni_srv,
155	domain->zoom_jbegin_srv,
156	domain->zoom_nj_srv,
157	domain->ni_glo,domain->nj_glo,
158	server->intraCommRank,server->intraCommSize);
159	}
160
161	if (domain->hasLonLat)
162	{
163	switch (domain->type)
164	{
165	case CDomain::type_attr::curvilinear :
166	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
167	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
168	break ;
169	case CDomain::type_attr::rectilinear :
170	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
171	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
172	break ;
173	}
174
175	this->writeAxisAttributes(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
176	this->writeAxisAttributes(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
177
178	if (domain->hasBounds)
179	{
180	SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
181	SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
182
183	dim0.clear();
184	dim0.push_back(dimYid);
185	dim0.push_back(dimXid);
186	dim0.push_back(dimVertId);
187	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
188	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
189	}
190	}
191
192	dim0.clear();
193	dim0.push_back(dimYid);
194	dim0.push_back(dimXid);
195
196
197	// supress mask if (server->intraCommSize > 1)
198	// supress mask {
199	// supress mask SuperClassWriter::addVariable(maskid, NC_INT, dim0);
200	// supress mask
201	// supress mask this->writeMaskAttributes(maskid,
202	// supress mask domain->data_dim.getValue()/*,
203	// supress mask domain->data_ni.getValue(),
204	// supress mask domain->data_nj.getValue(),
205	// supress mask domain->data_ibegin.getValue(),
206	// supress mask domain->data_jbegin.getValue()*/);
207	// supress mask }
208
209	//SuperClassWriter::setDefaultValue(maskid, &dvm);
210
211	if (domain->hasArea)
212	{
213	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
214	SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
215	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
216	}
217
218	SuperClassWriter::definition_end();
219
220	if (domain->hasLonLat)
221	{
222	switch (domain->type)
223	{
224	case CDomain::type_attr::curvilinear :
225	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
226	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
227	break;
228	case CDomain::type_attr::rectilinear :
229	CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
230	SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
231	CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
232	SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0);
233	break;
234	}
235
236	if (domain->hasBounds)
237	{
238	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
239	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
240	}
241	}
242
243	if (domain->hasArea)
244	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
245
246	SuperClassWriter::definition_start();
247
248	break;
249	}
250	case (ONE_FILE) :
251	{
252	SuperClassWriter::addDimension(dimXid, domain->global_zoom_ni);
253	SuperClassWriter::addDimension(dimYid, domain->global_zoom_nj);
254
255	if (domain->hasBounds)
256	SuperClassWriter::addDimension(dimVertId, domain->nvertex);
257
258	if (domain->hasLonLat)
259	{
260	switch (domain->type)
261	{
262	case CDomain::type_attr::curvilinear :
263	dim0.push_back(dimYid); dim0.push_back(dimXid);
264	lonid = StdString("nav_lon").append(appendDomid);
265	latid = StdString("nav_lat").append(appendDomid);
266	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
267	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
268	break;
269
270	case CDomain::type_attr::rectilinear :
271	dim0.push_back(dimYid);
272	dim1.push_back(dimXid);
273	lonid = StdString("lon").append(appendDomid);
274	latid = StdString("lat").append(appendDomid);
275	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
276	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
277	break;
278	}
279
280	bounds_lonid = StdString("bounds_lon").append(appendDomid);
281	bounds_latid = StdString("bounds_lat").append(appendDomid);
282
283	this->writeAxisAttributes
284	(lonid, isRegularDomain ? "X" : "", "longitude", "Longitude", "degrees_east", domid);
285	this->writeAxisAttributes
286	(latid, isRegularDomain ? "Y" : "", "latitude", "Latitude", "degrees_north", domid);
287
288	if (domain->hasBounds)
289	{
290	SuperClassWriter::addAttribute("bounds", bounds_lonid, &lonid);
291	SuperClassWriter::addAttribute("bounds", bounds_latid, &latid);
292
293	dim0.clear();
294	dim0.push_back(dimYid);
295	dim0.push_back(dimXid);
296	dim0.push_back(dimVertId);
297	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
298	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
299	}
300	}
301
302	if (domain->hasArea)
303	{
304	dim0.clear();
305	dim0.push_back(dimYid); dim0.push_back(dimXid);
306	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
307	SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
308	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
309	dim0.clear();
310	}
311
312	SuperClassWriter::definition_end();
313
314	switch (domain->type)
315	{
316	case CDomain::type_attr::curvilinear :
317	{
318	std::vector<StdSize> start(2) ;
319	std::vector<StdSize> count(2) ;
320	if (domain->isEmpty())
321	{
322	start[0]=0 ; start[1]=0 ;
323	count[0]=0 ; count[1]=0 ;
324	}
325	else
326	{
327	start[1]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
328	start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
329	count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
330	}
331
332	if (domain->hasLonLat)
333	{
334	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
335	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
336	}
337	break;
338	}
339	case CDomain::type_attr::rectilinear :
340	{
341	if (domain->hasLonLat)
342	{
343	std::vector<StdSize> start(1) ;
344	std::vector<StdSize> count(1) ;
345	if (domain->isEmpty())
346	{
347	start[0]=0 ;
348	count[0]=0 ;
349	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
350	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
351
352	}
353	else
354	{
355	start[0]=domain->zoom_jbegin_srv-domain->global_zoom_jbegin;
356	count[0]=domain->zoom_nj_srv ;
357	CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
358	SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count);
359
360	start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
361	count[0]=domain->zoom_ni_srv ;
362	CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ;
363	SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count);
364	}
365	}
366	break;
367	}
368	}
369
370	if (domain->hasBounds)
371	{
372	std::vector<StdSize> start(3);
373	std::vector<StdSize> count(3);
374	if (domain->isEmpty())
375	{
376	start[2] = start[1] = start[0] = 0;
377	count[2] = count[1] = count[0] = 0;
378	}
379	else
380	{
381	start[2] = 0;
382	start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
383	start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
384	count[2] = domain->nvertex;
385	count[1] = domain->zoom_ni_srv;
386	count[0] = domain->zoom_nj_srv;
387	}
388
389	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0, &start, &count);
390	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0, &start, &count);
391	}
392
393	if (domain->hasArea)
394	{
395	std::vector<StdSize> start(2);
396	std::vector<StdSize> count(2);
397
398	if (domain->isEmpty())
399	{
400	start[0] = 0; start[1] = 0;
401	count[0] = 0; count[1] = 0;
402	}
403	else
404	{
405	start[1] = domain->zoom_ibegin_srv - domain->global_zoom_ibegin;
406	start[0] = domain->zoom_jbegin_srv - domain->global_zoom_jbegin;
407	count[1] = domain->zoom_ni_srv;
408	count[0] = domain->zoom_nj_srv;
409	}
410
411	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
412	}
413
414	SuperClassWriter::definition_start();
415	break;
416	}
417	default :
418	ERROR("CNc4DataOutput::writeDomain(domain)",
419	<< "[ type = " << SuperClass::type << "]"
420	<< " not implemented yet !");
421	}
422	}
423	catch (CNetCdfException& e)
424	{
425	StdString msg("On writing the domain : ");
426	msg.append(domid); msg.append("\n");
427	msg.append("In the context : ");
428	msg.append(context->getId()); msg.append("\n");
429	msg.append(e.what());
430	ERROR("CNc4DataOutput::writeDomain_(CDomain* domain)", << msg);
431	}
432
433	domain->addRelFile(this->filename);
434	}
435
436	//--------------------------------------------------------------
437
438	void CNc4DataOutput::writeUnstructuredDomainUgrid(CDomain* domain)
439	{
440	CContext* context = CContext::getCurrent() ;
441	CContextServer* server=context->server ;
442
443	if (domain->IsWritten(this->filename)) return;
444	domain->checkAttributes();
445	if (domain->isEmpty())
446	if (SuperClass::type==MULTI_FILE) return ;
447
448	std::vector<StdString> dim0;
449	StdString domid = domain->getDomainOutputName();
450	StdString domainName = domain->name;
451
452	if (domain->mesh->isWritten(domainName)) domain->mesh = CMesh::getMesh;
453
454	domain->mesh->createMesh(domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv);
455	//domain->mesh->createMeshEpsilon(domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv);
456
457	StdString node_x = domainName + "_node_x";
458	StdString node_y = domainName + "_node_y";
459
460	StdString edge_x = domainName + "_edge_x";
461	StdString edge_y = domainName + "_edge_y";
462	StdString edge_nodes = domainName + "_edge_nodes";
463
464	StdString face_x = domainName + "_face_x";
465	StdString face_y = domainName + "_face_y";
466	StdString face_nodes = domainName + "_face_nodes";
467
468	StdString dimNode = "n" + domainName + "_node";
469	StdString dimEdge = "n" + domainName + "_edge";
470	StdString dimFace = "n" + domainName + "_face";
471	StdString dimVertex = "n" + domainName + "_vertex";
472	StdString dimTwo = "Two";
473
474	if (!SuperClassWriter::dimExist(dimTwo)) SuperClassWriter::addDimension(dimTwo, 2);
475	if (!isWrittenDomain(domid))
476	{
477	dim0.clear();
478	SuperClassWriter::addVariable(domainName, NC_INT, dim0);
479	SuperClassWriter::addAttribute("cf_role", StdString("mesh_topology"), &domainName);
480	SuperClassWriter::addAttribute("node_coordinates", node_x + " " + node_y, &domainName);
481	}
482
483	try
484	{
485	switch (SuperClass::type)
486	{
487	case (ONE_FILE) :
488	{
489	// Adding nodes
490	if (domain->nvertex == 1)
491	{
492	if (!SuperClassWriter::varExist(node_x) \|\| !SuperClassWriter::varExist(node_y))
493	{
494	SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
495	dim0.clear();
496	dim0.push_back(dimNode);
497	SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
498	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
499	SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
500	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
501	SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
502	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
503	SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
504	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
505	}
506	} // domain->nvertex == 1
507
508	// Adding edges and nodes, if nodes have not been defined previously
509	if (domain->nvertex == 2)
510	{
511	// Nodes
512	if (!SuperClassWriter::varExist(node_x) \|\| !SuperClassWriter::varExist(node_y))
513	{
514	SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
515	dim0.clear();
516	dim0.push_back(dimNode);
517	SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
518	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
519	SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
520	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
521	SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
522	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
523	SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
524	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
525	}
526	// Edges
527	if (!SuperClassWriter::varExist(edge_x) \|\| !SuperClassWriter::varExist(edge_y))
528	{
529	SuperClassWriter::addAttribute("edge_node_connectivity", edge_nodes, &domainName);
530	SuperClassWriter::addAttribute("edge_coordinates", edge_x + " " + edge_y, &domainName);
531	SuperClassWriter::addDimension(dimEdge, domain->mesh->nbEdges);
532	dim0.clear();
533	dim0.push_back(dimEdge);
534	SuperClassWriter::addVariable(edge_x, NC_FLOAT, dim0);
535	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &edge_x);
536	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh edges."), &edge_x);
537	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &edge_x);
538	SuperClassWriter::addVariable(edge_y, NC_FLOAT, dim0);
539	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &edge_y);
540	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh edges."), &edge_y);
541	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &edge_y);
542	dim0.clear();
543	dim0.push_back(dimEdge);
544	dim0.push_back(dimTwo);
545	SuperClassWriter::addVariable(edge_nodes, NC_INT, dim0);
546	SuperClassWriter::addAttribute("cf_role", StdString("edge_node_connectivity"), &edge_nodes);
547	SuperClassWriter::addAttribute("long_name", StdString("Maps every edge/link to two nodes that it connects."), &edge_nodes);
548	SuperClassWriter::addAttribute("start_index", 0, &edge_nodes);
549	}
550	} // domain->nvertex == 2
551
552	// Adding faces, edges, and nodes, if edges and nodes have not been defined previously
553	if (domain->nvertex > 2)
554	{
555	// Nodes
556	if (!SuperClassWriter::varExist(node_x) \|\| !SuperClassWriter::varExist(node_y))
557	{
558	SuperClassWriter::addDimension(dimNode, domain->mesh->nbNodes);
559	dim0.clear();
560	dim0.push_back(dimNode);
561	SuperClassWriter::addVariable(node_x, NC_FLOAT, dim0);
562	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &node_x);
563	SuperClassWriter::addAttribute("longname_name", StdString("Longitude of mesh nodes."), &node_x);
564	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &node_x);
565	SuperClassWriter::addVariable(node_y, NC_FLOAT, dim0);
566	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &node_y);
567	SuperClassWriter::addAttribute("longname_name", StdString("Latitude of mesh nodes."), &node_y);
568	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &node_y);
569	}
570	// Edges
571	if (!SuperClassWriter::varExist(edge_x) \|\| !SuperClassWriter::varExist(edge_y))
572	{
573	SuperClassWriter::addAttribute("edge_coordinates", edge_x + " " + edge_y, &domainName);
574	SuperClassWriter::addAttribute("edge_node_connectivity", edge_nodes, &domainName);
575	SuperClassWriter::addDimension(dimEdge, domain->mesh->nbEdges);
576	dim0.clear();
577	dim0.push_back(dimEdge);
578	SuperClassWriter::addVariable(edge_x, NC_FLOAT, dim0);
579	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &edge_x);
580	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh edges."), &edge_x);
581	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &edge_x);
582	SuperClassWriter::addVariable(edge_y, NC_FLOAT, dim0);
583	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &edge_y);
584	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh edges."), &edge_y);
585	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &edge_y);
586	dim0.clear();
587	dim0.push_back(dimEdge);
588	dim0.push_back(dimTwo);
589	SuperClassWriter::addVariable(edge_nodes, NC_INT, dim0);
590	SuperClassWriter::addAttribute("cf_role", StdString("edge_node_connectivity"), &edge_nodes);
591	SuperClassWriter::addAttribute("long_name", StdString("Maps every edge/link to two nodes that it connects."), &edge_nodes);
592	SuperClassWriter::addAttribute("start_index", 0, &edge_nodes);
593	}
594	// Faces
595	SuperClassWriter::addAttribute("face_coordinates", face_x + " " + face_y, &domainName);
596	SuperClassWriter::addAttribute("face_node_connectivity", face_nodes, &domainName);
597	SuperClassWriter::addDimension(dimFace, domain->mesh->nbFaces);
598	SuperClassWriter::addDimension(dimVertex, domain->mesh->nvertex);
599	dim0.clear();
600	dim0.push_back(dimFace);
601	SuperClassWriter::addVariable(face_x, NC_FLOAT, dim0);
602	SuperClassWriter::addAttribute("standard_name", StdString("longitude"), &face_x);
603	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic longitude of mesh faces."), &face_x);
604	SuperClassWriter::addAttribute("units", StdString("degrees_east"), &face_x);
605	SuperClassWriter::addVariable(face_y, NC_FLOAT, dim0);
606	SuperClassWriter::addAttribute("standard_name", StdString("latitude"), &face_y);
607	SuperClassWriter::addAttribute("longname_name", StdString("Characteristic latitude of mesh faces."), &face_y);
608	SuperClassWriter::addAttribute("units", StdString("degrees_north"), &face_y);
609	dim0.clear();
610	dim0.push_back(dimFace);
611	dim0.push_back(dimVertex);
612	SuperClassWriter::addVariable(face_nodes, NC_INT, dim0);
613	SuperClassWriter::addAttribute("cf_role", StdString("face_node_connectivity"), &face_nodes);
614	SuperClassWriter::addAttribute("long_name", StdString("Maps every face to its corner nodes."), &face_nodes);
615	SuperClassWriter::addAttribute("start_index", 0, &face_nodes);
616	} // domain->nvertex > 2
617
618	SuperClassWriter::definition_end();
619
620	if (!isWrittenDomain(domid))
621	{
622	if (domain->nvertex == 1)
623	{
624	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
625	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
626	}
627	else if (domain->nvertex == 2)
628	{
629	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
630	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
631	SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
632	SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
633	SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
634	}
635	else
636	{
637	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
638	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
639	SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
640	SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
641	SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
642	SuperClassWriter::writeData(domain->mesh->face_lat, face_y, isCollective, 0);
643	SuperClassWriter::writeData(domain->mesh->face_lon, face_x, isCollective, 0);
644	SuperClassWriter::writeData(domain->mesh->face_nodes, face_nodes);
645	}
646	setWrittenDomain(domid);
647	} // !isWrittenDomain
648	else
649	{
650	if (domain->nvertex == 1)
651	{
652	if ( (!domain->mesh->edgesAreWritten) && (!domain->mesh->facesAreWritten) )
653	{
654	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
655	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
656	}
657	}
658	if (domain->nvertex == 2)
659	{
660	if (!domain->mesh->facesAreWritten)
661	{
662	if (!domain->mesh->nodesAreWritten)
663	{
664	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
665	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
666	}
667	SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
668	SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
669	SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
670	}
671	}
672	if (domain->nvertex > 2)
673	{
674	if (!domain->mesh->edgesAreWritten)
675	{
676	if (!domain->mesh->nodesAreWritten)
677	{
678	SuperClassWriter::writeData(domain->mesh->node_lat, node_y, isCollective, 0);
679	SuperClassWriter::writeData(domain->mesh->node_lon, node_x, isCollective, 0);
680	}
681	SuperClassWriter::writeData(domain->mesh->edge_lat, edge_y, isCollective, 0);
682	SuperClassWriter::writeData(domain->mesh->edge_lon, edge_x, isCollective, 0);
683	SuperClassWriter::writeData(domain->mesh->edge_nodes, edge_nodes);
684	}
685	SuperClassWriter::writeData(domain->mesh->face_lat, face_y, isCollective, 0);
686	SuperClassWriter::writeData(domain->mesh->face_lon, face_x, isCollective, 0);
687	SuperClassWriter::writeData(domain->mesh->face_nodes, face_nodes);
688	}
689	}// isWrittenDomain
690
691	SuperClassWriter::definition_start();
692
693	break;
694	} // ONE_FILE
695
696	case (MULTI_FILE) :
697	{
698	break;
699	}
700
701	default :
702	ERROR("CNc4DataOutput::writeDomain(domain)",
703	<< "[ type = " << SuperClass::type << "]"
704	<< " not implemented yet !");
705	} // switch
706	} // try
707
708	catch (CNetCdfException& e)
709	{
710	StdString msg("On writing the domain : ");
711	msg.append(domid); msg.append("\n");
712	msg.append("In the context : ");
713	msg.append(context->getId()); msg.append("\n");
714	msg.append(e.what());
715	ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
716	}
717
718	domain->addRelFile(this->filename);
719	}
720
721	//--------------------------------------------------------------
722
723	void CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)
724	{
725	CContext* context = CContext::getCurrent() ;
726	CContextServer* server=context->server ;
727
728	if (domain->IsWritten(this->filename)) return;
729	domain->checkAttributes();
730
731	if (domain->isEmpty())
732	if (SuperClass::type==MULTI_FILE) return ;
733
734	std::vector<StdString> dim0, dim1;
735	StdString domid = domain->getDomainOutputName();
736	if (isWrittenDomain(domid)) return ;
737	else setWrittenDomain(domid);
738
739	StdString appendDomid = (singleDomain) ? "" : "_"+domid ;
740
741
742	StdString dimXid = StdString("cell").append(appendDomid);
743	StdString dimVertId = StdString("nvertex").append(appendDomid);
744
745	string lonid,latid,bounds_lonid,bounds_latid ;
746	string areaId = "area" + appendDomid;
747
748	try
749	{
750	switch (SuperClass::type)
751	{
752	case (MULTI_FILE) :
753	{
754	dim0.push_back(dimXid);
755	SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv);
756
757	lonid = StdString("lon").append(appendDomid);
758	latid = StdString("lat").append(appendDomid);
759	bounds_lonid = StdString("bounds_lon").append(appendDomid);
760	bounds_latid = StdString("bounds_lat").append(appendDomid);
761	if (domain->hasLonLat)
762	{
763	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
764	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
765	this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
766	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
767	this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
768	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
769	if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
770	}
771	dim0.clear();
772	if (domain->hasBounds)
773	{
774	dim0.push_back(dimXid);
775	dim0.push_back(dimVertId);
776	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
777	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
778	}
779
780	dim0.clear();
781	dim0.push_back(dimXid);
782	if (domain->hasArea)
783	{
784	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
785	SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
786	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
787	}
788
789	SuperClassWriter::definition_end();
790
791	if (domain->hasLonLat)
792	{
793	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0);
794	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
795	if (domain->hasBounds)
796	{
797	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0);
798	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0);
799	}
800	}
801
802	if (domain->hasArea)
803	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0);
804
805	SuperClassWriter::definition_start();
806	break ;
807	}
808
809	case (ONE_FILE) :
810	{
811	lonid = StdString("lon").append(appendDomid);
812	latid = StdString("lat").append(appendDomid);
813	bounds_lonid = StdString("bounds_lon").append(appendDomid);
814	bounds_latid = StdString("bounds_lat").append(appendDomid);
815	dim0.push_back(dimXid);
816	SuperClassWriter::addDimension(dimXid, domain->ni_glo);
817	if (domain->hasLonLat)
818	{
819	SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
820	SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
821
822	this->writeAxisAttributes(lonid, "", "longitude", "Longitude", "degrees_east", domid);
823	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid);
824	this->writeAxisAttributes(latid, "", "latitude", "Latitude", "degrees_north", domid);
825	if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid);
826	if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex);
827	}
828	dim0.clear();
829
830	if (domain->hasBounds)
831	{
832	dim0.push_back(dimXid);
833	dim0.push_back(dimVertId);
834	SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0);
835	SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0);
836	}
837
838	if (domain->hasArea)
839	{
840	dim0.clear();
841	dim0.push_back(dimXid);
842	SuperClassWriter::addVariable(areaId, NC_FLOAT, dim0);
843	SuperClassWriter::addAttribute("standard_name", StdString("cell_area"), &areaId);
844	SuperClassWriter::addAttribute("units", StdString("m2"), &areaId);
845	}
846
847	SuperClassWriter::definition_end();
848
849	std::vector<StdSize> start(1), startBounds(2) ;
850	std::vector<StdSize> count(1), countBounds(2) ;
851	if (domain->isEmpty())
852	{
853	start[0]=0 ;
854	count[0]=0 ;
855	startBounds[1]=0 ;
856	countBounds[1]=domain->nvertex ;
857	startBounds[0]=0 ;
858	countBounds[0]=0 ;
859	}
860	else
861	{
862	start[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
863	count[0]=domain->zoom_ni_srv ;
864	startBounds[0]=domain->zoom_ibegin_srv-domain->global_zoom_ibegin;
865	startBounds[1]=0 ;
866	countBounds[0]=domain->zoom_ni_srv ;
867	countBounds[1]=domain->nvertex ;
868	}
869
870	if (domain->hasLonLat)
871	{
872	SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count);
873	SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);
874	if (domain->hasBounds)
875	{
876	SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds);
877	SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds);
878	}
879	}
880
881	if (domain->hasArea)
882	SuperClassWriter::writeData(domain->area_srv, areaId, isCollective, 0, &start, &count);
883
884	SuperClassWriter::definition_start();
885
886	break;
887	}
888	default :
889	ERROR("CNc4DataOutput::writeDomain(domain)",
890	<< "[ type = " << SuperClass::type << "]"
891	<< " not implemented yet !");
892	}
893	}
894	catch (CNetCdfException& e)
895	{
896	StdString msg("On writing the domain : ");
897	msg.append(domid); msg.append("\n");
898	msg.append("In the context : ");
899	msg.append(context->getId()); msg.append("\n");
900	msg.append(e.what());
901	ERROR("CNc4DataOutput::writeUnstructuredDomain(CDomain* domain)", << msg);
902	}
903	domain->addRelFile(this->filename);
904	}
905	//--------------------------------------------------------------
906
907	void CNc4DataOutput::writeAxis_(CAxis* axis)
908	{
909	if (axis->IsWritten(this->filename)) return;
910	axis->checkAttributes();
911	int zoom_size_srv = axis->zoom_size_srv;
912	int zoom_begin_srv = axis->zoom_begin_srv;
913	int zoom_size = (MULTI_FILE == SuperClass::type) ? zoom_size_srv
914	: axis->global_zoom_n;
915	int zoom_begin = (MULTI_FILE == SuperClass::type) ? zoom_begin_srv
916	: axis->global_zoom_begin;
917
918	if ((0 == zoom_size_srv) && (MULTI_FILE == SuperClass::type)) return;
919
920	std::vector<StdString> dims;
921	StdString axisid = axis->getAxisOutputName();
922	if (isWrittenAxis(axisid)) return ;
923	else setWrittenAxis(axisid);
924
925	try
926	{
927	SuperClassWriter::addDimension(axisid, zoom_size);
928	if (axis->hasValue)
929	{
930	dims.push_back(axisid);
931	SuperClassWriter::addVariable(axisid, NC_FLOAT, dims);
932
933	if (!axis->name.isEmpty())
934	SuperClassWriter::addAttribute("name", axis->name.getValue(), &axisid);
935
936	if (!axis->standard_name.isEmpty())
937	SuperClassWriter::addAttribute("standard_name", axis->standard_name.getValue(), &axisid);
938
939	if (!axis->long_name.isEmpty())
940	SuperClassWriter::addAttribute("long_name", axis->long_name.getValue(), &axisid);
941
942	if (!axis->unit.isEmpty())
943	SuperClassWriter::addAttribute("units", axis->unit.getValue(), &axisid);
944
945	if (!axis->positive.isEmpty())
946	{
947	SuperClassWriter::addAttribute("axis", string("Z"), &axisid);
948	SuperClassWriter::addAttribute("positive",
949	(axis->positive == CAxis::positive_attr::up) ? string("up") : string("down"),
950	&axisid);
951	}
952
953	StdString axisBoundsId = axisid + "_bounds";
954	if (!axis->bounds.isEmpty())
955	{
956	dims.push_back("axis_nbounds");
957	SuperClassWriter::addVariable(axisBoundsId, NC_FLOAT, dims);
958	SuperClassWriter::addAttribute("bounds", axisBoundsId, &axisid);
959	}
960
961	SuperClassWriter::definition_end();
962
963	switch (SuperClass::type)
964	{
965	case MULTI_FILE:
966	{
967	CArray<double,1> axis_value(zoom_size_srv);
968	for (int i = 0; i < zoom_size_srv; i++) axis_value(i) = axis->value_srv(i);
969	SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
970
971	if (!axis->bounds.isEmpty())
972	SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0);
973
974	SuperClassWriter::definition_start();
975
976	break;
977	}
978	case ONE_FILE:
979	{
980	CArray<double,1> axis_value(zoom_size_srv);
981	axis_value = axis->value_srv;
982
983	std::vector<StdSize> start(1), startBounds(2) ;
984	std::vector<StdSize> count(1), countBounds(2) ;
985	start[0] = startBounds[0] = zoom_begin_srv-axis->global_zoom_begin;
986	count[0] = countBounds[0] = zoom_size_srv;
987	startBounds[1] = 0;
988	countBounds[1] = 2;
989	SuperClassWriter::writeData(axis_value, axisid, isCollective, 0, &start, &count);
990
991	if (!axis->bounds.isEmpty())
992	SuperClassWriter::writeData(axis->bound_srv, axisBoundsId, isCollective, 0, &startBounds, &countBounds);
993
994	SuperClassWriter::definition_start();
995
996	break;
997	}
998	default :
999	ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)",
1000	<< "[ type = " << SuperClass::type << "]"
1001	<< " not implemented yet !");
1002	}
1003	}
1004	}
1005	catch (CNetCdfException& e)
1006	{
1007	StdString msg("On writing the axis : ");
1008	msg.append(axisid); msg.append("\n");
1009	msg.append("In the context : ");
1010	CContext* context = CContext::getCurrent() ;
1011	msg.append(context->getId()); msg.append("\n");
1012	msg.append(e.what());
1013	ERROR("CNc4DataOutput::writeAxis_(CAxis* axis)", << msg);
1014	}
1015	axis->addRelFile(this->filename);
1016	}
1017
1018	//--------------------------------------------------------------
1019
1020	void CNc4DataOutput::writeGridCompressed_(CGrid* grid)
1021	{
1022	if (grid->isScalarGrid() \|\| grid->isWrittenCompressed(this->filename)) return;
1023
1024	try
1025	{
1026	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1027	std::vector<StdString> domainList = grid->getDomainList();
1028	std::vector<StdString> axisList = grid->getAxisList();
1029	int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1030
1031	std::vector<StdString> dims;
1032
1033	if (grid->isCompressible())
1034	{
1035	StdString varId = grid->getId() + "_points";
1036
1037	int nbIndexes = (SuperClass::type == MULTI_FILE) ? grid->getNumberWrittenIndexes() : grid->getTotalNumberWrittenIndexes();
1038	SuperClassWriter::addDimension(varId, nbIndexes);
1039
1040	dims.push_back(varId);
1041	SuperClassWriter::addVariable(varId, NC_INT, dims);
1042
1043	StdOStringStream compress;
1044	for (int i = numElement - 1; i >= 0; --i)
1045	{
1046	if (axisDomainOrder(i))
1047	{
1048	CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]);
1049	StdString domId = domain->getDomainOutputName();
1050	StdString appendDomId = singleDomain ? "" : "_" + domId;
1051
1052	switch (domain->type)
1053	{
1054	case CDomain::type_attr::curvilinear:
1055	compress << "y" << appendDomId << " x" << appendDomId;
1056	break;
1057	case CDomain::type_attr::rectilinear:
1058	compress << "lat" << appendDomId << " lon" << appendDomId;
1059	break;
1060	case CDomain::type_attr::unstructured:
1061	compress << "cell" << appendDomId;
1062	break;
1063	}
1064	++idxDomain;
1065	}
1066	else
1067	{
1068	CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]);
1069	compress << axis->getAxisOutputName();
1070	++idxAxis;
1071	}
1072
1073	if (i != 0) compress << ' ';
1074	}
1075	SuperClassWriter::addAttribute("compress", compress.str(), &varId);
1076
1077	grid->computeCompressedIndex();
1078
1079	CArray<int, 1> indexes(grid->getNumberWrittenIndexes());
1080	std::map<int, CArray<size_t, 1> >::const_iterator it;
1081	for (it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
1082	{
1083	const CArray<size_t, 1> compressedIndexes = grid->compressedOutIndexFromClient[it->first];
1084	for (int i = 0; i < it->second.numElements(); i++)
1085	indexes(compressedIndexes(i)) = it->second(i);
1086	}
1087
1088	switch (SuperClass::type)
1089	{
1090	case (MULTI_FILE):
1091	{
1092	SuperClassWriter::writeData(indexes, varId, isCollective, 0);
1093	break;
1094	}
1095	case (ONE_FILE):
1096	{
1097	if (grid->doGridHaveDataDistributed())
1098	grid->getDistributionServer()->computeGlobalIndex(indexes);
1099
1100	std::vector<StdSize> start, count;
1101	start.push_back(grid->getOffsetWrittenIndexes());
1102	count.push_back(grid->getNumberWrittenIndexes());
1103
1104	SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
1105	break;
1106	}
1107	}
1108	}
1109	else
1110	{
1111	for (int i = 0; i < numElement; ++i)
1112	{
1113	StdString varId, compress;
1114	CArray<int, 1> indexes;
1115	bool isDistributed;
1116	StdSize nbIndexes, totalNbIndexes, offset;
1117	int firstGlobalIndex;
1118
1119	if (axisDomainOrder(i))
1120	{
1121	CDomain* domain = CDomain::get(domainList[idxDomain]);
1122	StdString domId = domain->getDomainOutputName();
1123
1124	if (!domain->isCompressible()
1125	\|\| domain->type == CDomain::type_attr::unstructured
1126	\|\| domain->isWrittenCompressed(this->filename)
1127	\|\| isWrittenCompressedDomain(domId))
1128	continue;
1129
1130	StdString appendDomId = singleDomain ? "" : "_" + domId;
1131
1132	varId = domId + "_points";
1133	switch (domain->type)
1134	{
1135	case CDomain::type_attr::curvilinear:
1136	compress = "y" + appendDomId + " x" + appendDomId;
1137	break;
1138	case CDomain::type_attr::rectilinear:
1139	compress = "lat" + appendDomId + " lon" + appendDomId;
1140	break;
1141	}
1142
1143	const std::vector<int>& indexesToWrite = domain->getIndexesToWrite();
1144	indexes.resize(indexesToWrite.size());
1145	for (int n = 0; n < indexes.numElements(); ++n)
1146	indexes(n) = indexesToWrite[n];
1147
1148	isDistributed = domain->isDistributed();
1149	nbIndexes = domain->getNumberWrittenIndexes();
1150	totalNbIndexes = domain->getTotalNumberWrittenIndexes();
1151	offset = domain->getOffsetWrittenIndexes();
1152	firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
1153
1154	domain->addRelFileCompressed(this->filename);
1155	setWrittenCompressedDomain(domId);
1156	++idxDomain;
1157	}
1158	else
1159	{
1160	CAxis* axis = CAxis::get(axisList[idxAxis]);
1161	StdString axisId = axis->getAxisOutputName();
1162
1163	if (!axis->isCompressible()
1164	\|\| axis->isWrittenCompressed(this->filename)
1165	\|\| isWrittenCompressedAxis(axisId))
1166	continue;
1167
1168	varId = axisId + "_points";
1169	compress = axisId;
1170
1171	const std::vector<int>& indexesToWrite = axis->getIndexesToWrite();
1172	indexes.resize(indexesToWrite.size());
1173	for (int n = 0; n < indexes.numElements(); ++n)
1174	indexes(n) = indexesToWrite[n];
1175
1176	isDistributed = axis->isDistributed();
1177	nbIndexes = axis->getNumberWrittenIndexes();
1178	totalNbIndexes = axis->getTotalNumberWrittenIndexes();
1179	offset = axis->getOffsetWrittenIndexes();
1180	firstGlobalIndex = axis->begin;
1181
1182	axis->addRelFileCompressed(this->filename);
1183	setWrittenCompressedAxis(axisId);
1184	++idxAxis;
1185	}
1186
1187	if (!varId.empty())
1188	{
1189	SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
1190
1191	dims.clear();
1192	dims.push_back(varId);
1193	SuperClassWriter::addVariable(varId, NC_INT, dims);
1194
1195	SuperClassWriter::addAttribute("compress", compress, &varId);
1196
1197	switch (SuperClass::type)
1198	{
1199	case (MULTI_FILE):
1200	{
1201	indexes -= firstGlobalIndex;
1202	SuperClassWriter::writeData(indexes, varId, isCollective, 0);
1203	break;
1204	}
1205	case (ONE_FILE):
1206	{
1207	std::vector<StdSize> start, count;
1208	start.push_back(offset);
1209	count.push_back(nbIndexes);
1210
1211	SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
1212	break;
1213	}
1214	}
1215	}
1216	}
1217
1218	if (!dims.empty())
1219	grid->computeCompressedIndex();
1220	}
1221
1222	grid->addRelFileCompressed(this->filename);
1223	}
1224	catch (CNetCdfException& e)
1225	{
1226	StdString msg("On writing compressed grid : ");
1227	msg.append(grid->getId()); msg.append("\n");
1228	msg.append("In the context : ");
1229	CContext* context = CContext::getCurrent();
1230	msg.append(context->getId()); msg.append("\n");
1231	msg.append(e.what());
1232	ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
1233	}
1234	}
1235
1236	//--------------------------------------------------------------
1237
1238	void CNc4DataOutput::writeTimeDimension_(void)
1239	{
1240	try
1241	{
1242	SuperClassWriter::addDimension(getTimeCounterName());
1243	}
1244	catch (CNetCdfException& e)
1245	{
1246	StdString msg("On writing time dimension : time_couter\n");
1247	msg.append("In the context : ");
1248	CContext* context = CContext::getCurrent() ;
1249	msg.append(context->getId()); msg.append("\n");
1250	msg.append(e.what());
1251	ERROR("CNc4DataOutput::writeTimeDimension_(void)", << msg);
1252	}
1253	}
1254
1255	//--------------------------------------------------------------
1256
1257	void CNc4DataOutput::writeField_(CField* field)
1258	{
1259	CContext* context = CContext::getCurrent() ;
1260	CContextServer* server=context->server ;
1261
1262	std::vector<StdString> dims, coodinates;
1263	CGrid* grid = field->grid;
1264	if (!grid->doGridHaveDataToWrite())
1265	if (SuperClass::type==MULTI_FILE) return ;
1266
1267	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1268	int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1269	std::vector<StdString> domainList = grid->getDomainList();
1270	std::vector<StdString> axisList = grid->getAxisList();
1271
1272	StdString timeid = getTimeCounterName();
1273	StdString dimXid,dimYid;
1274	std::deque<StdString> dimIdList, dimCoordList;
1275	bool hasArea = false;
1276	StdString cellMeasures = "area:";
1277	bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
1278
1279	for (int i = 0; i < numElement; ++i)
1280	{
1281	if (axisDomainOrder(i))
1282	{
1283	CDomain* domain = CDomain::get(domainList[idxDomain]);
1284	StdString domId = domain->getDomainOutputName();
1285	StdString appendDomId = singleDomain ? "" : "_" + domId ;
1286
1287	if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
1288	{
1289	dimIdList.push_back(domId + "_points");
1290	field->setUseCompressedOutput();
1291	}
1292
1293	switch (domain->type)
1294	{
1295	case CDomain::type_attr::curvilinear:
1296	if (!compressedOutput \|\| !domain->isCompressible())
1297	{
1298	dimXid = StdString("x").append(appendDomId);
1299	dimIdList.push_back(dimXid);
1300	dimYid = StdString("y").append(appendDomId);
1301	dimIdList.push_back(dimYid);
1302	}
1303	dimCoordList.push_back(StdString("nav_lon").append(appendDomId));
1304	dimCoordList.push_back(StdString("nav_lat").append(appendDomId));
1305	break ;
1306	case CDomain::type_attr::rectilinear:
1307	if (!compressedOutput \|\| !domain->isCompressible())
1308	{
1309	dimXid = StdString("lon").append(appendDomId);
1310	dimIdList.push_back(dimXid);
1311	dimYid = StdString("lat").append(appendDomId);
1312	dimIdList.push_back(dimYid);
1313	}
1314	break ;
1315	case CDomain::type_attr::unstructured:
1316	{
1317	if (SuperClassWriter::useCFConvention)
1318	{
1319	dimXid = StdString("cell").append(appendDomId);
1320	dimIdList.push_back(dimXid);
1321	dimCoordList.push_back(StdString("lon").append(appendDomId));
1322	dimCoordList.push_back(StdString("lat").append(appendDomId));
1323	}
1324	else
1325	{
1326	StdString domainName = domain->name;
1327	if (domain->nvertex == 1)
1328	{
1329	dimXid = "n" + domainName + "_node";
1330	dimIdList.push_back(dimXid);
1331	dimCoordList.push_back(StdString(domainName + "_node_x"));
1332	dimCoordList.push_back(StdString(domainName + "_node_y"));
1333	}
1334	else if (domain->nvertex == 2)
1335	{
1336	dimXid = "n" + domainName + "_edge";
1337	dimIdList.push_back(dimXid);
1338	dimCoordList.push_back(StdString(domainName + "_edge_x"));
1339	dimCoordList.push_back(StdString(domainName + "_edge_y"));
1340	}
1341	else
1342	{
1343	dimXid = "n" + domainName + "_face";
1344	dimIdList.push_back(dimXid);
1345	dimCoordList.push_back(StdString(domainName + "_face_x"));
1346	dimCoordList.push_back(StdString(domainName + "_face_y"));
1347	}
1348	} // ugrid convention
1349	} // case unstructured domain
1350	}
1351
1352	if (domain->hasArea)
1353	{
1354	hasArea = true;
1355	cellMeasures += " area" + appendDomId;
1356	}
1357	++idxDomain;
1358	}
1359	else
1360	{
1361	CAxis* axis = CAxis::get(axisList[idxAxis]);
1362	StdString axisId = axis->getAxisOutputName();
1363
1364	if (compressedOutput && axis->isCompressible())
1365	{
1366	dimIdList.push_back(axisId + "_points");
1367	field->setUseCompressedOutput();
1368	}
1369	else
1370	dimIdList.push_back(axisId);
1371
1372	dimCoordList.push_back(axisId);
1373	++idxAxis;
1374	}
1375	}
1376
1377	/*
1378	StdString lonid_loc = (server->intraCommSize > 1)
1379	? StdString("lon").append(appendDomid).append("_local")
1380	: lonid;
1381	StdString latid_loc = (server->intraCommSize > 1)
1382	? StdString("lat").append(appendDomid).append("_local")
1383	: latid;
1384	*/
1385	StdString fieldid = field->getFieldOutputName();
1386
1387	// unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
1388	// bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
1389	// bool isCurvilinear = domain->isCurvilinear ;
1390
1391	nc_type type ;
1392	if (field->prec.isEmpty()) type = NC_FLOAT ;
1393	else
1394	{
1395	if (field->prec==2) type = NC_SHORT ;
1396	else if (field->prec==4) type = NC_FLOAT ;
1397	else if (field->prec==8) type = NC_DOUBLE ;
1398	}
1399
1400	bool wtime = !(!field->operation.isEmpty() && field->getOperationTimeType() == func::CFunctor::once);
1401
1402	if (wtime)
1403	{
1404
1405	//StdOStringStream oss;
1406	// oss << "time_" << field->operation.getValue()
1407	// << "_" << field->getRelFile()->output_freq.getValue();
1408	//oss
1409	if (field->getOperationTimeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
1410	else if (field->getOperationTimeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
1411	dims.push_back(timeid);
1412	}
1413
1414	if (compressedOutput && grid->isCompressible())
1415	{
1416	dims.push_back(grid->getId() + "_points");
1417	field->setUseCompressedOutput();
1418	}
1419	else
1420	{
1421	while (!dimIdList.empty())
1422	{
1423	dims.push_back(dimIdList.back());
1424	dimIdList.pop_back();
1425	}
1426	}
1427
1428	while (!dimCoordList.empty())
1429	{
1430	coodinates.push_back(dimCoordList.back());
1431	dimCoordList.pop_back();
1432	}
1433
1434	try
1435	{
1436	SuperClassWriter::addVariable(fieldid, type, dims);
1437
1438	if (!field->standard_name.isEmpty())
1439	SuperClassWriter::addAttribute
1440	("standard_name", field->standard_name.getValue(), &fieldid);
1441
1442	if (!field->long_name.isEmpty())
1443	SuperClassWriter::addAttribute
1444	("long_name", field->long_name.getValue(), &fieldid);
1445
1446	if (!field->unit.isEmpty())
1447	SuperClassWriter::addAttribute
1448	("units", field->unit.getValue(), &fieldid);
1449
1450	if (!field->valid_min.isEmpty())
1451	SuperClassWriter::addAttribute
1452	("valid_min", field->valid_min.getValue(), &fieldid);
1453
1454	if (!field->valid_max.isEmpty())
1455	SuperClassWriter::addAttribute
1456	("valid_max", field->valid_max.getValue(), &fieldid);
1457
1458	if (!field->scale_factor.isEmpty())
1459	SuperClassWriter::addAttribute
1460	("scale_factor", field->scale_factor.getValue(), &fieldid);
1461
1462	if (!field->add_offset.isEmpty())
1463	SuperClassWriter::addAttribute
1464	("add_offset", field->add_offset.getValue(), &fieldid);
1465
1466	SuperClassWriter::addAttribute
1467	("online_operation", field->operation.getValue(), &fieldid);
1468
1469	// write child variables as attributes
1470
1471
1472	vector<CVariable*> listVars = field->getAllVariables() ;
1473	for (vector<CVariable>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(it, fieldid) ;
1474
1475
1476	if (wtime)
1477	{
1478	CDuration freqOp = field->freq_op.getValue();
1479	freqOp.solveTimeStep(*context->calendar);
1480	StdString freqOpStr = freqOp.toStringUDUnits();
1481	SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
1482
1483	CDuration freqOut = field->getRelFile()->output_freq.getValue();
1484	freqOut.solveTimeStep(*context->calendar);
1485	SuperClassWriter::addAttribute("interval_write", freqOut.toStringUDUnits(), &fieldid);
1486
1487	StdString cellMethods = "time: ";
1488	if (field->operation.getValue() == "instant") cellMethods += "point";
1489	else if (field->operation.getValue() == "average") cellMethods += "mean";
1490	else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
1491	else cellMethods += field->operation;
1492	if (freqOp.resolve(context->calendar) != freqOut.resolve(context->calendar))
1493	cellMethods += " (interval: " + freqOpStr + ")";
1494	SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
1495	}
1496
1497	if (hasArea)
1498	SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
1499
1500	if (!field->default_value.isEmpty())
1501	{
1502	double default_value = field->default_value.getValue();
1503	float fdefault_value = (float)default_value;
1504	if (type == NC_DOUBLE)
1505	SuperClassWriter::setDefaultValue(fieldid, &default_value);
1506	else
1507	SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1508	}
1509	else
1510	SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1511
1512	if (field->compression_level.isEmpty())
1513	field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
1514	SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
1515
1516	{ // Ecriture des coordonnes
1517
1518	StdString coordstr; //boost::algorithm::join(coodinates, " ")
1519	std::vector<StdString>::iterator
1520	itc = coodinates.begin(), endc = coodinates.end();
1521
1522	for (; itc!= endc; itc++)
1523	{
1524	StdString & coord = *itc;
1525	if (itc+1 != endc)
1526	coordstr.append(coord).append(" ");
1527	else coordstr.append(coord);
1528	}
1529
1530	SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1531
1532	}
1533	}
1534	catch (CNetCdfException& e)
1535	{
1536	StdString msg("On writing field : ");
1537	msg.append(fieldid); msg.append("\n");
1538	msg.append("In the context : ");
1539	msg.append(context->getId()); msg.append("\n");
1540	msg.append(e.what());
1541	ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1542	}
1543	}
1544
1545	//--------------------------------------------------------------
1546	/*
1547	void CNc4DataOutput::writeField_(CField* field)
1548	{
1549	CContext* context = CContext::getCurrent() ;
1550	CContextServer* server=context->server ;
1551
1552	std::vector<StdString> dims, coodinates;
1553	CGrid* grid = field->grid;
1554	if (!grid->doGridHaveDataToWrite())
1555	if (SuperClass::type==MULTI_FILE) return ;
1556
1557	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
1558	int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
1559	std::vector<StdString> domainList = grid->getDomainList();
1560	std::vector<StdString> axisList = grid->getAxisList();
1561
1562	StdString timeid = getTimeCounterName();
1563	StdString dimXid,dimYid;
1564	std::deque<StdString> dimIdList, dimCoordList;
1565	bool hasArea = false;
1566	StdString cellMeasures = "area:";
1567	bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
1568
1569	for (int i = 0; i < numElement; ++i)
1570	{
1571	if (axisDomainOrder(i))
1572	{
1573	CDomain* domain = CDomain::get(domainList[idxDomain]);
1574	StdString domId = domain->getDomainOutputName();
1575	StdString appendDomId = singleDomain ? "" : "_" + domId ;
1576
1577	if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
1578	{
1579	dimIdList.push_back(domId + "_points");
1580	field->setUseCompressedOutput();
1581	}
1582
1583	switch (domain->type)
1584	{
1585	case CDomain::type_attr::curvilinear:
1586	if (!compressedOutput \|\| !domain->isCompressible())
1587	{
1588	dimXid = StdString("x").append(appendDomId);
1589	dimIdList.push_back(dimXid);
1590	dimYid = StdString("y").append(appendDomId);
1591	dimIdList.push_back(dimYid);
1592	}
1593	dimCoordList.push_back(StdString("nav_lon").append(appendDomId));
1594	dimCoordList.push_back(StdString("nav_lat").append(appendDomId));
1595	break ;
1596	case CDomain::type_attr::rectilinear:
1597	if (!compressedOutput \|\| !domain->isCompressible())
1598	{
1599	dimXid = StdString("lon").append(appendDomId);
1600	dimIdList.push_back(dimXid);
1601	dimYid = StdString("lat").append(appendDomId);
1602	dimIdList.push_back(dimYid);
1603	}
1604	break ;
1605	case CDomain::type_attr::unstructured:
1606	dimXid = StdString("cell").append(appendDomId);
1607	dimIdList.push_back(dimXid);
1608	dimCoordList.push_back(StdString("lon").append(appendDomId));
1609	dimCoordList.push_back(StdString("lat").append(appendDomId));
1610	break ;
1611	}
1612	if (domain->hasArea)
1613	{
1614	hasArea = true;
1615	cellMeasures += " area" + appendDomId;
1616	}
1617	++idxDomain;
1618	}
1619	else
1620	{
1621	CAxis* axis = CAxis::get(axisList[idxAxis]);
1622	StdString axisId = axis->getAxisOutputName();
1623
1624	if (compressedOutput && axis->isCompressible())
1625	{
1626	dimIdList.push_back(axisId + "_points");
1627	field->setUseCompressedOutput();
1628	}
1629	else
1630	dimIdList.push_back(axisId);
1631
1632	dimCoordList.push_back(axisId);
1633	++idxAxis;
1634	}
1635	}
1636
1637
1638	// StdString lonid_loc = (server->intraCommSize > 1)
1639	// ? StdString("lon").append(appendDomid).append("_local")
1640	// : lonid;
1641	// StdString latid_loc = (server->intraCommSize > 1)
1642	// ? StdString("lat").append(appendDomid).append("_local")
1643	// : latid;
1644
1645	StdString fieldid = field->getFieldOutputName();
1646
1647	// unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
1648	// bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
1649	// bool isCurvilinear = domain->isCurvilinear ;
1650
1651	nc_type type ;
1652	if (field->prec.isEmpty()) type = NC_FLOAT ;
1653	else
1654	{
1655	if (field->prec==2) type = NC_SHORT ;
1656	else if (field->prec==4) type = NC_FLOAT ;
1657	else if (field->prec==8) type = NC_DOUBLE ;
1658	}
1659
1660	bool wtime = !(!field->operation.isEmpty() && field->getOperationTimeType() == func::CFunctor::once);
1661
1662	if (wtime)
1663	{
1664
1665	//StdOStringStream oss;
1666	// oss << "time_" << field->operation.getValue()
1667	// << "_" << field->getRelFile()->output_freq.getValue();
1668	//oss
1669	if (field->getOperationTimeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
1670	else if (field->getOperationTimeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
1671	dims.push_back(timeid);
1672	}
1673
1674	if (compressedOutput && grid->isCompressible())
1675	{
1676	dims.push_back(grid->getId() + "_points");
1677	field->setUseCompressedOutput();
1678	}
1679	else
1680	{
1681	while (!dimIdList.empty())
1682	{
1683	dims.push_back(dimIdList.back());
1684	dimIdList.pop_back();
1685	}
1686	}
1687
1688	while (!dimCoordList.empty())
1689	{
1690	coodinates.push_back(dimCoordList.back());
1691	dimCoordList.pop_back();
1692	}
1693
1694	try
1695	{
1696	SuperClassWriter::addVariable(fieldid, type, dims);
1697
1698	if (!field->standard_name.isEmpty())
1699	SuperClassWriter::addAttribute
1700	("standard_name", field->standard_name.getValue(), &fieldid);
1701
1702	if (!field->long_name.isEmpty())
1703	SuperClassWriter::addAttribute
1704	("long_name", field->long_name.getValue(), &fieldid);
1705
1706	if (!field->unit.isEmpty())
1707	SuperClassWriter::addAttribute
1708	("units", field->unit.getValue(), &fieldid);
1709
1710	if (!field->valid_min.isEmpty())
1711	SuperClassWriter::addAttribute
1712	("valid_min", field->valid_min.getValue(), &fieldid);
1713
1714	if (!field->valid_max.isEmpty())
1715	SuperClassWriter::addAttribute
1716	("valid_max", field->valid_max.getValue(), &fieldid);
1717
1718	if (!field->scale_factor.isEmpty())
1719	SuperClassWriter::addAttribute
1720	("scale_factor", field->scale_factor.getValue(), &fieldid);
1721
1722	if (!field->add_offset.isEmpty())
1723	SuperClassWriter::addAttribute
1724	("add_offset", field->add_offset.getValue(), &fieldid);
1725
1726	SuperClassWriter::addAttribute
1727	("online_operation", field->operation.getValue(), &fieldid);
1728
1729	// write child variables as attributes
1730
1731
1732	vector<CVariable*> listVars = field->getAllVariables() ;
1733	for (vector<CVariable>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(it, fieldid) ;
1734
1735
1736	if (wtime)
1737	{
1738	CDuration freqOp = field->freq_op.getValue();
1739	freqOp.solveTimeStep(*context->calendar);
1740	StdString freqOpStr = freqOp.toStringUDUnits();
1741	SuperClassWriter::addAttribute("interval_operation", freqOpStr, &fieldid);
1742
1743	CDuration freqOut = field->getRelFile()->output_freq.getValue();
1744	freqOut.solveTimeStep(*context->calendar);
1745	SuperClassWriter::addAttribute("interval_write", freqOut.toStringUDUnits(), &fieldid);
1746
1747	StdString cellMethods = "time: ";
1748	if (field->operation.getValue() == "instant") cellMethods += "point";
1749	else if (field->operation.getValue() == "average") cellMethods += "mean";
1750	else if (field->operation.getValue() == "accumulate") cellMethods += "sum";
1751	else cellMethods += field->operation;
1752	if (freqOp.resolve(context->calendar) != freqOut.resolve(context->calendar))
1753	cellMethods += " (interval: " + freqOpStr + ")";
1754	SuperClassWriter::addAttribute("cell_methods", cellMethods, &fieldid);
1755	}
1756
1757	if (hasArea)
1758	SuperClassWriter::addAttribute("cell_measures", cellMeasures, &fieldid);
1759
1760	if (!field->default_value.isEmpty())
1761	{
1762	double default_value = field->default_value.getValue();
1763	float fdefault_value = (float)default_value;
1764	if (type == NC_DOUBLE)
1765	SuperClassWriter::setDefaultValue(fieldid, &default_value);
1766	else
1767	SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
1768	}
1769	else
1770	SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
1771
1772	if (field->compression_level.isEmpty())
1773	field->compression_level = field->file->compression_level.isEmpty() ? 0 : field->file->compression_level;
1774	SuperClassWriter::setCompressionLevel(fieldid, field->compression_level);
1775
1776	{ // Ecriture des coordonnes
1777
1778	StdString coordstr; //boost::algorithm::join(coodinates, " ")
1779	std::vector<StdString>::iterator
1780	itc = coodinates.begin(), endc = coodinates.end();
1781
1782	for (; itc!= endc; itc++)
1783	{
1784	StdString & coord = *itc;
1785	if (itc+1 != endc)
1786	coordstr.append(coord).append(" ");
1787	else coordstr.append(coord);
1788	}
1789
1790	SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
1791
1792	}
1793	}
1794	catch (CNetCdfException& e)
1795	{
1796	StdString msg("On writing field : ");
1797	msg.append(fieldid); msg.append("\n");
1798	msg.append("In the context : ");
1799	msg.append(context->getId()); msg.append("\n");
1800	msg.append(e.what());
1801	ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
1802	}
1803	}
1804
1805	*/
1806	//--------------------------------------------------------------
1807
1808	void CNc4DataOutput::writeFile_ (CFile* file)
1809	{
1810	StdString filename = file->getFileOutputName();
1811	StdString description = (!file->description.isEmpty())
1812	? file->description.getValue()
1813	: StdString("Created by xios");
1814
1815	singleDomain = (file->nbDomains == 1);
1816
1817	try
1818	{
1819	if (SuperClassWriter::useCFConvention)
1820	this->writeFileAttributes(filename, description,
1821	StdString("CF-1.5"),
1822	StdString("An IPSL model"),
1823	this->getTimeStamp());
1824	else
1825	this->writeFileAttributes(filename, description,
1826	StdString("UGRID"),
1827	StdString("An IPSL model"),
1828	this->getTimeStamp());
1829
1830
1831	if (!appendMode)
1832	SuperClassWriter::addDimension("axis_nbounds", 2);
1833	}
1834	catch (CNetCdfException& e)
1835	{
1836	StdString msg("On writing file : ");
1837	msg.append(filename); msg.append("\n");
1838	msg.append("In the context : ");
1839	CContext* context = CContext::getCurrent() ;
1840	msg.append(context->getId()); msg.append("\n");
1841	msg.append(e.what());
1842	ERROR("CNc4DataOutput::writeFile_ (CFile* file)", << msg);
1843	}
1844	}
1845
1846	void CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)
1847	{
1848	StdString name = var->getVariableOutputName();
1849
1850	try
1851	{
1852	if (var->type.getValue() == CVariable::type_attr::t_int \|\| var->type.getValue() == CVariable::type_attr::t_int32)
1853	addAttribute(name, var->getData<int>(), &fieldId);
1854	else if (var->type.getValue() == CVariable::type_attr::t_int16)
1855	addAttribute(name, var->getData<short int>(), &fieldId);
1856	else if (var->type.getValue() == CVariable::type_attr::t_float)
1857	addAttribute(name, var->getData<float>(), &fieldId);
1858	else if (var->type.getValue() == CVariable::type_attr::t_double)
1859	addAttribute(name, var->getData<double>(), &fieldId);
1860	else if (var->type.getValue() == CVariable::type_attr::t_string)
1861	addAttribute(name, var->getData<string>(), &fieldId);
1862	else
1863	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)",
1864	<< "Unsupported variable of type " << var->type.getStringValue());
1865	}
1866	catch (CNetCdfException& e)
1867	{
1868	StdString msg("On writing attributes of variable with name : ");
1869	msg.append(name); msg.append("in the field "); msg.append(fieldId); msg.append("\n");
1870	msg.append("In the context : ");
1871	CContext* context = CContext::getCurrent() ;
1872	msg.append(context->getId()); msg.append("\n");
1873	msg.append(e.what());
1874	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId)", << msg);
1875	}
1876	}
1877
1878	void CNc4DataOutput::writeAttribute_ (CVariable* var)
1879	{
1880	StdString name = var->getVariableOutputName();
1881
1882	try
1883	{
1884	if (var->type.getValue() == CVariable::type_attr::t_int \|\| var->type.getValue() == CVariable::type_attr::t_int32)
1885	addAttribute(name, var->getData<int>());
1886	else if (var->type.getValue() == CVariable::type_attr::t_int16)
1887	addAttribute(name, var->getData<short int>());
1888	else if (var->type.getValue() == CVariable::type_attr::t_float)
1889	addAttribute(name, var->getData<float>());
1890	else if (var->type.getValue() == CVariable::type_attr::t_double)
1891	addAttribute(name, var->getData<double>());
1892	else if (var->type.getValue() == CVariable::type_attr::t_string)
1893	addAttribute(name, var->getData<string>());
1894	else
1895	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)",
1896	<< "Unsupported variable of type " << var->type.getStringValue());
1897	}
1898	catch (CNetCdfException& e)
1899	{
1900	StdString msg("On writing attributes of variable with name : ");
1901	msg.append(name); msg.append("\n");
1902	msg.append("In the context : ");
1903	CContext* context = CContext::getCurrent() ;
1904	msg.append(context->getId()); msg.append("\n");
1905	msg.append(e.what());
1906	ERROR("CNc4DataOutput::writeAttribute_ (CVariable* var)", << msg);
1907	}
1908	}
1909
1910	void CNc4DataOutput::syncFile_ (void)
1911	{
1912	try
1913	{
1914	SuperClassWriter::sync() ;
1915	}
1916	catch (CNetCdfException& e)
1917	{
1918	StdString msg("On synchronizing the write among processes");
1919	msg.append("In the context : ");
1920	CContext* context = CContext::getCurrent() ;
1921	msg.append(context->getId()); msg.append("\n");
1922	msg.append(e.what());
1923	ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1924	}
1925	}
1926
1927	void CNc4DataOutput::closeFile_ (void)
1928	{
1929	try
1930	{
1931	SuperClassWriter::close() ;
1932	}
1933	catch (CNetCdfException& e)
1934	{
1935	StdString msg("On closing file");
1936	msg.append("In the context : ");
1937	CContext* context = CContext::getCurrent() ;
1938	msg.append(context->getId()); msg.append("\n");
1939	msg.append(e.what());
1940	ERROR("CNc4DataOutput::syncFile_ (void)", << msg);
1941	}
1942
1943	}
1944
1945	//---------------------------------------------------------------
1946
1947	StdString CNc4DataOutput::getTimeStamp(void) const
1948	{
1949	const int buffer_size = 100;
1950	time_t rawtime;
1951	struct tm * timeinfo = NULL;
1952	char buffer [buffer_size];
1953
1954	time ( &rawtime );
1955	timeinfo = localtime ( &rawtime );
1956	strftime (buffer, buffer_size, "%Y-%b-%d %H:%M:%S %Z", timeinfo);
1957
1958	return (StdString(buffer));
1959	}
1960
1961	//---------------------------------------------------------------
1962
1963	void CNc4DataOutput::writeFieldData_ (CField* field)
1964	{
1965	CContext* context = CContext::getCurrent();
1966	CContextServer* server = context->server;
1967	CGrid* grid = field->grid;
1968
1969	if (!grid->doGridHaveDataToWrite())
1970	if (SuperClass::type == MULTI_FILE \|\| !isCollective) return;
1971
1972	StdString fieldid = field->getFieldOutputName();
1973
1974	StdOStringStream oss;
1975	string timeAxisId;
1976	if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisId = "time_instant";
1977	else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisId = "time_centered";
1978
1979	StdString timeBoundId = getTimeCounterName() + "_bounds";
1980
1981	StdString timeAxisBoundId;
1982	if (field->getOperationTimeType() == func::CFunctor::instant) timeAxisBoundId = "time_instant_bounds";
1983	else if (field->getOperationTimeType() == func::CFunctor::centered) timeAxisBoundId = "time_centered_bounds";
1984
1985	if (!field->wasWritten())
1986	{
1987	if (appendMode && field->file->record_offset.isEmpty())
1988	{
1989	field->resetNStep(getRecordFromTime(field->last_Write_srv) + 1);
1990	}
1991
1992	field->setWritten();
1993	}
1994
1995
1996	CArray<double,1> time_data(1);
1997	CArray<double,1> time_data_bound(2);
1998	CArray<double,1> time_counter(1);
1999	CArray<double,1> time_counter_bound(2);
2000
2001	bool wtime = (field->getOperationTimeType() != func::CFunctor::once);
2002
2003	if (wtime)
2004	{
2005	Time lastWrite = field->last_Write_srv;
2006	Time lastLastWrite = field->lastlast_Write_srv;
2007
2008	if (field->getOperationTimeType() == func::CFunctor::instant)
2009	time_data(0) = lastWrite;
2010	else if (field->getOperationTimeType() == func::CFunctor::centered)
2011	time_data(0) = (lastWrite + lastLastWrite) / 2;
2012
2013	if (field->getOperationTimeType() == func::CFunctor::instant)
2014	time_data_bound(0) = time_data_bound(1) = lastWrite;
2015	else if (field->getOperationTimeType() == func::CFunctor::centered)
2016	{
2017	time_data_bound(0) = lastLastWrite;
2018	time_data_bound(1) = lastWrite;
2019	}
2020
2021	if (field->file->time_counter == CFile::time_counter_attr::instant)
2022	time_counter(0) = lastWrite;
2023	else if (field->file->time_counter == CFile::time_counter_attr::centered)
2024	time_counter(0) = (lastWrite + lastLastWrite) / 2;
2025	else if (field->file->time_counter == CFile::time_counter_attr::record)
2026	time_counter(0) = field->getNStep() - 1;
2027
2028
2029	if (field->file->time_counter == CFile::time_counter_attr::instant)
2030	time_counter_bound(0) = time_counter_bound(1) = lastWrite;
2031	else if (field->file->time_counter == CFile::time_counter_attr::centered)
2032	{
2033	time_counter_bound(0) = lastLastWrite;
2034	time_counter_bound(1) = lastWrite;
2035	}
2036	else if (field->file->time_counter == CFile::time_counter_attr::record)
2037	time_counter_bound(0) = time_counter_bound(1) = field->getNStep() - 1;
2038	}
2039
2040	bool isRoot = (server->intraCommRank == 0);
2041
2042	if (!field->scale_factor.isEmpty() \|\| !field->add_offset.isEmpty())
2043	{
2044	double scaleFactor = 1.0;
2045	double addOffset = 0.0;
2046	if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
2047	if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
2048	field->scaleFactorAddOffset(scaleFactor, addOffset);
2049	}
2050
2051	try
2052	{
2053	size_t writtenSize;
2054	if (field->getUseCompressedOutput())
2055	writtenSize = grid->getNumberWrittenIndexes();
2056	else
2057	writtenSize = grid->getWrittenDataSize();
2058
2059	CArray<double,1> fieldData(writtenSize);
2060	if (!field->default_value.isEmpty()) fieldData = field->default_value;
2061
2062	if (field->getUseCompressedOutput())
2063	field->outputCompressedField(fieldData);
2064	else
2065	field->outputField(fieldData);
2066
2067	if (!field->prec.isEmpty() && field->prec == 2) fieldData = round(fieldData);
2068
2069	switch (SuperClass::type)
2070	{
2071	case (MULTI_FILE) :
2072	{
2073	SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1);
2074	if (wtime)
2075	{
2076	SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep() - 1);
2077	SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1);
2078	if (field->file->time_counter != CFile::time_counter_attr::none)
2079	{
2080	SuperClassWriter::writeData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1);
2081	if (field->file->time_counter != CFile::time_counter_attr::record)
2082	SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1);
2083	}
2084	}
2085	break;
2086	}
2087	case (ONE_FILE) :
2088	{
2089	const std::vector<int>& nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
2090	const std::vector<int>& nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
2091	const std::vector<int>& nZoomSizeServer = grid->getDistributionServer()->getZoomSizeServer();
2092
2093	std::vector<StdSize> start, count;
2094
2095	if (field->getUseCompressedOutput())
2096	{
2097	if (grid->isCompressible())
2098	{
2099	start.push_back(grid->getOffsetWrittenIndexes());
2100	count.push_back(grid->getNumberWrittenIndexes());
2101	}
2102	else
2103	{
2104	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
2105	std::vector<StdString> domainList = grid->getDomainList();
2106	std::vector<StdString> axisList = grid->getAxisList();
2107	int numElement = axisDomainOrder.numElements();
2108	int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
2109	int idx = nZoomBeginGlobal.size() - 1;
2110
2111	start.reserve(nZoomBeginGlobal.size());
2112	count.reserve(nZoomBeginGlobal.size());
2113
2114
2115	for (int i = numElement - 1; i >= 0; --i)
2116	{
2117	if (axisDomainOrder(i))
2118	{
2119	CDomain* domain = CDomain::get(domainList[idxDomain]);
2120
2121	if (domain->isCompressible())
2122	{
2123	start.push_back(domain->getOffsetWrittenIndexes());
2124	count.push_back(domain->getNumberWrittenIndexes());
2125	idx -= 2;
2126	}
2127	else
2128	{
2129	if ((domain->type) != CDomain::type_attr::unstructured)
2130	{
2131	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2132	count.push_back(nZoomSizeServer[idx]);
2133	}
2134	--idx;
2135	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2136	count.push_back(nZoomSizeServer[idx]);
2137	--idx;
2138	}
2139	--idxDomain;
2140	}
2141	else
2142	{
2143	CAxis* axis = CAxis::get(axisList[idxAxis]);
2144
2145	if (axis->isCompressible())
2146	{
2147	start.push_back(axis->getOffsetWrittenIndexes());
2148	count.push_back(axis->getNumberWrittenIndexes());
2149	}
2150	else
2151	{
2152	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2153	count.push_back(nZoomSizeServer[idx]);
2154	}
2155
2156	--idxAxis;
2157	--idx;
2158	}
2159	}
2160	}
2161	}
2162	else
2163	{
2164
2165	CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
2166	std::vector<StdString> domainList = grid->getDomainList();
2167	std::vector<StdString> axisList = grid->getAxisList();
2168	int numElement = axisDomainOrder.numElements();
2169	int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
2170	int idx = nZoomBeginGlobal.size() - 1;
2171
2172	start.reserve(nZoomBeginGlobal.size());
2173	count.reserve(nZoomBeginGlobal.size());
2174
2175	for (int i = numElement - 1; i >= 0; --i)
2176	{
2177	if (axisDomainOrder(i))
2178	{
2179	CDomain* domain = CDomain::get(domainList[idxDomain]);
2180	if ((domain->type) != CDomain::type_attr::unstructured)
2181	{
2182	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2183	count.push_back(nZoomSizeServer[idx]);
2184	}
2185	--idx ;
2186	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2187	count.push_back(nZoomSizeServer[idx]);
2188	--idx ;
2189	--idxDomain;
2190	}
2191	else
2192	{
2193	start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
2194	count.push_back(nZoomSizeServer[idx]);
2195	--idx;
2196	}
2197	}
2198	}
2199
2200	SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep() - 1, &start, &count);
2201	if (wtime)
2202	{
2203	SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep() - 1, isRoot);
2204	SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep() - 1, isRoot);
2205	if (field->file->time_counter != CFile::time_counter_attr::none)
2206	{
2207	SuperClassWriter::writeTimeAxisData(time_counter, getTimeCounterName(), isCollective, field->getNStep() - 1, isRoot);
2208	if (field->file->time_counter != CFile::time_counter_attr::record)
2209	SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep() - 1, isRoot);
2210	}
2211	}
2212
2213	break;
2214	}
2215	}
2216	}
2217	catch (CNetCdfException& e)
2218	{
2219	StdString msg("On writing field data: ");
2220	msg.append(fieldid); msg.append("\n");
2221	msg.append("In the context : ");
2222	msg.append(context->getId()); msg.append("\n");
2223	msg.append(e.what());
2224	ERROR("CNc4DataOutput::writeFieldData_ (CField* field)", << msg);
2225	}
2226	}
2227
2228	//---------------------------------------------------------------
2229
2230	void CNc4DataOutput::writeTimeAxis_
2231	(CField* field,
2232	const boost::shared_ptr<CCalendar> cal)
2233	{
2234	StdOStringStream oss;
2235
2236	if (field->getOperationTimeType() == func::CFunctor::once) return ;
2237
2238	// oss << "time_" << field->operation.getValue()
2239	// << "_" << field->getRelFile()->output_freq.getValue();
2240
2241	// StdString axisid = oss.str();
2242	// if (field->getOperationTimeType() == func::CFunctor::centered) axisid="time_centered" ;
2243	// else if (field->getOperationTimeType() == func::CFunctor::instant) axisid="time_instant" ;
2244
2245	StdString axisid("time_centered") ;
2246	StdString axisBoundId("time_centered_bounds");
2247	StdString timeid(getTimeCounterName());
2248	StdString timeBoundId("axis_nbounds");
2249
2250	if (field->getOperationTimeType() == func::CFunctor::instant)
2251	{
2252	axisid = "time_instant";
2253	axisBoundId = "time_instant_bounds";
2254	}
2255
2256	try
2257	{
2258	// Adding time_instant or time_centered
2259	std::vector<StdString> dims;
2260	dims.push_back(timeid);
2261	if (!SuperClassWriter::varExist(axisid))
2262	{
2263	SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
2264
2265	CDate timeOrigin=cal->getTimeOrigin() ;
2266	StdOStringStream oss2;
2267	// oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" "
2268	// <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ;
2269	StdString strInitdate=oss2.str() ;
2270	StdString strTimeOrigin=timeOrigin.toString() ;
2271	this->writeTimeAxisAttributes
2272	(axisid, cal->getType(),
2273	StdString("seconds since ").append(strTimeOrigin),
2274	strTimeOrigin, axisBoundId);
2275	}
2276
2277	// Adding time_instant_bounds or time_centered_bounds variables
2278	if (!SuperClassWriter::varExist(axisBoundId))
2279	{
2280	dims.clear() ;
2281	dims.push_back(timeid);
2282	dims.push_back(timeBoundId);
2283	SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
2284	}
2285
2286	if (field->file->time_counter != CFile::time_counter_attr::none)
2287	{
2288	// Adding time_counter
2289	axisid = getTimeCounterName();
2290	axisBoundId = getTimeCounterName() + "_bounds";
2291	dims.clear();
2292	dims.push_back(timeid);
2293	if (!SuperClassWriter::varExist(axisid))
2294	{
2295	SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims);
2296	SuperClassWriter::addAttribute("axis", string("T"), &axisid);
2297
2298	if (field->file->time_counter != CFile::time_counter_attr::record)
2299	{
2300	CDate timeOrigin = cal->getTimeOrigin();
2301	StdString strTimeOrigin = timeOrigin.toString();
2302
2303	this->writeTimeAxisAttributes(axisid, cal->getType(),
2304	StdString("seconds since ").append(strTimeOrigin),
2305	strTimeOrigin, axisBoundId);
2306	}
2307	}
2308
2309	// Adding time_counter_bound dimension
2310	if (field->file->time_counter != CFile::time_counter_attr::record)
2311	{
2312	if (!SuperClassWriter::varExist(axisBoundId))
2313	{
2314	dims.clear();
2315	dims.push_back(timeid);
2316	dims.push_back(timeBoundId);
2317	SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims);
2318	}
2319	}
2320	}
2321	}
2322	catch (CNetCdfException& e)
2323	{
2324	StdString msg("On writing time axis data: ");
2325	msg.append("In the context : ");
2326	CContext* context = CContext::getCurrent() ;
2327	msg.append(context->getId()); msg.append("\n");
2328	msg.append(e.what());
2329	ERROR("CNc4DataOutput::writeTimeAxis_ (CField* field, \
2330	const boost::shared_ptr<CCalendar> cal)", << msg);
2331	}
2332	}
2333
2334	//---------------------------------------------------------------
2335
2336	void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name,
2337	const StdString & calendar,
2338	const StdString & units,
2339	const StdString & time_origin,
2340	const StdString & time_bounds,
2341	const StdString & standard_name,
2342	const StdString & long_name)
2343	{
2344	try
2345	{
2346	SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
2347	SuperClassWriter::addAttribute("long_name", long_name , &axis_name);
2348	SuperClassWriter::addAttribute("calendar", calendar , &axis_name);
2349	SuperClassWriter::addAttribute("units", units , &axis_name);
2350	SuperClassWriter::addAttribute("time_origin", time_origin , &axis_name);
2351	SuperClassWriter::addAttribute("bounds", time_bounds , &axis_name);
2352	}
2353	catch (CNetCdfException& e)
2354	{
2355	StdString msg("On writing time axis Attribute: ");
2356	msg.append("In the context : ");
2357	CContext* context = CContext::getCurrent() ;
2358	msg.append(context->getId()); msg.append("\n");
2359	msg.append(e.what());
2360	ERROR("CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, \
2361	const StdString & calendar,\
2362	const StdString & units, \
2363	const StdString & time_origin, \
2364	const StdString & time_bounds, \
2365	const StdString & standard_name, \
2366	const StdString & long_name)", << msg);
2367	}
2368	}
2369
2370	//---------------------------------------------------------------
2371
2372	void CNc4DataOutput::writeAxisAttributes(const StdString & axis_name,
2373	const StdString & axis,
2374	const StdString & standard_name,
2375	const StdString & long_name,
2376	const StdString & units,
2377	const StdString & nav_model)
2378	{
2379	try
2380	{
2381	if (!axis.empty())
2382	SuperClassWriter::addAttribute("axis" , axis , &axis_name);
2383
2384	SuperClassWriter::addAttribute("standard_name", standard_name, &axis_name);
2385	SuperClassWriter::addAttribute("long_name" , long_name , &axis_name);
2386	SuperClassWriter::addAttribute("units" , units , &axis_name);
2387	SuperClassWriter::addAttribute("nav_model" , nav_model , &axis_name);
2388	}
2389	catch (CNetCdfException& e)
2390	{
2391	StdString msg("On writing Axis Attribute: ");
2392	msg.append("In the context : ");
2393	CContext* context = CContext::getCurrent() ;
2394	msg.append(context->getId()); msg.append("\n");
2395	msg.append(e.what());
2396	ERROR("CNc4DataOutput::writeAxisAttributes(const StdString & axis_name, \
2397	const StdString & axis, \
2398	const StdString & standard_name, \
2399	const StdString & long_name, \
2400	const StdString & units, \
2401	const StdString & nav_model)", << msg);
2402	}
2403	}
2404
2405	//---------------------------------------------------------------
2406
2407	void CNc4DataOutput::writeLocalAttributes
2408	(int ibegin, int ni, int jbegin, int nj, StdString domid)
2409	{
2410	try
2411	{
2412	SuperClassWriter::addAttribute(StdString("ibegin").append(domid), ibegin);
2413	SuperClassWriter::addAttribute(StdString("ni" ).append(domid), ni);
2414	SuperClassWriter::addAttribute(StdString("jbegin").append(domid), jbegin);
2415	SuperClassWriter::addAttribute(StdString("nj" ).append(domid), nj);
2416	}
2417	catch (CNetCdfException& e)
2418	{
2419	StdString msg("On writing Local Attributes: ");
2420	msg.append("In the context : ");
2421	CContext* context = CContext::getCurrent() ;
2422	msg.append(context->getId()); msg.append("\n");
2423	msg.append(e.what());
2424	ERROR("CNc4DataOutput::writeLocalAttributes \
2425	(int ibegin, int ni, int jbegin, int nj, StdString domid)", << msg);
2426	}
2427
2428	}
2429
2430	void CNc4DataOutput::writeLocalAttributes_IOIPSL(const StdString& dimXid, const StdString& dimYid,
2431	int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)
2432	{
2433	CArray<int,1> array(2) ;
2434
2435	try
2436	{
2437	SuperClassWriter::addAttribute("DOMAIN_number_total",size ) ;
2438	SuperClassWriter::addAttribute("DOMAIN_number", rank) ;
2439	array = SuperClassWriter::getDimension(dimXid) + 1, SuperClassWriter::getDimension(dimYid) + 1;
2440	SuperClassWriter::addAttribute("DOMAIN_dimensions_ids",array) ;
2441	array=ni_glo,nj_glo ;
2442	SuperClassWriter::addAttribute("DOMAIN_size_global", array) ;
2443	array=ni,nj ;
2444	SuperClassWriter::addAttribute("DOMAIN_size_local", array) ;
2445	array=ibegin+1,jbegin+1 ;
2446	SuperClassWriter::addAttribute("DOMAIN_position_first", array) ;
2447	array=ibegin+ni-1+1,jbegin+nj-1+1 ;
2448	SuperClassWriter::addAttribute("DOMAIN_position_last",array) ;
2449	array=0,0 ;
2450	SuperClassWriter::addAttribute("DOMAIN_halo_size_start", array) ;
2451	SuperClassWriter::addAttribute("DOMAIN_halo_size_end", array);
2452	SuperClassWriter::addAttribute("DOMAIN_type",string("box")) ;
2453	/*
2454	SuperClassWriter::addAttribute("DOMAIN_DIM_N001",string("x")) ;
2455	SuperClassWriter::addAttribute("DOMAIN_DIM_N002",string("y")) ;
2456	SuperClassWriter::addAttribute("DOMAIN_DIM_N003",string("axis_A")) ;
2457	SuperClassWriter::addAttribute("DOMAIN_DIM_N004",string("time_counter")) ;
2458	*/
2459	}
2460	catch (CNetCdfException& e)
2461	{
2462	StdString msg("On writing Local Attributes IOIPSL \n");
2463	msg.append("In the context : ");
2464	CContext* context = CContext::getCurrent() ;
2465	msg.append(context->getId()); msg.append("\n");
2466	msg.append(e.what());
2467	ERROR("CNc4DataOutput::writeLocalAttributes_IOIPSL \
2468	(int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size)", << msg);
2469	}
2470	}
2471	//---------------------------------------------------------------
2472
2473	void CNc4DataOutput:: writeFileAttributes(const StdString & name,
2474	const StdString & description,
2475	const StdString & conventions,
2476	const StdString & production,
2477	const StdString & timeStamp)
2478	{
2479	try
2480	{
2481	SuperClassWriter::addAttribute("name" , name);
2482	SuperClassWriter::addAttribute("description", description);
2483	SuperClassWriter::addAttribute("title" , description);
2484	SuperClassWriter::addAttribute("Conventions", conventions);
2485	SuperClassWriter::addAttribute("production" , production);
2486	SuperClassWriter::addAttribute("timeStamp" , timeStamp);
2487	}
2488	catch (CNetCdfException& e)
2489	{
2490	StdString msg("On writing File Attributes \n ");
2491	msg.append("In the context : ");
2492	CContext* context = CContext::getCurrent() ;
2493	msg.append(context->getId()); msg.append("\n");
2494	msg.append(e.what());
2495	ERROR("CNc4DataOutput:: writeFileAttributes(const StdString & name, \
2496	const StdString & description, \
2497	const StdString & conventions, \
2498	const StdString & production, \
2499	const StdString & timeStamp)", << msg);
2500	}
2501	}
2502
2503	//---------------------------------------------------------------
2504
2505	void CNc4DataOutput::writeMaskAttributes(const StdString & mask_name,
2506	int data_dim,
2507	int data_ni,
2508	int data_nj,
2509	int data_ibegin,
2510	int data_jbegin)
2511	{
2512	try
2513	{
2514	SuperClassWriter::addAttribute("data_dim" , data_dim , &mask_name);
2515	SuperClassWriter::addAttribute("data_ni" , data_ni , &mask_name);
2516	SuperClassWriter::addAttribute("data_nj" , data_nj , &mask_name);
2517	SuperClassWriter::addAttribute("data_ibegin", data_ibegin, &mask_name);
2518	SuperClassWriter::addAttribute("data_jbegin", data_jbegin, &mask_name);
2519	}
2520	catch (CNetCdfException& e)
2521	{
2522	StdString msg("On writing Mask Attributes \n ");
2523	msg.append("In the context : ");
2524	CContext* context = CContext::getCurrent() ;
2525	msg.append(context->getId()); msg.append("\n");
2526	msg.append(e.what());
2527	ERROR("CNc4DataOutput::writeMaskAttributes(const StdString & mask_name, \
2528	int data_dim, \
2529	int data_ni, \
2530	int data_nj, \
2531	int data_ibegin, \
2532	int data_jbegin)", << msg);
2533	}
2534	}
2535
2536	///--------------------------------------------------------------
2537
2538	StdSize CNc4DataOutput::getRecordFromTime(Time time)
2539	{
2540	std::map<Time, StdSize>::const_iterator it = timeToRecordCache.find(time);
2541	if (it == timeToRecordCache.end())
2542	{
2543	StdString timeAxisBoundsId(getTimeCounterName() + "_bounds");
2544	if (!SuperClassWriter::varExist(timeAxisBoundsId))
2545	timeAxisBoundsId = "time_instant_bounds";
2546
2547	CArray<double,2> timeAxisBounds;
2548	SuperClassWriter::getTimeAxisBounds(timeAxisBounds, timeAxisBoundsId, isCollective);
2549
2550	StdSize record = 0;
2551	double dtime(time);
2552	for (int n = timeAxisBounds.extent(1) - 1; n >= 0; n--)
2553	{
2554	if (timeAxisBounds(1, n) < dtime)
2555	{
2556	record = n + 1;
2557	break;
2558	}
2559	}
2560	it = timeToRecordCache.insert(std::make_pair(time, record)).first;
2561	}
2562	return it->second;
2563	}
2564
2565	///--------------------------------------------------------------
2566
2567	bool CNc4DataOutput::isWrittenDomain(const std::string& domainName) const
2568	{
2569	return (this->writtenDomains.find(domainName) != this->writtenDomains.end());
2570	}
2571
2572	bool CNc4DataOutput::isWrittenCompressedDomain(const std::string& domainName) const
2573	{
2574	return (this->writtenCompressedDomains.find(domainName) != this->writtenCompressedDomains.end());
2575	}
2576
2577	bool CNc4DataOutput::isWrittenAxis(const std::string& axisName) const
2578	{
2579	return (this->writtenAxis.find(axisName) != this->writtenAxis.end());
2580	}
2581
2582	bool CNc4DataOutput::isWrittenCompressedAxis(const std::string& axisName) const
2583	{
2584	return (this->writtenCompressedAxis.find(axisName) != this->writtenCompressedAxis.end());
2585	}
2586
2587	void CNc4DataOutput::setWrittenDomain(const std::string& domainName)
2588	{
2589	this->writtenDomains.insert(domainName);
2590	}
2591
2592	void CNc4DataOutput::setWrittenCompressedDomain(const std::string& domainName)
2593	{
2594	this->writtenCompressedDomains.insert(domainName);
2595	}
2596
2597	void CNc4DataOutput::setWrittenAxis(const std::string& axisName)
2598	{
2599	this->writtenAxis.insert(axisName);
2600	}
2601
2602	void CNc4DataOutput::setWrittenCompressedAxis(const std::string& axisName)
2603	{
2604	this->writtenCompressedAxis.insert(axisName);
2605	}
2606	} // namespace xios

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

Download in other formats: