Context Navigation

source: XIOS/dev/branch_yushan/src/interface/c/icdata.cpp @ 1070

Last change on this file since 1070 was 1070, checked in by yushan, 7 years ago
Preperation for merge from trunk
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:eol-style set to `native`
File size: 37.7 KB

Line
1	/* ************************************************************************** *
2	* Copyright IPSL/LSCE, xios, Avril 2010 - Octobre 2011 *
3	* ************************************************************************** */
4
5	#include <boost/multi_array.hpp>
6	#include <boost/shared_ptr.hpp>
7	#include <string>
8	#include <cstring>
9	#include <iostream>
10
11
12	#include "xios.hpp"
13	//#include "oasis_cinterface.hpp"
14
15	#include "attribute_template.hpp"
16	#include "object_template.hpp"
17	#include "group_template.hpp"
18
19	#include "icutil.hpp"
20	#include "cxios.hpp"
21	#include "client.hpp"
22	#include "field.hpp"
23	#include "context.hpp"
24	#include "context_client.hpp"
25	#include "mpi_std.hpp"
26	#include "timer.hpp"
27	#include "array_new.hpp"
28
29	extern "C"
30	{
31	// /////////////////////////////// Dfinitions ////////////////////////////// //
32
33	// ----------------------- Redfinition de types ----------------------------
34
35	typedef enum { NETCDF4 = 0 } XFileType;
36
37	typedef xios::CContext* XContextPtr;
38
39	// -------------------- Traitement des donnes ------------------------------
40
41	// This function is not exported to the public Fortran interface,
42	// it is only used from the parse_xml.exe standalone test tool.
43	void cxios_init(void)
44	{
45	CXios::initialize();
46	}
47
48	void cxios_init_server(void)
49	{
50	CXios::initServerSide();
51	}
52
53	void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
54	{
55	std::string str;
56	ep_lib::MPI_Comm local_comm;
57	ep_lib::MPI_Comm return_comm;
58
59	ep_lib::fc_comm_map.clear();
60
61	if (!cstr2string(client_id, len_client_id, str)) return;
62
63	int initialized;
64	MPI_Initialized(&initialized);
65
66	#ifdef _usingEP
67	if (initialized) local_comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_local_comm));
68	else local_comm = MPI_COMM_NULL;
69	#else
70	if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
71	else local_comm = MPI_COMM_NULL;
72	#endif
73
74
75	CXios::initClientSide(str, local_comm, return_comm);
76
77	#ifdef _usingEP
78	*f_return_comm = ep_lib::EP_Comm_c2f(return_comm);
79	#else
80	*f_return_comm = MPI_Comm_c2f(return_comm);
81	#endif
82
83	CTimer::get("XIOS init").suspend();
84	CTimer::get("XIOS").suspend();
85	}
86
87	void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
88	{
89	std::string str;
90	ep_lib::MPI_Comm comm;
91
92	if (!cstr2string(context_id, len_context_id, str)) return;
93	CTimer::get("XIOS").resume();
94	CTimer::get("XIOS init context").resume();
95	comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_comm));
96
97	CClient::registerContext(str,comm);
98
99	CTimer::get("XIOS init context").suspend();
100	CTimer::get("XIOS").suspend();
101	}
102
103	void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
104	{
105	std::string str;
106
107	if (!cstr2string(context_id, len_context_id, str)) return;
108	CTimer::get("XIOS").resume();
109	CContext* context = CContext::get(str, str);
110	*initialized=context->isInitialized();
111	CTimer::get("XIOS").suspend();
112	}
113
114	void cxios_context_close_definition()
115	{
116	CTimer::get("XIOS").resume();
117	CTimer::get("XIOS close definition").resume();
118	CContext* context = CContext::getCurrent();
119
120	context->closeDefinition();
121
122	CTimer::get("XIOS close definition").suspend();
123	CTimer::get("XIOS").suspend();
124	}
125
126	void cxios_context_finalize()
127	{
128	CTimer::get("XIOS").resume();
129	CTimer::get("XIOS context finalize").resume();
130
131	CContext* context = CContext::getCurrent();
132	context->finalize();
133
134	CTimer::get("XIOS context finalize").suspend();
135	CTimer::get("XIOS").suspend();
136	}
137
138	void cxios_finalize()
139	{
140	CTimer::get("XIOS").resume();
141	CTimer::get("XIOS finalize").resume();
142	CXios::clientFinalize();
143	}
144
145	void cxios_solve_inheritance()
146	{
147	CTimer::get("XIOS").resume();
148	CContext* context = CContext::getCurrent();
149	context->solveAllInheritance(false);
150	CTimer::get("XIOS").suspend();
151	}
152
153	/*! \brief This group of functions retrieve variable information from the configuration file (.xml)
154	*
155	* These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
156	* from a Fortran one, for example the value of a variable with id = "using_server".
157	* Each function corresponds to each basic type.
158	* \param varId [in] id of the variable that we'd like to get
159	* \param varIdSize [in] size of the variable type (integer, float, double, string)
160	* \param dataInt [in/out] the retrieved data
161	* \param isVarExisted [in/out] Verify whether variable with varId exists
162	*/
163	void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
164	{
165	std::string varIdStr;
166	if (!cstr2string(varId, varIdSize, varIdStr)) return;
167
168	CTimer::get("XIOS").resume();
169	CTimer::get("XIOS get variable data").resume();
170
171	CContext* context = CContext::getCurrent();
172	*isVarExisted = CVariable::has(context->getId(), varIdStr);
173
174	if (*isVarExisted)
175	{
176	*data = CVariable::get(context->getId(), varIdStr)->getData<double>();
177	}
178
179	CTimer::get("XIOS get variable data").suspend();
180	CTimer::get("XIOS").suspend();
181	}
182
183	void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
184	{
185	std::string varIdStr;
186	if (!cstr2string(varId, varIdSize, varIdStr)) return;
187
188	CTimer::get("XIOS").resume();
189	CTimer::get("XIOS get variable data").resume();
190
191	CContext* context = CContext::getCurrent();
192	*isVarExisted = CVariable::has(context->getId(), varIdStr);
193
194	if (*isVarExisted)
195	{
196	*data = CVariable::get(context->getId(), varIdStr)->getData<float>();
197	}
198
199	CTimer::get("XIOS get variable data").suspend();
200	CTimer::get("XIOS").suspend();
201	}
202
203	void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
204	{
205	std::string varIdStr;
206	if (!cstr2string(varId, varIdSize, varIdStr)) return;
207
208	CTimer::get("XIOS").resume();
209	CTimer::get("XIOS get variable data").resume();
210
211	CContext* context = CContext::getCurrent();
212	*isVarExisted = CVariable::has(context->getId(), varIdStr);
213
214	if (*isVarExisted)
215	{
216	*data = CVariable::get(context->getId(), varIdStr)->getData<int>();
217	}
218
219	CTimer::get("XIOS get variable data").suspend();
220	CTimer::get("XIOS").suspend();
221	}
222
223	void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
224	{
225	std::string varIdStr;
226	if (!cstr2string(varId, varIdSize, varIdStr)) return;
227
228	CTimer::get("XIOS").resume();
229	CTimer::get("XIOS get variable data").resume();
230
231	CContext* context = CContext::getCurrent();
232	*isVarExisted = CVariable::has(context->getId(), varIdStr);
233
234	if (*isVarExisted)
235	{
236	*data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
237	}
238
239	CTimer::get("XIOS get variable data").suspend();
240	CTimer::get("XIOS").suspend();
241	}
242
243	void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
244	{
245	std::string varIdStr;
246	if (!cstr2string(varId, varIdSize, varIdStr)) return;
247
248	CTimer::get("XIOS").resume();
249	CTimer::get("XIOS get variable data").resume();
250
251	CContext* context = CContext::getCurrent();
252	*isVarExisted = CVariable::has(context->getId(), varIdStr);
253
254	if (*isVarExisted)
255	{
256	int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
257	strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
258	}
259
260	CTimer::get("XIOS get variable data").suspend();
261	CTimer::get("XIOS").suspend();
262	}
263
264	/*! \brief This group of functions write information into existing variable in the configuration file (.xml)
265	*
266	* These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
267	* from a Fortran one, for example the value of a variable with id = "using_server".
268	* Each function corresponds to each basic type.
269	* \param varId [in] id of the variable that we'd like to get
270	* \param varIdSize [in] size of the variable type (integer, float, double, string)
271	* \param data [in] the input data
272	* \param isVarExisted [in/out] Verify whether variable with varId exists
273	*/
274	void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted)
275	{
276	std::string varIdStr;
277	if (!cstr2string(varId, varIdSize, varIdStr)) return;
278
279	CTimer::get("XIOS").resume();
280	CTimer::get("XIOS set variable data").resume();
281
282	CContext* context = CContext::getCurrent();
283	*isVarExisted = CVariable::has(context->getId(), varIdStr);
284
285	if (*isVarExisted)
286	{
287	CVariable::get(context->getId(), varIdStr)->setData<double>(data);
288	}
289
290	CTimer::get("XIOS set variable data").suspend();
291	CTimer::get("XIOS").suspend();
292	}
293
294	void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted)
295	{
296	std::string varIdStr;
297	if (!cstr2string(varId, varIdSize, varIdStr)) return;
298
299	CTimer::get("XIOS").resume();
300	CTimer::get("XIOS set variable data").resume();
301
302	CContext* context = CContext::getCurrent();
303	*isVarExisted = CVariable::has(context->getId(), varIdStr);
304
305	if (*isVarExisted)
306	{
307	CVariable::get(context->getId(), varIdStr)->setData<float>(data);
308	}
309
310	CTimer::get("XIOS set variable data").suspend();
311	CTimer::get("XIOS").suspend();
312	}
313
314	void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
315	{
316	std::string varIdStr;
317	if (!cstr2string(varId, varIdSize, varIdStr)) return;
318
319	CTimer::get("XIOS").resume();
320	CTimer::get("XIOS set variable data").resume();
321
322	CContext* context = CContext::getCurrent();
323	*isVarExisted = CVariable::has(context->getId(), varIdStr);
324
325	if (*isVarExisted)
326	{
327	CVariable::get(context->getId(), varIdStr)->setData<int>(data);
328	}
329
330
331	CTimer::get("XIOS set variable data").suspend();
332	CTimer::get("XIOS").suspend();
333	}
334
335	void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
336	{
337	std::string varIdStr;
338	if (!cstr2string(varId, varIdSize, varIdStr)) return;
339
340	CTimer::get("XIOS").resume();
341	CTimer::get("XIOS set variable data").resume();
342
343	CContext* context = CContext::getCurrent();
344	*isVarExisted = CVariable::has(context->getId(), varIdStr);
345
346	if (*isVarExisted)
347	{
348	CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
349	}
350
351	CTimer::get("XIOS set variable data").suspend();
352	CTimer::get("XIOS").suspend();
353	}
354
355	void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
356	{
357	std::string varIdStr, dataStr;
358	if (!cstr2string(varId, varIdSize, varIdStr)) return;
359	if (!cstr2string(data, dataSizeIn, dataStr))
360	{
361	*isVarExisted = false;
362	return;
363	}
364
365	CTimer::get("XIOS").resume();
366	CTimer::get("XIOS set variable data").resume();
367
368	CContext* context = CContext::getCurrent();
369	*isVarExisted = CVariable::has(context->getId(), varIdStr);
370
371	if (*isVarExisted)
372	{
373	CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
374	}
375
376	CTimer::get("XIOS set variable data").suspend();
377	CTimer::get("XIOS").suspend();
378	}
379
380
381	// ---------------------- Ecriture des donnes ------------------------------
382
383	void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
384	{
385	std::string fieldid_str;
386	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
387
388	CTimer::get("XIOS").resume();
389	CTimer::get("XIOS send field").resume();
390	CContext* context = CContext::getCurrent();
391	if (!context->hasServer && !context->client->isAttachedModeEnabled())
392	context->checkBuffersAndListen();
393	CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
394	CField::get(fieldid_str)->setData(data);
395	CTimer::get("XIOS send field").suspend();
396	CTimer::get("XIOS").suspend();
397	}
398
399	void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
400	{
401	std::string fieldid_str;
402	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
403
404	CTimer::get("XIOS").resume();
405	CTimer::get("XIOS send field").resume();
406
407	CContext* context = CContext::getCurrent();
408	if (!context->hasServer && !context->client->isAttachedModeEnabled())
409	context->checkBuffersAndListen();
410
411	CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
412	CField::get(fieldid_str)->setData(data);
413
414	CTimer::get("XIOS send field").suspend();
415	CTimer::get("XIOS").suspend();
416	}
417
418	void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
419	{
420	std::string fieldid_str;
421	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
422
423	CTimer::get("XIOS").resume();
424	CTimer::get("XIOS send field").resume();
425
426	CContext* context = CContext::getCurrent();
427	if (!context->hasServer && !context->client->isAttachedModeEnabled())
428	context->checkBuffersAndListen();
429
430	CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
431	CField::get(fieldid_str)->setData(data);
432
433	CTimer::get("XIOS send field").suspend();
434	CTimer::get("XIOS").suspend();
435	}
436
437	void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
438	{
439	std::string fieldid_str;
440	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
441
442	CTimer::get("XIOS").resume();
443	CTimer::get("XIOS send field").resume();
444
445	CContext* context = CContext::getCurrent();
446	if (!context->hasServer && !context->client->isAttachedModeEnabled())
447	{
448	context->checkBuffersAndListen();
449	}
450
451	CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
452	CField::get(fieldid_str)->setData(data);
453
454	CTimer::get("XIOS send field").suspend();
455	CTimer::get("XIOS").suspend();
456	}
457
458	void cxios_write_data_k84(const char* fieldid, int fieldid_size, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size)
459	{
460	std::string fieldid_str;
461	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
462
463	CTimer::get("XIOS").resume();
464	CTimer::get("XIOS send field").resume();
465
466	CContext* context = CContext::getCurrent();
467	if (!context->hasServer && !context->client->isAttachedModeEnabled())
468	context->checkBuffersAndListen();
469
470	CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
471	CField::get(fieldid_str)->setData(data);
472
473	CTimer::get("XIOS send field").suspend();
474	CTimer::get("XIOS").suspend();
475	}
476
477	void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
478	int data_0size, int data_1size, int data_2size,
479	int data_3size, int data_4size)
480	{
481	std::string fieldid_str;
482	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
483
484	CTimer::get("XIOS").resume();
485	CTimer::get("XIOS send field").resume();
486
487	CContext* context = CContext::getCurrent();
488	if (!context->hasServer && !context->client->isAttachedModeEnabled())
489	context->checkBuffersAndListen();
490
491	CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
492	CField::get(fieldid_str)->setData(data);
493
494	CTimer::get("XIOS send field").suspend();
495	CTimer::get("XIOS").suspend();
496	}
497
498	void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
499	int data_0size, int data_1size, int data_2size,
500	int data_3size, int data_4size, int data_5size)
501	{
502	std::string fieldid_str;
503	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
504
505	CTimer::get("XIOS").resume();
506	CTimer::get("XIOS send field").resume();
507
508	CContext* context = CContext::getCurrent();
509	if (!context->hasServer && !context->client->isAttachedModeEnabled())
510	context->checkBuffersAndListen();
511
512	CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
513	CField::get(fieldid_str)->setData(data);
514
515	CTimer::get("XIOS send field").suspend();
516	CTimer::get("XIOS").suspend();
517	}
518
519	void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
520	int data_0size, int data_1size, int data_2size,
521	int data_3size, int data_4size, int data_5size,
522	int data_6size)
523	{
524	std::string fieldid_str;
525	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
526
527	CTimer::get("XIOS").resume();
528	CTimer::get("XIOS send field").resume();
529
530	CContext* context = CContext::getCurrent();
531	if (!context->hasServer && !context->client->isAttachedModeEnabled())
532	context->checkBuffersAndListen();
533
534	CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
535	CField::get(fieldid_str)->setData(data);
536
537	CTimer::get("XIOS send field").suspend();
538	CTimer::get("XIOS").suspend();
539	}
540
541	void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
542	{
543	std::string fieldid_str;
544	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
545
546	CTimer::get("XIOS").resume();
547	CTimer::get("XIOS send field").resume();
548	CContext* context = CContext::getCurrent();
549	if (!context->hasServer && !context->client->isAttachedModeEnabled())
550	context->checkBuffersAndListen();
551
552	CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
553	CArray<double, 1> data(data_Xsize) ;
554	data = data_tmp;
555	CField::get(fieldid_str)->setData(data);
556	CTimer::get("XIOS send field").suspend();
557	CTimer::get("XIOS").suspend();
558	}
559
560	void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
561	{
562	std::string fieldid_str;
563	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
564
565	CTimer::get("XIOS").resume();
566	CTimer::get("XIOS send field").resume();
567
568	CContext* context = CContext::getCurrent();
569	if (!context->hasServer && !context->client->isAttachedModeEnabled())
570	context->checkBuffersAndListen();
571
572	CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
573	CArray<double, 1> data(data_Xsize);
574	data = data_tmp;
575	CField::get(fieldid_str)->setData(data);
576
577	CTimer::get("XIOS send field").suspend();
578	CTimer::get("XIOS").suspend();
579	}
580
581	void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
582	{
583	std::string fieldid_str;
584	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
585
586	CTimer::get("XIOS").resume();
587	CTimer::get("XIOS send field").resume();
588
589	CContext* context = CContext::getCurrent();
590	if (!context->hasServer && !context->client->isAttachedModeEnabled())
591	context->checkBuffersAndListen();
592
593	CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
594	CArray<double, 2> data(data_Xsize, data_Ysize);
595	data = data_tmp;
596	CField::get(fieldid_str)->setData(data);
597
598	CTimer::get("XIOS send field").suspend();
599	CTimer::get("XIOS").suspend();
600	}
601
602	void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
603	{
604	std::string fieldid_str;
605	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
606
607	CTimer::get("XIOS").resume();
608	CTimer::get("XIOS send field").resume();
609
610	CContext* context = CContext::getCurrent();
611	if (!context->hasServer && !context->client->isAttachedModeEnabled())
612	context->checkBuffersAndListen();
613
614	CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
615	CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
616	data = data_tmp;
617	CField::get(fieldid_str)->setData(data);
618
619	CTimer::get("XIOS send field").suspend();
620	CTimer::get("XIOS").suspend();
621	}
622
623	void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
624	int data_0size, int data_1size, int data_2size,
625	int data_3size)
626	{
627	std::string fieldid_str;
628	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
629
630	CTimer::get("XIOS").resume();
631	CTimer::get("XIOS send field").resume();
632
633	CContext* context = CContext::getCurrent();
634	if (!context->hasServer && !context->client->isAttachedModeEnabled())
635	context->checkBuffersAndListen();
636
637	CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
638	CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
639	data = data_tmp;
640	CField::get(fieldid_str)->setData(data);
641
642	CTimer::get("XIOS send field").suspend();
643	CTimer::get("XIOS").suspend();
644	}
645
646	void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
647	int data_0size, int data_1size, int data_2size,
648	int data_3size, int data_4size)
649	{
650	std::string fieldid_str;
651	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
652
653	CTimer::get("XIOS").resume();
654	CTimer::get("XIOS send field").resume();
655
656	CContext* context = CContext::getCurrent();
657	if (!context->hasServer && !context->client->isAttachedModeEnabled())
658	context->checkBuffersAndListen();
659
660	CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
661	CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
662	data = data_tmp;
663	CField::get(fieldid_str)->setData(data);
664
665	CTimer::get("XIOS send field").suspend();
666	CTimer::get("XIOS").suspend();
667	}
668
669	void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
670	int data_0size, int data_1size, int data_2size,
671	int data_3size, int data_4size, int data_5size)
672	{
673	std::string fieldid_str;
674	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
675
676	CTimer::get("XIOS").resume();
677	CTimer::get("XIOS send field").resume();
678
679	CContext* context = CContext::getCurrent();
680	if (!context->hasServer && !context->client->isAttachedModeEnabled())
681	context->checkBuffersAndListen();
682
683	CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
684	CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
685	data = data_tmp;
686	CField::get(fieldid_str)->setData(data);
687
688	CTimer::get("XIOS send field").suspend();
689	CTimer::get("XIOS").suspend();
690	}
691
692	void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
693	int data_0size, int data_1size, int data_2size,
694	int data_3size, int data_4size, int data_5size,
695	int data_6size)
696	{
697	std::string fieldid_str;
698	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
699
700	CTimer::get("XIOS").resume();
701	CTimer::get("XIOS send field").resume();
702
703	CContext* context = CContext::getCurrent();
704	if (!context->hasServer && !context->client->isAttachedModeEnabled())
705	context->checkBuffersAndListen();
706
707	CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
708	CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
709	data = data_tmp;
710	CField::get(fieldid_str)->setData(data);
711
712	CTimer::get("XIOS send field").suspend();
713	CTimer::get("XIOS").suspend();
714	}
715
716	// ---------------------- Lecture des donnes ------------------------------
717
718	void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
719	{
720	std::string fieldid_str;
721	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
722
723	CTimer::get("XIOS").resume();
724	CTimer::get("XIOS recv field").resume();
725
726	CContext* context = CContext::getCurrent();
727	if (!context->hasServer && !context->client->isAttachedModeEnabled())
728	context->checkBuffersAndListen();
729
730	CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
731	CField::get(fieldid_str)->getData(data);
732
733	CTimer::get("XIOS recv field").suspend();
734	CTimer::get("XIOS").suspend();
735	}
736
737	void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
738	{
739	std::string fieldid_str;
740	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
741
742	CTimer::get("XIOS").resume();
743	CTimer::get("XIOS recv field").resume();
744
745	CContext* context = CContext::getCurrent();
746	if (!context->hasServer && !context->client->isAttachedModeEnabled())
747	context->checkBuffersAndListen();
748
749	CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
750	CField::get(fieldid_str)->getData(data);
751
752	CTimer::get("XIOS recv field").suspend();
753	CTimer::get("XIOS").suspend();
754	}
755
756	void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
757	{
758	std::string fieldid_str;
759	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
760
761	CTimer::get("XIOS").resume();
762	CTimer::get("XIOS recv field").resume();
763
764	CContext* context = CContext::getCurrent();
765	if (!context->hasServer && !context->client->isAttachedModeEnabled())
766	context->checkBuffersAndListen();
767
768	CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
769	CField::get(fieldid_str)->getData(data);
770
771	CTimer::get("XIOS recv field").suspend();
772	CTimer::get("XIOS").suspend();
773	}
774
775	void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
776	{
777	std::string fieldid_str;
778	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
779
780	CTimer::get("XIOS").resume();
781	CTimer::get("XIOS recv field").resume();
782
783	CContext* context = CContext::getCurrent();
784	if (!context->hasServer && !context->client->isAttachedModeEnabled())
785	context->checkBuffersAndListen();
786
787	CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
788	CField::get(fieldid_str)->getData(data);
789
790	CTimer::get("XIOS recv field").suspend();
791	CTimer::get("XIOS").suspend();
792	}
793
794	void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
795	int data_0size, int data_1size, int data_2size,
796	int data_3size)
797	{
798	std::string fieldid_str;
799	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
800
801	CTimer::get("XIOS").resume();
802	CTimer::get("XIOS recv field").resume();
803
804	CContext* context = CContext::getCurrent();
805	if (!context->hasServer && !context->client->isAttachedModeEnabled())
806	context->checkBuffersAndListen();
807
808	CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
809	CField::get(fieldid_str)->getData(data);
810
811	CTimer::get("XIOS recv field").suspend();
812	CTimer::get("XIOS").suspend();
813	}
814
815	void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
816	int data_0size, int data_1size, int data_2size,
817	int data_3size, int data_4size)
818	{
819	std::string fieldid_str;
820	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
821
822	CTimer::get("XIOS").resume();
823	CTimer::get("XIOS recv field").resume();
824
825	CContext* context = CContext::getCurrent();
826	if (!context->hasServer && !context->client->isAttachedModeEnabled())
827	context->checkBuffersAndListen();
828
829	CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
830	CField::get(fieldid_str)->getData(data);
831
832	CTimer::get("XIOS recv field").suspend();
833	CTimer::get("XIOS").suspend();
834	}
835
836	void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
837	int data_0size, int data_1size, int data_2size,
838	int data_3size, int data_4size, int data_5size)
839	{
840	std::string fieldid_str;
841	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
842
843	CTimer::get("XIOS").resume();
844	CTimer::get("XIOS recv field").resume();
845
846	CContext* context = CContext::getCurrent();
847	if (!context->hasServer && !context->client->isAttachedModeEnabled())
848	context->checkBuffersAndListen();
849
850	CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
851	CField::get(fieldid_str)->getData(data);
852
853	CTimer::get("XIOS recv field").suspend();
854	CTimer::get("XIOS").suspend();
855	}
856
857	void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
858	int data_0size, int data_1size, int data_2size,
859	int data_3size, int data_4size, int data_5size,
860	int data_6size)
861	{
862	std::string fieldid_str;
863	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
864
865	CTimer::get("XIOS").resume();
866	CTimer::get("XIOS recv field").resume();
867
868	CContext* context = CContext::getCurrent();
869	if (!context->hasServer && !context->client->isAttachedModeEnabled())
870	context->checkBuffersAndListen();
871
872	CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
873	CField::get(fieldid_str)->getData(data);
874
875	CTimer::get("XIOS recv field").suspend();
876	CTimer::get("XIOS").suspend();
877	}
878
879	void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
880	{
881	std::string fieldid_str;
882	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
883
884	CTimer::get("XIOS").resume();
885	CTimer::get("XIOS recv field").resume();
886
887	CContext* context = CContext::getCurrent();
888	if (!context->hasServer && !context->client->isAttachedModeEnabled())
889	context->checkBuffersAndListen();
890
891	CArray<double, 1> data(data_Xsize);
892	CField::get(fieldid_str)->getData(data);
893	CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
894	data_tmp = data;
895
896	CTimer::get("XIOS recv field").suspend();
897	CTimer::get("XIOS").suspend();
898	}
899
900	void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
901	{
902	std::string fieldid_str;
903	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
904
905	CTimer::get("XIOS").resume();
906	CTimer::get("XIOS recv field").resume();
907
908	CContext* context = CContext::getCurrent();
909	if (!context->hasServer && !context->client->isAttachedModeEnabled())
910	context->checkBuffersAndListen();
911
912	CArray<double, 1> data(data_Xsize);
913	CField::get(fieldid_str)->getData(data);
914	CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
915	data_tmp = data;
916
917	CTimer::get("XIOS recv field").suspend();
918	CTimer::get("XIOS").suspend();
919	}
920
921	void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
922	{
923	std::string fieldid_str;
924	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
925
926	CTimer::get("XIOS").resume();
927	CTimer::get("XIOS recv field").resume();
928
929	CContext* context = CContext::getCurrent();
930	if (!context->hasServer && !context->client->isAttachedModeEnabled())
931	context->checkBuffersAndListen();
932
933	CArray<double, 2> data(data_Xsize, data_Ysize);
934	CField::get(fieldid_str)->getData(data);
935	CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
936	data_tmp = data;
937
938	CTimer::get("XIOS recv field").suspend();
939	CTimer::get("XIOS").suspend();
940	}
941
942	void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
943	{
944	std::string fieldid_str;
945	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
946
947	CTimer::get("XIOS").resume();
948	CTimer::get("XIOS recv field").resume();
949
950	CContext* context = CContext::getCurrent();
951	if (!context->hasServer && !context->client->isAttachedModeEnabled())
952	context->checkBuffersAndListen();
953
954	CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
955	CField::get(fieldid_str)->getData(data);
956	CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
957	data_tmp = data;
958
959	CTimer::get("XIOS recv field").suspend();
960	CTimer::get("XIOS").suspend();
961	}
962
963	void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
964	int data_0size, int data_1size, int data_2size,
965	int data_3size)
966	{
967	std::string fieldid_str;
968	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
969
970	CTimer::get("XIOS").resume();
971	CTimer::get("XIOS recv field").resume();
972
973	CContext* context = CContext::getCurrent();
974	if (!context->hasServer && !context->client->isAttachedModeEnabled())
975	context->checkBuffersAndListen();
976
977	CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
978	CField::get(fieldid_str)->getData(data);
979	CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
980	data_tmp = data;
981
982	CTimer::get("XIOS recv field").suspend();
983	CTimer::get("XIOS").suspend();
984	}
985
986	void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
987	int data_0size, int data_1size, int data_2size,
988	int data_3size, int data_4size)
989	{
990	std::string fieldid_str;
991	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
992
993	CTimer::get("XIOS").resume();
994	CTimer::get("XIOS recv field").resume();
995
996	CContext* context = CContext::getCurrent();
997	if (!context->hasServer && !context->client->isAttachedModeEnabled())
998	context->checkBuffersAndListen();
999
1000	CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1001	CField::get(fieldid_str)->getData(data);
1002	CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1003	data_tmp = data;
1004
1005	CTimer::get("XIOS recv field").suspend();
1006	CTimer::get("XIOS").suspend();
1007	}
1008
1009	void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
1010	int data_0size, int data_1size, int data_2size,
1011	int data_3size, int data_4size, int data_5size)
1012	{
1013	std::string fieldid_str;
1014	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1015
1016	CTimer::get("XIOS").resume();
1017	CTimer::get("XIOS recv field").resume();
1018
1019	CContext* context = CContext::getCurrent();
1020	if (!context->hasServer && !context->client->isAttachedModeEnabled())
1021	context->checkBuffersAndListen();
1022
1023	CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1024	CField::get(fieldid_str)->getData(data);
1025	CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1026	data_tmp = data;
1027
1028	CTimer::get("XIOS recv field").suspend();
1029	CTimer::get("XIOS").suspend();
1030	}
1031
1032	void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1033	int data_0size, int data_1size, int data_2size,
1034	int data_3size, int data_4size, int data_5size,
1035	int data_6size)
1036	{
1037	std::string fieldid_str;
1038	if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1039
1040	CTimer::get("XIOS").resume();
1041	CTimer::get("XIOS recv field").resume();
1042
1043	CContext* context = CContext::getCurrent();
1044	if (!context->hasServer && !context->client->isAttachedModeEnabled())
1045	context->checkBuffersAndListen();
1046
1047	CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1048	CField::get(fieldid_str)->getData(data);
1049	CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1050	data_tmp = data;
1051
1052	CTimer::get("XIOS recv field").suspend();
1053	CTimer::get("XIOS").suspend();
1054	}
1055	} // extern "C"

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

Download in other formats: