Context Navigation

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

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

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

Download in other formats: