source: XIOS3/branches/xios-3.0-beta/src/interface/c/icdata.cpp @ 2427

Last change on this file since 2427 was 2427, checked in by jderouillat, 17 months ago

Backport the system to log the memory consumption (commit ID [2418-2420,2425-2426])
  • 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.