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

Last change on this file since 2471 was 2471, checked in by jderouillat, 14 months ago

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