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

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

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