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

Last change on this file since 2243 was 2243, checked in by jderouillat, 3 years ago

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