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

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

branch_openmp merged with XIOS_DEV_CMIP6@1459

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