source: XIOS/dev/dev_ym/XIOS_ONE_SIDED/src/interface/c/icdata.cpp @ 1753

Last change on this file since 1753 was 1753, checked in by ymipsl, 5 years ago

more timers

YM
  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
  • Property svn:eol-style set to native
File size: 39.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 "array_new.hpp"
28
29
30extern "C"
31{
32// /////////////////////////////// Définitions ////////////////////////////// //
33
34   // ----------------------- Redéfinition de types ----------------------------
35
36   typedef enum { NETCDF4 = 0 } XFileType;
37
38   typedef xios::CContext* XContextPtr;
39
40   // -------------------- Traitement des données ------------------------------
41
42   // This function is not exported to the public Fortran interface,
43   // it is only used from the parse_xml.exe standalone test tool.
44   void cxios_init(void)
45   TRY
46   {
47     CXios::initialize();
48   }
49   CATCH_DUMP_STACK
50
51   void cxios_init_server(void)
52   TRY
53   {
54     CXios::initServerSide();
55   }
56   CATCH_DUMP_STACK
57
58   void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
59   TRY
60   {
61      std::string str;
62      MPI_Comm local_comm;
63      MPI_Comm return_comm;
64
65      if (!cstr2string(client_id, len_client_id, str)) return;
66
67      CTimer::get("XIOS").resume();
68      CTimer::get("XIOS init").resume();
69      int initialized;
70      MPI_Initialized(&initialized);
71      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
72      else local_comm=MPI_COMM_NULL;
73      CXios::initClientSide(str, local_comm, return_comm);
74      *f_return_comm=MPI_Comm_c2f(return_comm);
75      CTimer::get("XIOS init").suspend();
76      CTimer::get("XIOS").suspend();
77   }
78   CATCH_DUMP_STACK
79
80   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
81   TRY
82   {
83     std::string str;
84     MPI_Comm comm;
85
86     if (!cstr2string(context_id, len_context_id, str)) return;
87     CTimer::get("XIOS").resume();
88     CTimer::get("XIOS init context").resume();
89     comm=MPI_Comm_f2c(*f_comm);
90     CClient::registerContext(str, comm);
91     CTimer::get("XIOS init context").suspend();
92     CTimer::get("XIOS").suspend();
93   }
94   CATCH_DUMP_STACK
95
96   void cxios_oasis_enddef()
97   TRY
98   {
99     CTimer::get("XIOS").resume();
100     CClient::callOasisEnddef();
101     CTimer::get("XIOS").suspend();
102   }
103   CATCH_DUMP_STACK
104
105   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
106   TRY
107   {
108     std::string str;
109
110     if (!cstr2string(context_id, len_context_id, str)) return;
111     CTimer::get("XIOS").resume();
112     CContext* context = CContext::get(str, str);
113     *initialized=context->isInitialized();
114     CTimer::get("XIOS").suspend();
115   }
116   CATCH_DUMP_STACK
117
118   void cxios_context_close_definition()
119   TRY
120   {
121     CTimer::get("XIOS").resume();
122     CTimer::get("XIOS close definition").resume();
123     CContext* context = CContext::getCurrent();
124     context->closeDefinition();
125     CTimer::get("XIOS close definition").suspend();
126     CTimer::get("XIOS").suspend();
127   }
128   CATCH_DUMP_STACK
129
130   void cxios_context_finalize()
131   TRY
132   {
133     CTimer::get("XIOS").resume();
134     CTimer::get("XIOS context finalize").resume();
135     CContext* context = CContext::getCurrent();
136     context->finalize();
137     CTimer::get("XIOS context finalize").suspend();
138     CTimer::get("XIOS").suspend();
139   }
140   CATCH_DUMP_STACK
141
142   void cxios_finalize()
143   TRY
144   {
145     CTimer::get("XIOS").resume();
146     CTimer::get("XIOS finalize").resume();
147     CXios::clientFinalize();
148   }
149   CATCH_DUMP_STACK
150
151   void cxios_solve_inheritance()
152   TRY
153   {
154     CTimer::get("XIOS").resume();
155     CContext* context = CContext::getCurrent();
156     context->solveAllInheritance(false);
157     CTimer::get("XIOS").suspend();
158   }
159   CATCH_DUMP_STACK
160
161   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
162    *
163    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
164    * from a Fortran one, for example the value of a variable with id = "using_server".
165    * Each function corresponds to each basic type.
166    * \param varId        [in] id of the variable that we'd like to get
167    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
168    * \param dataInt      [in/out] the retrieved data
169    * \param isVarExisted [in/out] Verify whether variable with varId exists
170   */
171   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
172   TRY
173   {
174      std::string varIdStr;
175      if (!cstr2string(varId, varIdSize, varIdStr)) return;
176
177      CTimer::get("XIOS").resume();
178      CTimer::get("XIOS get variable data").resume();
179
180      CContext* context = CContext::getCurrent();
181      *isVarExisted = CVariable::has(context->getId(), varIdStr);
182
183      if (*isVarExisted)
184      {
185        *data = CVariable::get(context->getId(), varIdStr)->getData<double>();
186      }
187
188      CTimer::get("XIOS get variable data").suspend();
189      CTimer::get("XIOS").suspend();
190   }
191   CATCH_DUMP_STACK
192
193   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
194   TRY
195   {
196      std::string varIdStr;
197      if (!cstr2string(varId, varIdSize, varIdStr)) return;
198
199      CTimer::get("XIOS").resume();
200      CTimer::get("XIOS get variable data").resume();
201
202      CContext* context = CContext::getCurrent();
203      *isVarExisted = CVariable::has(context->getId(), varIdStr);
204
205      if (*isVarExisted)
206      {
207        *data = CVariable::get(context->getId(), varIdStr)->getData<float>();
208      }
209
210      CTimer::get("XIOS get variable data").suspend();
211      CTimer::get("XIOS").suspend();
212   }
213   CATCH_DUMP_STACK
214
215   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
216   TRY
217   {
218      std::string varIdStr;
219      if (!cstr2string(varId, varIdSize, varIdStr)) return;
220
221      CTimer::get("XIOS").resume();
222      CTimer::get("XIOS get variable data").resume();
223
224      CContext* context = CContext::getCurrent();
225      *isVarExisted = CVariable::has(context->getId(), varIdStr);
226
227      if (*isVarExisted)
228      {
229        *data = CVariable::get(context->getId(), varIdStr)->getData<int>();
230      }
231
232      CTimer::get("XIOS get variable data").suspend();
233      CTimer::get("XIOS").suspend();
234   }
235   CATCH_DUMP_STACK
236
237   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
238   TRY
239   {
240      std::string varIdStr;
241      if (!cstr2string(varId, varIdSize, varIdStr)) return;
242
243      CTimer::get("XIOS").resume();
244      CTimer::get("XIOS get variable data").resume();
245
246      CContext* context = CContext::getCurrent();
247      *isVarExisted = CVariable::has(context->getId(), varIdStr);
248
249      if (*isVarExisted)
250      {
251        *data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
252      }
253
254      CTimer::get("XIOS get variable data").suspend();
255      CTimer::get("XIOS").suspend();
256   }
257   CATCH_DUMP_STACK
258
259   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
260   TRY
261   {
262      std::string varIdStr;
263      if (!cstr2string(varId, varIdSize, varIdStr)) return;
264
265      CTimer::get("XIOS").resume();
266      CTimer::get("XIOS get variable data").resume();
267
268      CContext* context = CContext::getCurrent();
269      *isVarExisted = CVariable::has(context->getId(), varIdStr);
270
271      if (*isVarExisted)
272      {
273        int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
274        strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
275      }
276
277      CTimer::get("XIOS get variable data").suspend();
278      CTimer::get("XIOS").suspend();
279   }
280   CATCH_DUMP_STACK
281
282   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
283    *
284    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
285    * from a Fortran one, for example the value of a variable with id = "using_server".
286    * Each function corresponds to each basic type.
287    * \param varId        [in] id of the variable that we'd like to get
288    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
289    * \param data         [in] the input data
290    * \param isVarExisted [in/out] Verify whether variable with varId exists
291   */
292   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted)
293   TRY
294  {
295      std::string varIdStr;
296      if (!cstr2string(varId, varIdSize, varIdStr)) return;
297
298      CTimer::get("XIOS").resume();
299      CTimer::get("XIOS set variable data").resume();
300
301      CContext* context = CContext::getCurrent();
302      *isVarExisted = CVariable::has(context->getId(), varIdStr);
303
304      if (*isVarExisted)
305      {
306        CVariable::get(context->getId(), varIdStr)->setData<double>(data);
307        //CVariable::get(context->getId(), varIdStr)->sendValue();
308      }
309
310      CTimer::get("XIOS set variable data").suspend();
311      CTimer::get("XIOS").suspend();
312   }
313   CATCH_DUMP_STACK
314
315   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted)
316   TRY
317   {
318      std::string varIdStr;
319      if (!cstr2string(varId, varIdSize, varIdStr)) return;
320
321      CTimer::get("XIOS").resume();
322      CTimer::get("XIOS set variable data").resume();
323
324      CContext* context = CContext::getCurrent();
325      *isVarExisted = CVariable::has(context->getId(), varIdStr);
326
327      if (*isVarExisted)
328      {
329        CVariable::get(context->getId(), varIdStr)->setData<float>(data);
330        //CVariable::get(context->getId(), varIdStr)->sendValue();
331      }
332
333      CTimer::get("XIOS set variable data").suspend();
334      CTimer::get("XIOS").suspend();
335   }
336   CATCH_DUMP_STACK
337
338   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
339   TRY
340   {
341      std::string varIdStr;
342      if (!cstr2string(varId, varIdSize, varIdStr)) return;
343
344      CTimer::get("XIOS").resume();
345      CTimer::get("XIOS set variable data").resume();
346
347      CContext* context = CContext::getCurrent();
348      *isVarExisted = CVariable::has(context->getId(), varIdStr);
349
350      if (*isVarExisted)
351      {
352        CVariable::get(context->getId(), varIdStr)->setData<int>(data);
353        //CVariable::get(context->getId(), varIdStr)->sendValue();
354      }
355
356
357      CTimer::get("XIOS set variable data").suspend();
358      CTimer::get("XIOS").suspend();
359   }
360   CATCH_DUMP_STACK
361
362   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
363   TRY
364   {
365      std::string varIdStr;
366      if (!cstr2string(varId, varIdSize, varIdStr)) return;
367
368      CTimer::get("XIOS").resume();
369      CTimer::get("XIOS set variable data").resume();
370
371      CContext* context = CContext::getCurrent();
372      *isVarExisted = CVariable::has(context->getId(), varIdStr);
373
374      if (*isVarExisted)
375      {
376        CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
377        //CVariable::get(context->getId(), varIdStr)->sendValue();
378      }
379
380      CTimer::get("XIOS set variable data").suspend();
381      CTimer::get("XIOS").suspend();
382   }
383   CATCH_DUMP_STACK
384
385   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
386   TRY
387  {
388      std::string varIdStr, dataStr;
389      if (!cstr2string(varId, varIdSize, varIdStr)) return;
390      if (!cstr2string(data, dataSizeIn, dataStr))
391      {
392        *isVarExisted = false;
393        return;
394      }
395
396      CTimer::get("XIOS").resume();
397      CTimer::get("XIOS set variable data").resume();
398
399      CContext* context = CContext::getCurrent();
400      *isVarExisted = CVariable::has(context->getId(), varIdStr);
401
402      if (*isVarExisted)
403      {
404        CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
405        //CVariable::get(context->getId(), varIdStr)->sendValue();
406      }
407
408      CTimer::get("XIOS set variable data").suspend();
409      CTimer::get("XIOS").suspend();
410   }
411   CATCH_DUMP_STACK
412
413   // ---------------------- Ecriture des données ------------------------------
414
415   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
416   TRY
417   {
418      std::string fieldid_str;
419      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
420
421      CTimer::get("XIOS").resume();
422      CTimer::get("XIOS send field").resume();
423      CContext* context = CContext::getCurrent();
424      if (!context->hasServer && !context->client->isAttachedModeEnabled())
425        context->checkBuffersAndListen();
426      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
427      CField::get(fieldid_str)->setData(data);
428      CTimer::get("XIOS send field").suspend();
429      CTimer::get("XIOS").suspend();
430   }
431   CATCH_DUMP_STACK
432
433   void cxios_write_data_k81(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
439      CTimer::get("XIOS").resume();
440      CTimer::get("XIOS send field").resume();
441
442      CContext* context = CContext::getCurrent();
443      if (!context->hasServer && !context->client->isAttachedModeEnabled())
444        context->checkBuffersAndListen();
445
446      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
447      CField::get(fieldid_str)->setData(data);
448
449      CTimer::get("XIOS send field").suspend();
450      CTimer::get("XIOS").suspend();
451   }
452   CATCH_DUMP_STACK
453
454   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
455   TRY
456   {
457      std::string fieldid_str;
458      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
459
460      CTimer::get("XIOS").resume();
461      CTimer::get("XIOS send field").resume();
462
463      CContext* context = CContext::getCurrent();
464      if (!context->hasServer && !context->client->isAttachedModeEnabled())
465        context->checkBuffersAndListen();
466
467      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
468      CField::get(fieldid_str)->setData(data);
469
470      CTimer::get("XIOS send field").suspend();
471      CTimer::get("XIOS").suspend();
472   }
473   CATCH_DUMP_STACK
474
475   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
476   TRY
477   {
478      std::string fieldid_str;
479      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
480
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, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
489      CField::get(fieldid_str)->setData(data);
490
491      CTimer::get("XIOS send field").suspend();
492      CTimer::get("XIOS").suspend();
493   }
494   CATCH_DUMP_STACK
495
496   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)
497   TRY
498   {
499      std::string fieldid_str;
500      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
501
502      CTimer::get("XIOS").resume();
503      CTimer::get("XIOS send field").resume();
504
505      CContext* context = CContext::getCurrent();
506      if (!context->hasServer && !context->client->isAttachedModeEnabled())
507        context->checkBuffersAndListen();
508
509      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
510      CField::get(fieldid_str)->setData(data);
511
512      CTimer::get("XIOS send field").suspend();
513      CTimer::get("XIOS").suspend();
514   }
515   CATCH_DUMP_STACK
516
517   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
518                             int data_0size, int data_1size, int data_2size,
519                             int data_3size, int data_4size)
520   TRY
521   {
522      std::string fieldid_str;
523      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
524
525      CTimer::get("XIOS").resume();
526      CTimer::get("XIOS send field").resume();
527
528      CContext* context = CContext::getCurrent();
529      if (!context->hasServer && !context->client->isAttachedModeEnabled())
530        context->checkBuffersAndListen();
531
532      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
533      CField::get(fieldid_str)->setData(data);
534
535      CTimer::get("XIOS send field").suspend();
536      CTimer::get("XIOS").suspend();
537   }
538   CATCH_DUMP_STACK
539
540   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
541                             int data_0size, int data_1size, int data_2size,
542                             int data_3size, int data_4size, int data_5size)
543   TRY
544   {
545      std::string fieldid_str;
546      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
547
548      CTimer::get("XIOS").resume();
549      CTimer::get("XIOS send field").resume();
550
551      CContext* context = CContext::getCurrent();
552      if (!context->hasServer && !context->client->isAttachedModeEnabled())
553        context->checkBuffersAndListen();
554
555      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
556      CField::get(fieldid_str)->setData(data);
557
558      CTimer::get("XIOS send field").suspend();
559      CTimer::get("XIOS").suspend();
560   }
561   CATCH_DUMP_STACK
562
563   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
564                             int data_0size, int data_1size, int data_2size,
565                             int data_3size, int data_4size, int data_5size,
566                             int data_6size)
567   TRY
568   {
569      std::string fieldid_str;
570      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
571
572      CTimer::get("XIOS").resume();
573      CTimer::get("XIOS send field").resume();
574
575      CContext* context = CContext::getCurrent();
576      if (!context->hasServer && !context->client->isAttachedModeEnabled())
577        context->checkBuffersAndListen();
578
579      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
580      CField::get(fieldid_str)->setData(data);
581
582      CTimer::get("XIOS send field").suspend();
583      CTimer::get("XIOS").suspend();
584   }
585   CATCH_DUMP_STACK
586
587   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
588   TRY
589   {
590      std::string fieldid_str;
591      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
592
593      CTimer::get("XIOS").resume();
594      CTimer::get("XIOS send field").resume();
595      CContext* context = CContext::getCurrent();
596      if (!context->hasServer && !context->client->isAttachedModeEnabled())
597        context->checkBuffersAndListen();
598
599      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
600      CArray<double, 1> data(data_Xsize) ;
601      data = data_tmp;
602      CField::get(fieldid_str)->setData(data);
603      CTimer::get("XIOS send field").suspend();
604      CTimer::get("XIOS").suspend();
605   }
606   CATCH_DUMP_STACK
607
608   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
609   TRY
610   {
611      std::string fieldid_str;
612      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
613
614      CTimer::get("XIOS").resume();
615      CTimer::get("XIOS send field").resume();
616
617      CContext* context = CContext::getCurrent();
618      if (!context->hasServer && !context->client->isAttachedModeEnabled())
619        context->checkBuffersAndListen();
620
621      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
622      CArray<double, 1> data(data_Xsize);
623      data = data_tmp;
624      CField::get(fieldid_str)->setData(data);
625
626      CTimer::get("XIOS send field").suspend();
627      CTimer::get("XIOS").suspend();
628   }
629   CATCH_DUMP_STACK
630
631   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
632   TRY
633   {
634      std::string fieldid_str;
635      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
636
637      CTimer::get("XIOS").resume();
638      CTimer::get("XIOS send field").resume();
639
640      CContext* context = CContext::getCurrent();
641      if (!context->hasServer && !context->client->isAttachedModeEnabled())
642        context->checkBuffersAndListen();
643
644      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
645      CArray<double, 2> data(data_Xsize, data_Ysize);
646      data = data_tmp;
647      CField::get(fieldid_str)->setData(data);
648
649      CTimer::get("XIOS send field").suspend();
650      CTimer::get("XIOS").suspend();
651   }
652   CATCH_DUMP_STACK
653
654   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
655   TRY
656   {
657      std::string fieldid_str;
658      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
659
660      CTimer::get("XIOS").resume();
661      CTimer::get("XIOS send field").resume();
662
663      CContext* context = CContext::getCurrent();
664      if (!context->hasServer && !context->client->isAttachedModeEnabled())
665        context->checkBuffersAndListen();
666
667      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
668      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
669      data = data_tmp;
670      CField::get(fieldid_str)->setData(data);
671
672      CTimer::get("XIOS send field").suspend();
673      CTimer::get("XIOS").suspend();
674    }
675   CATCH_DUMP_STACK
676
677   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
678                             int data_0size, int data_1size, int data_2size,
679                             int data_3size)
680   TRY
681   {
682      std::string fieldid_str;
683      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
684
685      CTimer::get("XIOS").resume();
686      CTimer::get("XIOS send field").resume();
687
688      CContext* context = CContext::getCurrent();
689      if (!context->hasServer && !context->client->isAttachedModeEnabled())
690        context->checkBuffersAndListen();
691
692      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
693      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
694      data = data_tmp;
695      CField::get(fieldid_str)->setData(data);
696
697      CTimer::get("XIOS send field").suspend();
698      CTimer::get("XIOS").suspend();
699    }
700   CATCH_DUMP_STACK
701
702   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
703                             int data_0size, int data_1size, int data_2size,
704                             int data_3size, int data_4size)
705   TRY
706   {
707      std::string fieldid_str;
708      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
709
710      CTimer::get("XIOS").resume();
711      CTimer::get("XIOS send field").resume();
712
713      CContext* context = CContext::getCurrent();
714      if (!context->hasServer && !context->client->isAttachedModeEnabled())
715        context->checkBuffersAndListen();
716
717      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
718      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
719      data = data_tmp;
720      CField::get(fieldid_str)->setData(data);
721
722      CTimer::get("XIOS send field").suspend();
723      CTimer::get("XIOS").suspend();
724    }
725   CATCH_DUMP_STACK
726
727   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
728                             int data_0size, int data_1size, int data_2size,
729                             int data_3size, int data_4size, int data_5size)
730   TRY
731   {
732      std::string fieldid_str;
733      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
734
735      CTimer::get("XIOS").resume();
736      CTimer::get("XIOS send field").resume();
737
738      CContext* context = CContext::getCurrent();
739      if (!context->hasServer && !context->client->isAttachedModeEnabled())
740        context->checkBuffersAndListen();
741
742      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
743      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
744      data = data_tmp;
745      CField::get(fieldid_str)->setData(data);
746
747      CTimer::get("XIOS send field").suspend();
748      CTimer::get("XIOS").suspend();
749    }
750   CATCH_DUMP_STACK
751
752   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
753                             int data_0size, int data_1size, int data_2size,
754                             int data_3size, int data_4size, int data_5size,
755                             int data_6size)
756   TRY
757   {
758      std::string fieldid_str;
759      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
760
761      CTimer::get("XIOS").resume();
762      CTimer::get("XIOS send field").resume();
763
764      CContext* context = CContext::getCurrent();
765      if (!context->hasServer && !context->client->isAttachedModeEnabled())
766        context->checkBuffersAndListen();
767
768      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
769      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
770      data = data_tmp;
771      CField::get(fieldid_str)->setData(data);
772
773      CTimer::get("XIOS send field").suspend();
774      CTimer::get("XIOS").suspend();
775    }
776   CATCH_DUMP_STACK
777
778   // ---------------------- Lecture des données ------------------------------
779
780   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
781   TRY
782   {
783      std::string fieldid_str;
784      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
785
786      CTimer::get("XIOS").resume();
787      CTimer::get("XIOS recv field").resume();
788
789      CContext* context = CContext::getCurrent();
790      if (!context->hasServer && !context->client->isAttachedModeEnabled())
791        context->checkBuffersAndListen();
792
793      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
794      CField::get(fieldid_str)->getData(data);
795
796      CTimer::get("XIOS recv field").suspend();
797      CTimer::get("XIOS").suspend();
798   }
799   CATCH_DUMP_STACK
800
801   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
802   TRY
803   {
804      std::string fieldid_str;
805      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
806
807      CTimer::get("XIOS").resume();
808      CTimer::get("XIOS recv field").resume();
809
810      CContext* context = CContext::getCurrent();
811      if (!context->hasServer && !context->client->isAttachedModeEnabled())
812        context->checkBuffersAndListen();
813
814      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
815      CField::get(fieldid_str)->getData(data);
816
817      CTimer::get("XIOS recv field").suspend();
818      CTimer::get("XIOS").suspend();
819   }
820   CATCH_DUMP_STACK
821
822   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
823   TRY
824   {
825      std::string fieldid_str;
826      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
827
828      CTimer::get("XIOS").resume();
829      CTimer::get("XIOS recv field").resume();
830
831      CContext* context = CContext::getCurrent();
832      if (!context->hasServer && !context->client->isAttachedModeEnabled())
833        context->checkBuffersAndListen();
834
835      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
836      CField::get(fieldid_str)->getData(data);
837
838      CTimer::get("XIOS recv field").suspend();
839      CTimer::get("XIOS").suspend();
840   }
841   CATCH_DUMP_STACK
842
843   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
844   TRY
845   {
846      std::string fieldid_str;
847      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
848
849      CTimer::get("XIOS").resume();
850      CTimer::get("XIOS recv field").resume();
851
852      CContext* context = CContext::getCurrent();
853      if (!context->hasServer && !context->client->isAttachedModeEnabled())
854        context->checkBuffersAndListen();
855
856      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
857      CField::get(fieldid_str)->getData(data);
858
859      CTimer::get("XIOS recv field").suspend();
860      CTimer::get("XIOS").suspend();
861   }
862   CATCH_DUMP_STACK
863
864   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
865                            int data_0size, int data_1size, int data_2size,
866                            int data_3size)
867   TRY
868   {
869      std::string fieldid_str;
870      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
871
872      CTimer::get("XIOS").resume();
873      CTimer::get("XIOS recv field").resume();
874
875      CContext* context = CContext::getCurrent();
876      if (!context->hasServer && !context->client->isAttachedModeEnabled())
877        context->checkBuffersAndListen();
878
879      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
880      CField::get(fieldid_str)->getData(data);
881
882      CTimer::get("XIOS recv field").suspend();
883      CTimer::get("XIOS").suspend();
884   }
885   CATCH_DUMP_STACK
886
887   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
888                            int data_0size, int data_1size, int data_2size,
889                            int data_3size, int data_4size)
890   TRY
891   {
892      std::string fieldid_str;
893      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
894
895      CTimer::get("XIOS").resume();
896      CTimer::get("XIOS recv field").resume();
897
898      CContext* context = CContext::getCurrent();
899      if (!context->hasServer && !context->client->isAttachedModeEnabled())
900        context->checkBuffersAndListen();
901
902      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
903      CField::get(fieldid_str)->getData(data);
904
905      CTimer::get("XIOS recv field").suspend();
906      CTimer::get("XIOS").suspend();
907   }
908   CATCH_DUMP_STACK
909
910   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
911                            int data_0size, int data_1size, int data_2size,
912                            int data_3size, int data_4size, int data_5size)
913   TRY
914   {
915      std::string fieldid_str;
916      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
917
918      CTimer::get("XIOS").resume();
919      CTimer::get("XIOS recv field").resume();
920
921      CContext* context = CContext::getCurrent();
922      if (!context->hasServer && !context->client->isAttachedModeEnabled())
923        context->checkBuffersAndListen();
924
925      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
926      CField::get(fieldid_str)->getData(data);
927
928      CTimer::get("XIOS recv field").suspend();
929      CTimer::get("XIOS").suspend();
930   }
931   CATCH_DUMP_STACK
932
933   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
934                            int data_0size, int data_1size, int data_2size,
935                            int data_3size, int data_4size, int data_5size,
936                            int data_6size)
937   TRY
938   {
939      std::string fieldid_str;
940      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
941
942      CTimer::get("XIOS").resume();
943      CTimer::get("XIOS recv field").resume();
944
945      CContext* context = CContext::getCurrent();
946      if (!context->hasServer && !context->client->isAttachedModeEnabled())
947        context->checkBuffersAndListen();
948
949      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
950      CField::get(fieldid_str)->getData(data);
951
952      CTimer::get("XIOS recv field").suspend();
953      CTimer::get("XIOS").suspend();
954   }
955   CATCH_DUMP_STACK
956
957   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
958   TRY
959   {
960      std::string fieldid_str;
961      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
962
963      CTimer::get("XIOS").resume();
964      CTimer::get("XIOS recv field").resume();
965
966      CContext* context = CContext::getCurrent();
967      if (!context->hasServer && !context->client->isAttachedModeEnabled())
968        context->checkBuffersAndListen();
969
970      CArray<double, 1> data(data_Xsize);
971      CField::get(fieldid_str)->getData(data);
972      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
973      data_tmp = data;
974
975      CTimer::get("XIOS recv field").suspend();
976      CTimer::get("XIOS").suspend();
977   }
978   CATCH_DUMP_STACK
979
980   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
981   TRY
982   {
983      std::string fieldid_str;
984      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
985
986      CTimer::get("XIOS").resume();
987      CTimer::get("XIOS recv field").resume();
988
989      CContext* context = CContext::getCurrent();
990      if (!context->hasServer && !context->client->isAttachedModeEnabled())
991        context->checkBuffersAndListen();
992
993      CArray<double, 1> data(data_Xsize);
994      CField::get(fieldid_str)->getData(data);
995      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
996      data_tmp = data;
997
998      CTimer::get("XIOS recv field").suspend();
999      CTimer::get("XIOS").suspend();
1000   }
1001   CATCH_DUMP_STACK
1002
1003   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
1004   TRY
1005   {
1006      std::string fieldid_str;
1007      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1008
1009      CTimer::get("XIOS").resume();
1010      CTimer::get("XIOS recv field").resume();
1011
1012      CContext* context = CContext::getCurrent();
1013      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1014        context->checkBuffersAndListen();
1015
1016      CArray<double, 2> data(data_Xsize, data_Ysize);
1017      CField::get(fieldid_str)->getData(data);
1018      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
1019      data_tmp = data;
1020
1021      CTimer::get("XIOS recv field").suspend();
1022      CTimer::get("XIOS").suspend();
1023   }
1024   CATCH_DUMP_STACK
1025
1026   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
1027   TRY
1028   {
1029      std::string fieldid_str;
1030      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1031
1032      CTimer::get("XIOS").resume();
1033      CTimer::get("XIOS recv field").resume();
1034
1035      CContext* context = CContext::getCurrent();
1036      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1037        context->checkBuffersAndListen();
1038
1039      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
1040      CField::get(fieldid_str)->getData(data);
1041      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
1042      data_tmp = data;
1043
1044      CTimer::get("XIOS recv field").suspend();
1045      CTimer::get("XIOS").suspend();
1046    }
1047   CATCH_DUMP_STACK
1048
1049   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
1050                            int data_0size, int data_1size, int data_2size,
1051                            int data_3size)
1052   TRY
1053   {
1054      std::string fieldid_str;
1055      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1056
1057      CTimer::get("XIOS").resume();
1058      CTimer::get("XIOS recv field").resume();
1059
1060      CContext* context = CContext::getCurrent();
1061      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1062        context->checkBuffersAndListen();
1063
1064      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
1065      CField::get(fieldid_str)->getData(data);
1066      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
1067      data_tmp = data;
1068
1069      CTimer::get("XIOS recv field").suspend();
1070      CTimer::get("XIOS").suspend();
1071    }
1072   CATCH_DUMP_STACK
1073
1074   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
1075                            int data_0size, int data_1size, int data_2size,
1076                            int data_3size, int data_4size)
1077   TRY
1078   {
1079      std::string fieldid_str;
1080      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1081
1082      CTimer::get("XIOS").resume();
1083      CTimer::get("XIOS recv field").resume();
1084
1085      CContext* context = CContext::getCurrent();
1086      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1087        context->checkBuffersAndListen();
1088
1089      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1090      CField::get(fieldid_str)->getData(data);
1091      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1092      data_tmp = data;
1093
1094      CTimer::get("XIOS recv field").suspend();
1095      CTimer::get("XIOS").suspend();
1096    }
1097   CATCH_DUMP_STACK
1098
1099   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
1100                            int data_0size, int data_1size, int data_2size,
1101                            int data_3size, int data_4size, int data_5size)
1102   TRY
1103   {
1104      std::string fieldid_str;
1105      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1106
1107      CTimer::get("XIOS").resume();
1108      CTimer::get("XIOS recv field").resume();
1109
1110      CContext* context = CContext::getCurrent();
1111      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1112        context->checkBuffersAndListen();
1113
1114      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1115      CField::get(fieldid_str)->getData(data);
1116      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1117      data_tmp = data;
1118
1119      CTimer::get("XIOS recv field").suspend();
1120      CTimer::get("XIOS").suspend();
1121    }
1122   CATCH_DUMP_STACK
1123
1124   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1125                            int data_0size, int data_1size, int data_2size,
1126                            int data_3size, int data_4size, int data_5size,
1127                            int data_6size)
1128   TRY
1129   {
1130      std::string fieldid_str;
1131      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1132
1133      CTimer::get("XIOS").resume();
1134      CTimer::get("XIOS recv field").resume();
1135
1136      CContext* context = CContext::getCurrent();
1137      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1138        context->checkBuffersAndListen();
1139
1140      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1141      CField::get(fieldid_str)->getData(data);
1142      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1143      data_tmp = data;
1144
1145      CTimer::get("XIOS recv field").suspend();
1146      CTimer::get("XIOS").suspend();
1147    }
1148   CATCH_DUMP_STACK
1149} // extern "C"
Note: See TracBrowser for help on using the repository browser.