source: XIOS2/trunk/src/interface/c/icdata.cpp @ 2428

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

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