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

Last change on this file since 1642 was 1642, checked in by yushan, 5 years ago

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