source: XIOS3/trunk/src/interface/c/icdata.cpp @ 2426

Last change on this file since 2426 was 2426, checked in by jderouillat, 16 months ago

Clean MemCheckcer?, add memory consumption accumulators in main XIOS interfaces for clients, and in the NetCDF interface for servers.

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