source: XIOS/trunk/src/interface/c/icdata.cpp @ 2025

Last change on this file since 2025 was 2025, checked in by ymipsl, 9 months ago

New feature : introduce handle acces to xios_send_field and xios_recv_field. Only access by id was possible before.
YM

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