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

Last change on this file was 2629, checked in by jderouillat, 2 months ago

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