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

Last change on this file since 2265 was 2265, checked in by ymipsl, 6 months ago

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