source: XIOS/dev/dev_ym/XIOS_COUPLING/src/interface/c/icdata.cpp @ 2121

Last change on this file since 2121 was 2121, checked in by ymipsl, 3 years ago

Merge fortran interface functionnalities from trunk :

  • sendField & recvField with field handle
  • getCurrentContext

YM
  • 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: 47.8 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      MPI_Comm local_comm;
63      MPI_Comm return_comm;
64
65      if (!cstr2string(client_id, len_client_id, str)) return;
66
67      CTimer::get("XIOS").resume();
68      CTimer::get("XIOS init").resume();
69      int initialized;
70      MPI_Initialized(&initialized);
71      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
72      else local_comm=MPI_COMM_NULL;
73      CXios::initClientSide(str, local_comm, return_comm);
74      *f_return_comm=MPI_Comm_c2f(return_comm);
75      CTimer::get("XIOS init").suspend();
76      CTimer::get("XIOS").suspend();
77   }
78   CATCH_DUMP_STACK
79
80   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
81   TRY
82   {
83     std::string str;
84     MPI_Comm comm;
85
86     if (!cstr2string(context_id, len_context_id, str)) return;
87     CTimer::get("XIOS").resume();
88     CTimer::get("XIOS init context").resume();
89     comm=MPI_Comm_f2c(*f_comm);
90     CClient::registerContext(str, comm);
91     CTimer::get("XIOS init context").suspend();
92     CTimer::get("XIOS").suspend();
93   }
94   CATCH_DUMP_STACK
95
96   void cxios_oasis_enddef()
97   TRY
98   {
99     CTimer::get("XIOS").resume();
100     CClient::callOasisEnddef();
101     CTimer::get("XIOS").suspend();
102   }
103   CATCH_DUMP_STACK
104
105   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
106   TRY
107   {
108     std::string str;
109
110     if (!cstr2string(context_id, len_context_id, str)) return;
111     CTimer::get("XIOS").resume();
112     CContext* context = CContext::get(str, str);
113     *initialized=context->isInitialized();
114     CTimer::get("XIOS").suspend();
115   }
116   CATCH_DUMP_STACK
117
118   void cxios_context_close_definition()
119   TRY
120   {
121     CTimer::get("XIOS").resume();
122     CTimer::get("XIOS close definition").resume();
123     CContext* context = CContext::getCurrent();
124     context->closeDefinition();
125     CTimer::get("XIOS close definition").suspend();
126     CTimer::get("XIOS").suspend();
127   }
128   CATCH_DUMP_STACK
129
130   void cxios_context_finalize()
131   TRY
132   {
133     CTimer::get("XIOS").resume();
134     CTimer::get("XIOS context finalize").resume();
135     CContext* context = CContext::getCurrent();
136     context->finalize();
137     CTimer::get("XIOS context finalize").suspend();
138     CTimer::get("XIOS").suspend();
139   }
140   CATCH_DUMP_STACK
141
142   void cxios_finalize()
143   TRY
144   {
145     CTimer::get("XIOS").resume();
146     CTimer::get("XIOS finalize").resume();
147     CXios::clientFinalize();
148   }
149   CATCH_DUMP_STACK
150
151   void cxios_solve_inheritance()
152   TRY
153   {
154     CTimer::get("XIOS").resume();
155     CContext* context = CContext::getCurrent();
156     context->solveAllInheritance(false);
157     CTimer::get("XIOS").suspend();
158   }
159   CATCH_DUMP_STACK
160
161   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
162    *
163    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
164    * from a Fortran one, for example the value of a variable with id = "using_server".
165    * Each function corresponds to each basic type.
166    * \param varId        [in] id of the variable that we'd like to get
167    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
168    * \param dataInt      [in/out] the retrieved data
169    * \param isVarExisted [in/out] Verify whether variable with varId exists
170   */
171   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
172   TRY
173   {
174      std::string varIdStr;
175      if (!cstr2string(varId, varIdSize, varIdStr)) return;
176
177      CTimer::get("XIOS").resume();
178      CTimer::get("XIOS get variable data").resume();
179
180      CContext* context = CContext::getCurrent();
181      *isVarExisted = CVariable::has(context->getId(), varIdStr);
182
183      if (*isVarExisted)
184      {
185        *data = CVariable::get(context->getId(), varIdStr)->getData<double>();
186      }
187
188      CTimer::get("XIOS get variable data").suspend();
189      CTimer::get("XIOS").suspend();
190   }
191   CATCH_DUMP_STACK
192
193   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
194   TRY
195   {
196      std::string varIdStr;
197      if (!cstr2string(varId, varIdSize, varIdStr)) return;
198
199      CTimer::get("XIOS").resume();
200      CTimer::get("XIOS get variable data").resume();
201
202      CContext* context = CContext::getCurrent();
203      *isVarExisted = CVariable::has(context->getId(), varIdStr);
204
205      if (*isVarExisted)
206      {
207        *data = CVariable::get(context->getId(), varIdStr)->getData<float>();
208      }
209
210      CTimer::get("XIOS get variable data").suspend();
211      CTimer::get("XIOS").suspend();
212   }
213   CATCH_DUMP_STACK
214
215   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
216   TRY
217   {
218      std::string varIdStr;
219      if (!cstr2string(varId, varIdSize, varIdStr)) return;
220
221      CTimer::get("XIOS").resume();
222      CTimer::get("XIOS get variable data").resume();
223
224      CContext* context = CContext::getCurrent();
225      *isVarExisted = CVariable::has(context->getId(), varIdStr);
226
227      if (*isVarExisted)
228      {
229        *data = CVariable::get(context->getId(), varIdStr)->getData<int>();
230      }
231
232      CTimer::get("XIOS get variable data").suspend();
233      CTimer::get("XIOS").suspend();
234   }
235   CATCH_DUMP_STACK
236
237   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
238   TRY
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        *data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
252      }
253
254      CTimer::get("XIOS get variable data").suspend();
255      CTimer::get("XIOS").suspend();
256   }
257   CATCH_DUMP_STACK
258
259   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
260   TRY
261   {
262      std::string varIdStr;
263      if (!cstr2string(varId, varIdSize, varIdStr)) return;
264
265      CTimer::get("XIOS").resume();
266      CTimer::get("XIOS get variable data").resume();
267
268      CContext* context = CContext::getCurrent();
269      *isVarExisted = CVariable::has(context->getId(), varIdStr);
270
271      if (*isVarExisted)
272      {
273        int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
274        strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
275      }
276
277      CTimer::get("XIOS get variable data").suspend();
278      CTimer::get("XIOS").suspend();
279   }
280   CATCH_DUMP_STACK
281
282   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
283    *
284    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
285    * from a Fortran one, for example the value of a variable with id = "using_server".
286    * Each function corresponds to each basic type.
287    * \param varId        [in] id of the variable that we'd like to get
288    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
289    * \param data         [in] the input data
290    * \param isVarExisted [in/out] Verify whether variable with varId exists
291   */
292   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted)
293   TRY
294  {
295      std::string varIdStr;
296      if (!cstr2string(varId, varIdSize, varIdStr)) return;
297
298      CTimer::get("XIOS").resume();
299      CTimer::get("XIOS set variable data").resume();
300
301      CContext* context = CContext::getCurrent();
302      *isVarExisted = CVariable::has(context->getId(), varIdStr);
303
304      if (*isVarExisted)
305      {
306        CVariable::get(context->getId(), varIdStr)->setData<double>(data);
307        //CVariable::get(context->getId(), varIdStr)->sendValue();
308      }
309
310      CTimer::get("XIOS set variable data").suspend();
311      CTimer::get("XIOS").suspend();
312   }
313   CATCH_DUMP_STACK
314
315   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted)
316   TRY
317   {
318      std::string varIdStr;
319      if (!cstr2string(varId, varIdSize, varIdStr)) return;
320
321      CTimer::get("XIOS").resume();
322      CTimer::get("XIOS set variable data").resume();
323
324      CContext* context = CContext::getCurrent();
325      *isVarExisted = CVariable::has(context->getId(), varIdStr);
326
327      if (*isVarExisted)
328      {
329        CVariable::get(context->getId(), varIdStr)->setData<float>(data);
330        //CVariable::get(context->getId(), varIdStr)->sendValue();
331      }
332
333      CTimer::get("XIOS set variable data").suspend();
334      CTimer::get("XIOS").suspend();
335   }
336   CATCH_DUMP_STACK
337
338   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
339   TRY
340   {
341      std::string varIdStr;
342      if (!cstr2string(varId, varIdSize, varIdStr)) return;
343
344      CTimer::get("XIOS").resume();
345      CTimer::get("XIOS set variable data").resume();
346
347      CContext* context = CContext::getCurrent();
348      *isVarExisted = CVariable::has(context->getId(), varIdStr);
349
350      if (*isVarExisted)
351      {
352        CVariable::get(context->getId(), varIdStr)->setData<int>(data);
353        //CVariable::get(context->getId(), varIdStr)->sendValue();
354      }
355
356
357      CTimer::get("XIOS set variable data").suspend();
358      CTimer::get("XIOS").suspend();
359   }
360   CATCH_DUMP_STACK
361
362   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
363   TRY
364   {
365      std::string varIdStr;
366      if (!cstr2string(varId, varIdSize, varIdStr)) return;
367
368      CTimer::get("XIOS").resume();
369      CTimer::get("XIOS set variable data").resume();
370
371      CContext* context = CContext::getCurrent();
372      *isVarExisted = CVariable::has(context->getId(), varIdStr);
373
374      if (*isVarExisted)
375      {
376        CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
377        //CVariable::get(context->getId(), varIdStr)->sendValue();
378      }
379
380      CTimer::get("XIOS set variable data").suspend();
381      CTimer::get("XIOS").suspend();
382   }
383   CATCH_DUMP_STACK
384
385   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
386   TRY
387  {
388      std::string varIdStr, dataStr;
389      if (!cstr2string(varId, varIdSize, varIdStr)) return;
390      if (!cstr2string(data, dataSizeIn, dataStr))
391      {
392        *isVarExisted = false;
393        return;
394      }
395
396      CTimer::get("XIOS").resume();
397      CTimer::get("XIOS set variable data").resume();
398
399      CContext* context = CContext::getCurrent();
400      *isVarExisted = CVariable::has(context->getId(), varIdStr);
401
402      if (*isVarExisted)
403      {
404        CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
405        //CVariable::get(context->getId(), varIdStr)->sendValue();
406      }
407
408      CTimer::get("XIOS set variable data").suspend();
409      CTimer::get("XIOS").suspend();
410   }
411   CATCH_DUMP_STACK
412
413   // ---------------------- Ecriture des données ------------------------------
414   
415   void cxios_write_data_k80_hdl(CField* field, double* data_k8, int data_Xsize)
416   TRY
417   {
418      CTimer::get("XIOS").resume();
419      CTimer::get("XIOS send field").resume();
420      CContext* context = CContext::getCurrent();
421      if (!context->hasServer && !context->client->isAttachedModeEnabled())
422        context->eventLoop();
423      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
424      field->setData(data);
425      CTimer::get("XIOS send field").suspend();
426      CTimer::get("XIOS").suspend();
427   }
428   CATCH_DUMP_STACK
429
430   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
431   TRY
432   {
433      std::string fieldid_str;
434      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
435      cxios_write_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ;
436   }
437   CATCH_DUMP_STACK
438
439
440
441 
442   void cxios_write_data_k81_hdl(CField* field, double* data_k8, int data_Xsize)
443   TRY
444   {
445      CTimer::get("XIOS").resume();
446      CTimer::get("XIOS send field").resume();
447
448      CContext* context = CContext::getCurrent();
449      if (!context->hasServer && !context->client->isAttachedModeEnabled())
450        context->eventLoop();
451
452      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
453      field->setData(data);
454
455      CTimer::get("XIOS send field").suspend();
456      CTimer::get("XIOS").suspend();
457   }
458   CATCH_DUMP_STACK
459   
460   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
461   TRY
462   {
463      std::string fieldid_str;
464      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
465      cxios_write_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ;
466   
467   }
468   CATCH_DUMP_STACK
469
470
471
472   void cxios_write_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize)
473   TRY
474   {
475      CTimer::get("XIOS").resume();
476      CTimer::get("XIOS send field").resume();
477
478      CContext* context = CContext::getCurrent();
479      if (!context->hasServer && !context->client->isAttachedModeEnabled())
480        context->eventLoop();
481
482      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
483      field->setData(data);
484
485      CTimer::get("XIOS send field").suspend();
486      CTimer::get("XIOS").suspend();
487   }
488   CATCH_DUMP_STACK
489
490   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
491   TRY
492   {
493      std::string fieldid_str;
494      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
495      cxios_write_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ;
496   }
497   CATCH_DUMP_STACK
498
499
500
501
502
503
504   void cxios_write_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
505   TRY
506   {
507      CTimer::get("XIOS").resume();
508      CTimer::get("XIOS send field").resume();
509
510      CContext* context = CContext::getCurrent();
511      if (!context->hasServer && !context->client->isAttachedModeEnabled())
512        context->eventLoop();
513
514      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
515      field->setData(data);
516
517      CTimer::get("XIOS send field").suspend();
518      CTimer::get("XIOS").suspend();
519   }
520   CATCH_DUMP_STACK
521   
522   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
523   TRY
524   {
525      std::string fieldid_str;
526      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
527      cxios_write_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ;
528
529
530   }
531   CATCH_DUMP_STACK
532
533
534
535
536
537
538   void cxios_write_data_k84_hdl(CField* field, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size)
539   TRY
540   {
541      CTimer::get("XIOS").resume();
542      CTimer::get("XIOS send field").resume();
543
544      CContext* context = CContext::getCurrent();
545      if (!context->hasServer && !context->client->isAttachedModeEnabled())
546        context->eventLoop();
547
548      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
549      field->setData(data);
550
551      CTimer::get("XIOS send field").suspend();
552      CTimer::get("XIOS").suspend();
553   }
554   CATCH_DUMP_STACK
555
556   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)
557   TRY
558   {
559      std::string fieldid_str;
560      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
561
562      CTimer::get("XIOS").resume();
563      CTimer::get("XIOS send field").resume();
564      cxios_write_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ;
565   }
566   CATCH_DUMP_STACK
567
568
569
570   
571
572   void cxios_write_data_k85_hdl(CField* field, double* data_k8,
573                             int data_0size, int data_1size, int data_2size,
574                             int data_3size, int data_4size)
575   TRY
576   {
577      CTimer::get("XIOS").resume();
578      CTimer::get("XIOS send field").resume();
579
580      CContext* context = CContext::getCurrent();
581      if (!context->hasServer && !context->client->isAttachedModeEnabled())
582        context->eventLoop();
583
584      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
585      field->setData(data);
586
587      CTimer::get("XIOS send field").suspend();
588      CTimer::get("XIOS").suspend();
589   }
590   CATCH_DUMP_STACK
591
592   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
593                             int data_0size, int data_1size, int data_2size,
594                             int data_3size, int data_4size)
595   TRY
596   {
597      std::string fieldid_str;
598      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
599      cxios_write_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ;
600
601   }
602   CATCH_DUMP_STACK
603
604
605
606   void cxios_write_data_k86_hdl(CField* field, double* data_k8,
607                             int data_0size, int data_1size, int data_2size,
608                             int data_3size, int data_4size, int data_5size)
609   TRY
610   {
611 
612      CTimer::get("XIOS").resume();
613      CTimer::get("XIOS send field").resume();
614
615      CContext* context = CContext::getCurrent();
616      if (!context->hasServer && !context->client->isAttachedModeEnabled())
617        context->eventLoop();
618
619      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
620      field->setData(data);
621
622      CTimer::get("XIOS send field").suspend();
623      CTimer::get("XIOS").suspend();
624   }
625   CATCH_DUMP_STACK
626   
627   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
628                             int data_0size, int data_1size, int data_2size,
629                             int data_3size, int data_4size, int data_5size)
630   TRY
631   {
632      std::string fieldid_str;
633      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
634      cxios_write_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
635
636  }
637   CATCH_DUMP_STACK
638   
639
640
641
642   void cxios_write_data_k87_hdl(CField* field, double* data_k8,
643                             int data_0size, int data_1size, int data_2size,
644                             int data_3size, int data_4size, int data_5size,
645                             int data_6size)
646   TRY
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->eventLoop();
654
655      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
656      field->setData(data);
657
658      CTimer::get("XIOS send field").suspend();
659      CTimer::get("XIOS").suspend();
660   }
661   CATCH_DUMP_STACK
662   
663   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
664                             int data_0size, int data_1size, int data_2size,
665                             int data_3size, int data_4size, int data_5size,
666                             int data_6size)
667   TRY
668   {
669      std::string fieldid_str;
670      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
671      cxios_write_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
672   }
673   CATCH_DUMP_STACK
674   
675
676
677
678
679   void cxios_write_data_k40_hdl(CField* field, float* data_k4, int data_Xsize)
680   TRY
681   {
682      CTimer::get("XIOS").resume();
683      CTimer::get("XIOS send field").resume();
684      CContext* context = CContext::getCurrent();
685      if (!context->hasServer && !context->client->isAttachedModeEnabled())
686        context->eventLoop();
687
688      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
689      CArray<double, 1> data(data_Xsize) ;
690      data = data_tmp;
691      field->setData(data);
692      CTimer::get("XIOS send field").suspend();
693      CTimer::get("XIOS").suspend();
694   }
695   CATCH_DUMP_STACK
696
697   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
698   TRY
699   {
700      std::string fieldid_str;
701      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
702      cxios_write_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize);
703
704   }
705   CATCH_DUMP_STACK
706   
707   
708   void cxios_write_data_k41_hdl(CField* field, float* data_k4, int data_Xsize)
709   TRY
710   {
711      CTimer::get("XIOS").resume();
712      CTimer::get("XIOS send field").resume();
713
714      CContext* context = CContext::getCurrent();
715      if (!context->hasServer && !context->client->isAttachedModeEnabled())
716        context->eventLoop();
717
718      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
719      CArray<double, 1> data(data_Xsize);
720      data = data_tmp;
721      field->setData(data);
722
723      CTimer::get("XIOS send field").suspend();
724      CTimer::get("XIOS").suspend();
725   }
726   CATCH_DUMP_STACK
727
728   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
729   TRY
730   {
731      std::string fieldid_str;
732      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
733      cxios_write_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize);
734   }
735   CATCH_DUMP_STACK
736
737
738   void cxios_write_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize)
739   TRY
740   {
741      CTimer::get("XIOS").resume();
742      CTimer::get("XIOS send field").resume();
743
744      CContext* context = CContext::getCurrent();
745      if (!context->hasServer && !context->client->isAttachedModeEnabled())
746        context->eventLoop();
747
748      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
749      CArray<double, 2> data(data_Xsize, data_Ysize);
750      data = data_tmp;
751      field->setData(data);
752
753      CTimer::get("XIOS send field").suspend();
754      CTimer::get("XIOS").suspend();
755   }
756   CATCH_DUMP_STACK
757
758   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
759   TRY
760   {
761      std::string fieldid_str;
762      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
763      cxios_write_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize);
764   }
765   CATCH_DUMP_STACK
766
767
768
769
770   void cxios_write_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
771   TRY
772   {
773      CTimer::get("XIOS").resume();
774      CTimer::get("XIOS send field").resume();
775
776      CContext* context = CContext::getCurrent();
777      if (!context->hasServer && !context->client->isAttachedModeEnabled())
778        context->eventLoop();
779
780      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
781      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
782      data = data_tmp;
783      field->setData(data);
784
785      CTimer::get("XIOS send field").suspend();
786      CTimer::get("XIOS").suspend();
787    }
788   CATCH_DUMP_STACK
789   
790   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
791   TRY
792   {
793      std::string fieldid_str;
794      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
795      cxios_write_data_k43_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, data_Zsize);
796    }
797   CATCH_DUMP_STACK
798   
799
800   
801   void cxios_write_data_k44_hdl(CField* field, float* data_k4,
802                             int data_0size, int data_1size, int data_2size,
803                             int data_3size)
804   TRY
805   {
806      CTimer::get("XIOS").resume();
807      CTimer::get("XIOS send field").resume();
808
809      CContext* context = CContext::getCurrent();
810      if (!context->hasServer && !context->client->isAttachedModeEnabled())
811        context->eventLoop();
812
813      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
814      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
815      data = data_tmp;
816      field->setData(data);
817
818      CTimer::get("XIOS send field").suspend();
819      CTimer::get("XIOS").suspend();
820    }
821   CATCH_DUMP_STACK
822
823   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
824                             int data_0size, int data_1size, int data_2size,
825                             int data_3size)
826   TRY
827   {
828      std::string fieldid_str;
829      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
830      cxios_write_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ;
831    }
832   CATCH_DUMP_STACK
833
834
835
836
837   void cxios_write_data_k45_hdl(CField* field, float* data_k4,
838                             int data_0size, int data_1size, int data_2size,
839                             int data_3size, int data_4size)
840   TRY
841   {
842      CTimer::get("XIOS").resume();
843      CTimer::get("XIOS send field").resume();
844
845      CContext* context = CContext::getCurrent();
846      if (!context->hasServer && !context->client->isAttachedModeEnabled())
847        context->eventLoop();
848
849      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
850      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
851      data = data_tmp;
852      field->setData(data);
853
854      CTimer::get("XIOS send field").suspend();
855      CTimer::get("XIOS").suspend();
856    }
857   CATCH_DUMP_STACK
858
859   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
860                             int data_0size, int data_1size, int data_2size,
861                             int data_3size, int data_4size)
862   TRY
863   {
864      std::string fieldid_str;
865      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
866      cxios_write_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ;
867    }
868   CATCH_DUMP_STACK
869
870
871
872   void cxios_write_data_k46_hdl(CField* field, float* data_k4,
873                             int data_0size, int data_1size, int data_2size,
874                             int data_3size, int data_4size, int data_5size)
875   TRY
876   {
877      CTimer::get("XIOS").resume();
878      CTimer::get("XIOS send field").resume();
879
880      CContext* context = CContext::getCurrent();
881      if (!context->hasServer && !context->client->isAttachedModeEnabled())
882        context->eventLoop();
883
884      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
885      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
886      data = data_tmp;
887      field->setData(data);
888
889      CTimer::get("XIOS send field").suspend();
890      CTimer::get("XIOS").suspend();
891    }
892   CATCH_DUMP_STACK
893
894   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
895                             int data_0size, int data_1size, int data_2size,
896                             int data_3size, int data_4size, int data_5size)
897   TRY
898   {
899      std::string fieldid_str;
900      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
901      cxios_write_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
902    }
903   CATCH_DUMP_STACK
904
905
906   void cxios_write_data_k47_hdl(CField* field, float* data_k4,
907                             int data_0size, int data_1size, int data_2size,
908                             int data_3size, int data_4size, int data_5size,
909                             int data_6size)
910   TRY
911   {
912      CTimer::get("XIOS").resume();
913      CTimer::get("XIOS send field").resume();
914
915      CContext* context = CContext::getCurrent();
916      if (!context->hasServer && !context->client->isAttachedModeEnabled())
917        context->eventLoop();
918
919      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
920      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
921      data = data_tmp;
922      field->setData(data);
923
924      CTimer::get("XIOS send field").suspend();
925      CTimer::get("XIOS").suspend();
926    }
927   CATCH_DUMP_STACK
928
929  void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
930                             int data_0size, int data_1size, int data_2size,
931                             int data_3size, int data_4size, int data_5size,
932                             int data_6size)
933   TRY
934   {
935      std::string fieldid_str;
936      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
937      cxios_write_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
938    }
939   CATCH_DUMP_STACK
940
941
942   // ---------------------- Lecture des données ------------------------------
943
944   void cxios_read_data_k80_hdl(CField* field, double* data_k8, int data_Xsize)
945   TRY
946   {
947      CTimer::get("XIOS").resume();
948      CTimer::get("XIOS recv field").resume();
949
950      CContext* context = CContext::getCurrent();
951      if (!context->hasServer && !context->client->isAttachedModeEnabled())
952        context->eventLoop();
953
954      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
955      field->getData(data);
956
957      CTimer::get("XIOS recv field").suspend();
958      CTimer::get("XIOS").suspend();
959   }
960   CATCH_DUMP_STACK
961
962   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
963   TRY
964   {
965      std::string fieldid_str;
966      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
967      cxios_read_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ;
968   }
969   CATCH_DUMP_STACK
970   
971   
972   void cxios_read_data_k81_hdl(CField* field, double* data_k8, int data_Xsize)
973   TRY
974   {
975      CTimer::get("XIOS").resume();
976      CTimer::get("XIOS recv field").resume();
977
978      CContext* context = CContext::getCurrent();
979      if (!context->hasServer && !context->client->isAttachedModeEnabled())
980        context->eventLoop();
981
982      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
983      field->getData(data);
984
985      CTimer::get("XIOS recv field").suspend();
986      CTimer::get("XIOS").suspend();
987   }
988   CATCH_DUMP_STACK
989
990   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
991   TRY
992   {
993      std::string fieldid_str;
994      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
995      cxios_read_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ;
996   }
997   CATCH_DUMP_STACK
998
999   void cxios_read_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize)
1000   TRY
1001   {
1002      CTimer::get("XIOS").resume();
1003      CTimer::get("XIOS recv field").resume();
1004
1005      CContext* context = CContext::getCurrent();
1006      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1007        context->eventLoop();
1008
1009      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
1010      field->getData(data);
1011
1012      CTimer::get("XIOS recv field").suspend();
1013      CTimer::get("XIOS").suspend();
1014   }
1015   CATCH_DUMP_STACK
1016
1017   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
1018   TRY
1019   {
1020      std::string fieldid_str;
1021      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1022      cxios_read_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ;
1023   }
1024   CATCH_DUMP_STACK
1025
1026
1027   void cxios_read_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
1028   TRY
1029   {
1030      CTimer::get("XIOS").resume();
1031      CTimer::get("XIOS recv field").resume();
1032
1033      CContext* context = CContext::getCurrent();
1034      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1035        context->eventLoop();
1036
1037      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
1038      field->getData(data);
1039
1040      CTimer::get("XIOS recv field").suspend();
1041      CTimer::get("XIOS").suspend();
1042   }
1043   CATCH_DUMP_STACK
1044
1045
1046   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
1047   TRY
1048   {
1049      std::string fieldid_str;
1050      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1051      cxios_read_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ;
1052   }
1053   CATCH_DUMP_STACK
1054
1055   void cxios_read_data_k84_hdl(CField* field, double* data_k8,
1056                            int data_0size, int data_1size, int data_2size,
1057                            int data_3size)
1058   TRY
1059   {
1060      CTimer::get("XIOS").resume();
1061      CTimer::get("XIOS recv field").resume();
1062
1063      CContext* context = CContext::getCurrent();
1064      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1065        context->eventLoop();
1066
1067      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
1068      field->getData(data);
1069
1070      CTimer::get("XIOS recv field").suspend();
1071      CTimer::get("XIOS").suspend();
1072   }
1073   CATCH_DUMP_STACK
1074
1075   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
1076                            int data_0size, int data_1size, int data_2size,
1077                            int data_3size)
1078   TRY
1079   {
1080      std::string fieldid_str;
1081      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1082      cxios_read_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ;
1083   }
1084   CATCH_DUMP_STACK
1085
1086   void cxios_read_data_k85_hdl(CField* field, double* data_k8,
1087                            int data_0size, int data_1size, int data_2size,
1088                            int data_3size, int data_4size)
1089   TRY
1090   {
1091      CTimer::get("XIOS").resume();
1092      CTimer::get("XIOS recv field").resume();
1093
1094      CContext* context = CContext::getCurrent();
1095      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1096        context->eventLoop();
1097
1098      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1099      field->getData(data);
1100
1101      CTimer::get("XIOS recv field").suspend();
1102      CTimer::get("XIOS").suspend();
1103   }
1104   CATCH_DUMP_STACK
1105
1106   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
1107                            int data_0size, int data_1size, int data_2size,
1108                            int data_3size, int data_4size)
1109   TRY
1110   {
1111      std::string fieldid_str;
1112      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1113      cxios_read_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ;
1114   }
1115   CATCH_DUMP_STACK
1116
1117   void cxios_read_data_k86_hdl(CField* field, double* data_k8,
1118                            int data_0size, int data_1size, int data_2size,
1119                            int data_3size, int data_4size, int data_5size)
1120   TRY
1121   {
1122      CTimer::get("XIOS").resume();
1123      CTimer::get("XIOS recv field").resume();
1124
1125      CContext* context = CContext::getCurrent();
1126      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1127        context->eventLoop();
1128
1129      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1130      field->getData(data);
1131
1132      CTimer::get("XIOS recv field").suspend();
1133      CTimer::get("XIOS").suspend();
1134   }
1135   CATCH_DUMP_STACK
1136
1137   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
1138                            int data_0size, int data_1size, int data_2size,
1139                            int data_3size, int data_4size, int data_5size)
1140   TRY
1141   {
1142      std::string fieldid_str;
1143      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1144      cxios_read_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
1145   }
1146   CATCH_DUMP_STACK
1147
1148   void cxios_read_data_k87_hdl(CField* field, double* data_k8,
1149                            int data_0size, int data_1size, int data_2size,
1150                            int data_3size, int data_4size, int data_5size,
1151                            int data_6size)
1152   TRY
1153   {
1154      CTimer::get("XIOS").resume();
1155      CTimer::get("XIOS recv field").resume();
1156
1157      CContext* context = CContext::getCurrent();
1158      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1159        context->eventLoop();
1160
1161      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1162      field->getData(data);
1163
1164      CTimer::get("XIOS recv field").suspend();
1165      CTimer::get("XIOS").suspend();
1166   }
1167   CATCH_DUMP_STACK
1168
1169   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
1170                            int data_0size, int data_1size, int data_2size,
1171                            int data_3size, int data_4size, int data_5size,
1172                            int data_6size)
1173   TRY
1174   {
1175      std::string fieldid_str;
1176      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1177      cxios_read_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
1178   }
1179   CATCH_DUMP_STACK
1180
1181
1182
1183
1184
1185
1186   void cxios_read_data_k40_hdl(CField* field, float* data_k4, int data_Xsize)
1187   TRY
1188   {
1189      CTimer::get("XIOS").resume();
1190      CTimer::get("XIOS recv field").resume();
1191
1192      CContext* context = CContext::getCurrent();
1193      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1194        context->eventLoop();
1195
1196      CArray<double, 1> data(data_Xsize);
1197      field->getData(data);
1198      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
1199      data_tmp = data;
1200
1201      CTimer::get("XIOS recv field").suspend();
1202      CTimer::get("XIOS").suspend();
1203   }
1204   CATCH_DUMP_STACK
1205
1206   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
1207   TRY
1208   {
1209      std::string fieldid_str;
1210      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1211      cxios_read_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ;
1212   }
1213   CATCH_DUMP_STACK
1214
1215
1216
1217   void cxios_read_data_k41_hdl(CField* field, float* data_k4, int data_Xsize)
1218   TRY
1219   {
1220      CTimer::get("XIOS").resume();
1221      CTimer::get("XIOS recv field").resume();
1222
1223      CContext* context = CContext::getCurrent();
1224      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1225        context->eventLoop();
1226
1227      CArray<double, 1> data(data_Xsize);
1228      field->getData(data);
1229      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
1230      data_tmp = data;
1231
1232      CTimer::get("XIOS recv field").suspend();
1233      CTimer::get("XIOS").suspend();
1234   }
1235   CATCH_DUMP_STACK
1236
1237   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
1238   TRY
1239   {
1240      std::string fieldid_str;
1241      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1242      cxios_read_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ;
1243   }
1244   CATCH_DUMP_STACK
1245
1246
1247
1248
1249   void cxios_read_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize)
1250   TRY
1251   {
1252      CTimer::get("XIOS").resume();
1253      CTimer::get("XIOS recv field").resume();
1254
1255      CContext* context = CContext::getCurrent();
1256      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1257        context->eventLoop();
1258
1259      CArray<double, 2> data(data_Xsize, data_Ysize);
1260      field->getData(data);
1261      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
1262      data_tmp = data;
1263
1264      CTimer::get("XIOS recv field").suspend();
1265      CTimer::get("XIOS").suspend();
1266   }
1267   CATCH_DUMP_STACK
1268
1269   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
1270   TRY
1271   {
1272      std::string fieldid_str;
1273      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1274      cxios_read_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize, data_Ysize) ;
1275   }
1276   CATCH_DUMP_STACK
1277
1278
1279
1280   void cxios_read_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
1281   TRY
1282   {
1283      CTimer::get("XIOS").resume();
1284      CTimer::get("XIOS recv field").resume();
1285
1286      CContext* context = CContext::getCurrent();
1287      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1288        context->eventLoop();
1289
1290      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
1291      field->getData(data);
1292      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
1293      data_tmp = data;
1294
1295      CTimer::get("XIOS recv field").suspend();
1296      CTimer::get("XIOS").suspend();
1297    }
1298   CATCH_DUMP_STACK
1299
1300   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
1301   TRY
1302   {
1303      std::string fieldid_str;
1304      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1305      cxios_read_data_k43_hdl(CField::get(fieldid_str), data_k4,data_Xsize, data_Ysize, data_Zsize) ;
1306    }
1307   CATCH_DUMP_STACK
1308
1309
1310   void cxios_read_data_k44_hdl(CField* field, float* data_k4,
1311                            int data_0size, int data_1size, int data_2size,
1312                            int data_3size)
1313   TRY
1314   {
1315      CTimer::get("XIOS").resume();
1316      CTimer::get("XIOS recv field").resume();
1317
1318      CContext* context = CContext::getCurrent();
1319      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1320        context->eventLoop();
1321
1322      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
1323      field->getData(data);
1324      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
1325      data_tmp = data;
1326
1327      CTimer::get("XIOS recv field").suspend();
1328      CTimer::get("XIOS").suspend();
1329    }
1330   CATCH_DUMP_STACK
1331
1332   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
1333                            int data_0size, int data_1size, int data_2size,
1334                            int data_3size)
1335   TRY
1336   {
1337      std::string fieldid_str;
1338      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1339      cxios_read_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ;
1340    }
1341   CATCH_DUMP_STACK
1342
1343
1344
1345   void cxios_read_data_k45_hdl(CField* field, float* data_k4,
1346                            int data_0size, int data_1size, int data_2size,
1347                            int data_3size, int data_4size)
1348   TRY
1349   {
1350      CTimer::get("XIOS").resume();
1351      CTimer::get("XIOS recv field").resume();
1352
1353      CContext* context = CContext::getCurrent();
1354      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1355        context->eventLoop();
1356
1357      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1358      field->getData(data);
1359      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1360      data_tmp = data;
1361
1362      CTimer::get("XIOS recv field").suspend();
1363      CTimer::get("XIOS").suspend();
1364    }
1365   CATCH_DUMP_STACK
1366
1367   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
1368                            int data_0size, int data_1size, int data_2size,
1369                            int data_3size, int data_4size)
1370   TRY
1371   {
1372      std::string fieldid_str;
1373      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1374      cxios_read_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ;
1375    }
1376   CATCH_DUMP_STACK
1377
1378
1379   void cxios_read_data_k46_hdl(CField* field, float* data_k4,
1380                            int data_0size, int data_1size, int data_2size,
1381                            int data_3size, int data_4size, int data_5size)
1382   TRY
1383   {
1384      CTimer::get("XIOS").resume();
1385      CTimer::get("XIOS recv field").resume();
1386
1387      CContext* context = CContext::getCurrent();
1388      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1389        context->eventLoop();
1390
1391      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1392      field->getData(data);
1393      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1394      data_tmp = data;
1395
1396      CTimer::get("XIOS recv field").suspend();
1397      CTimer::get("XIOS").suspend();
1398    }
1399   CATCH_DUMP_STACK
1400
1401   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
1402                            int data_0size, int data_1size, int data_2size,
1403                            int data_3size, int data_4size, int data_5size)
1404   TRY
1405   {
1406      std::string fieldid_str;
1407      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1408      cxios_read_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
1409    }
1410   CATCH_DUMP_STACK
1411
1412
1413
1414   void cxios_read_data_k47_hdl(CField* field, float* data_k4,
1415                            int data_0size, int data_1size, int data_2size,
1416                            int data_3size, int data_4size, int data_5size,
1417                            int data_6size)
1418   TRY
1419   {
1420      CTimer::get("XIOS").resume();
1421      CTimer::get("XIOS recv field").resume();
1422
1423      CContext* context = CContext::getCurrent();
1424      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1425        context->eventLoop();
1426
1427      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1428      field->getData(data);
1429      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1430      data_tmp = data;
1431
1432      CTimer::get("XIOS recv field").suspend();
1433      CTimer::get("XIOS").suspend();
1434    }
1435   CATCH_DUMP_STACK
1436 
1437   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1438                            int data_0size, int data_1size, int data_2size,
1439                            int data_3size, int data_4size, int data_5size,
1440                            int data_6size)
1441   TRY
1442   {
1443      std::string fieldid_str;
1444      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1445      cxios_read_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
1446    }
1447   CATCH_DUMP_STACK
1448} // extern "C"
Note: See TracBrowser for help on using the repository browser.