source: XIOS/dev/dev_trunk_omp/src/interface/c/icdata.cpp @ 1646

Last change on this file since 1646 was 1646, checked in by yushan, 5 years ago

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