source: XIOS/dev/branch_openmp/src/interface/c/icdata.cpp @ 1369

Last change on this file since 1369 was 1369, checked in by yushan, 3 years ago

unify type : MPI_Fint

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