source: XIOS/dev/dev_olga/src/interface/c/icdata.cpp @ 1612

Last change on this file since 1612 was 1612, checked in by oabramkina, 21 months ago

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

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