source: XIOS/trunk/src/interface/c/icdata.cpp @ 932

Last change on this file since 932 was 932, checked in by mhnguyen, 5 years ago

Adding Fortran interface for high-dimension grid (up to 7)

+) Add check mask for high-dimension grid
+) Add Fortran interface for send_field, recv_field

Test
+) On Curie
+) Work

  • 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: 36.2 KB
Line 
1/* ************************************************************************** *
2 *      Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
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   {
46     CXios::initialize();
47   }
48
49   void cxios_init_server(void)
50   {
51     CXios::initServerSide();
52   }
53
54   void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
55   {
56      std::string str;
57      MPI_Comm local_comm;
58      MPI_Comm return_comm;
59
60      if (!cstr2string(client_id, len_client_id, str)) return;
61
62      int initialized;
63      MPI_Initialized(&initialized);
64      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
65      else local_comm=MPI_COMM_NULL;
66      CXios::initClientSide(str, local_comm, return_comm);
67      *f_return_comm=MPI_Comm_c2f(return_comm);
68      CTimer::get("XIOS init").suspend();
69      CTimer::get("XIOS").suspend();
70   }
71
72   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
73   {
74     std::string str;
75     MPI_Comm comm;
76
77     if (!cstr2string(context_id, len_context_id, str)) return;
78     CTimer::get("XIOS").resume();
79     CTimer::get("XIOS init context").resume();
80     comm=MPI_Comm_f2c(*f_comm);
81     CClient::registerContext(str, comm);
82     CTimer::get("XIOS init context").suspend();
83     CTimer::get("XIOS").suspend();
84   }
85
86   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
87   {
88     std::string str;
89
90     if (!cstr2string(context_id, len_context_id, str)) return;
91     CTimer::get("XIOS").resume();
92     CContext* context = CContext::get(str, str);
93     *initialized=context->isInitialized();
94     CTimer::get("XIOS").suspend();
95   }
96
97    void cxios_context_close_definition()
98   {
99     CTimer::get("XIOS").resume();
100     CTimer::get("XIOS close definition").resume();
101     CContext* context = CContext::getCurrent();
102     context->closeDefinition();
103     CTimer::get("XIOS close definition").suspend();
104     CTimer::get("XIOS").suspend();
105   }
106
107   void cxios_context_finalize()
108   {
109     CTimer::get("XIOS").resume();
110     CTimer::get("XIOS context finalize").resume();
111     CContext* context = CContext::getCurrent();
112     context->finalize();
113     CTimer::get("XIOS context finalize").suspend();
114     CTimer::get("XIOS").suspend();
115   }
116
117   void cxios_finalize()
118   {
119     CTimer::get("XIOS").resume();
120     CTimer::get("XIOS finalize").resume();
121     CXios::clientFinalize();
122   }
123
124   void cxios_solve_inheritance()
125   {
126     CTimer::get("XIOS").resume();
127     CContext* context = CContext::getCurrent();
128     context->solveAllInheritance(false);
129     CTimer::get("XIOS").suspend();
130   }
131
132   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
133    *
134    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
135    * from a Fortran one, for example the value of a variable with id = "using_server".
136    * Each function corresponds to each basic type.
137    * \param varId        [in] id of the variable that we'd like to get
138    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
139    * \param dataInt      [in/out] the retrieved data
140    * \param isVarExisted [in/out] Verify whether variable with varId exists
141   */
142   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
143   {
144      std::string varIdStr;
145      if (!cstr2string(varId, varIdSize, varIdStr)) return;
146
147      CTimer::get("XIOS").resume();
148      CTimer::get("XIOS get variable data").resume();
149
150      CContext* context = CContext::getCurrent();
151      *isVarExisted = CVariable::has(context->getId(), varIdStr);
152
153      if (*isVarExisted)
154      {
155        *data = CVariable::get(context->getId(), varIdStr)->getData<double>();
156      }
157
158      CTimer::get("XIOS get variable data").suspend();
159      CTimer::get("XIOS").suspend();
160   }
161
162   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
163   {
164      std::string varIdStr;
165      if (!cstr2string(varId, varIdSize, varIdStr)) return;
166
167      CTimer::get("XIOS").resume();
168      CTimer::get("XIOS get variable data").resume();
169
170      CContext* context = CContext::getCurrent();
171      *isVarExisted = CVariable::has(context->getId(), varIdStr);
172
173      if (*isVarExisted)
174      {
175        *data = CVariable::get(context->getId(), varIdStr)->getData<float>();
176      }
177
178      CTimer::get("XIOS get variable data").suspend();
179      CTimer::get("XIOS").suspend();
180   }
181
182   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
183   {
184      std::string varIdStr;
185      if (!cstr2string(varId, varIdSize, varIdStr)) return;
186
187      CTimer::get("XIOS").resume();
188      CTimer::get("XIOS get variable data").resume();
189
190      CContext* context = CContext::getCurrent();
191      *isVarExisted = CVariable::has(context->getId(), varIdStr);
192
193      if (*isVarExisted)
194      {
195        *data = CVariable::get(context->getId(), varIdStr)->getData<int>();
196      }
197
198      CTimer::get("XIOS get variable data").suspend();
199      CTimer::get("XIOS").suspend();
200   }
201
202   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
203   {
204      std::string varIdStr;
205      if (!cstr2string(varId, varIdSize, varIdStr)) return;
206
207      CTimer::get("XIOS").resume();
208      CTimer::get("XIOS get variable data").resume();
209
210      CContext* context = CContext::getCurrent();
211      *isVarExisted = CVariable::has(context->getId(), varIdStr);
212
213      if (*isVarExisted)
214      {
215        *data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
216      }
217
218      CTimer::get("XIOS get variable data").suspend();
219      CTimer::get("XIOS").suspend();
220   }
221
222   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
223   {
224      std::string varIdStr;
225      if (!cstr2string(varId, varIdSize, varIdStr)) return;
226
227      CTimer::get("XIOS").resume();
228      CTimer::get("XIOS get variable data").resume();
229
230      CContext* context = CContext::getCurrent();
231      *isVarExisted = CVariable::has(context->getId(), varIdStr);
232
233      if (*isVarExisted)
234      {
235        int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
236        strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
237      }
238
239      CTimer::get("XIOS get variable data").suspend();
240      CTimer::get("XIOS").suspend();
241   }
242
243   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
244    *
245    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
246    * from a Fortran one, for example the value of a variable with id = "using_server".
247    * Each function corresponds to each basic type.
248    * \param varId        [in] id of the variable that we'd like to get
249    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
250    * \param data         [in] the input data
251    * \param isVarExisted [in/out] Verify whether variable with varId exists
252   */
253   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted)
254   {
255      std::string varIdStr;
256      if (!cstr2string(varId, varIdSize, varIdStr)) return;
257
258      CTimer::get("XIOS").resume();
259      CTimer::get("XIOS set variable data").resume();
260
261      CContext* context = CContext::getCurrent();
262      *isVarExisted = CVariable::has(context->getId(), varIdStr);
263
264      if (*isVarExisted)
265      {
266        CVariable::get(context->getId(), varIdStr)->setData<double>(data);
267        //CVariable::get(context->getId(), varIdStr)->sendValue();
268      }
269
270      CTimer::get("XIOS set variable data").suspend();
271      CTimer::get("XIOS").suspend();
272   }
273
274   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted)
275   {
276      std::string varIdStr;
277      if (!cstr2string(varId, varIdSize, varIdStr)) return;
278
279      CTimer::get("XIOS").resume();
280      CTimer::get("XIOS set variable data").resume();
281
282      CContext* context = CContext::getCurrent();
283      *isVarExisted = CVariable::has(context->getId(), varIdStr);
284
285      if (*isVarExisted)
286      {
287        CVariable::get(context->getId(), varIdStr)->setData<float>(data);
288        //CVariable::get(context->getId(), varIdStr)->sendValue();
289      }
290
291      CTimer::get("XIOS set variable data").suspend();
292      CTimer::get("XIOS").suspend();
293   }
294
295   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
296   {
297      std::string varIdStr;
298      if (!cstr2string(varId, varIdSize, varIdStr)) return;
299
300      CTimer::get("XIOS").resume();
301      CTimer::get("XIOS set variable data").resume();
302
303      CContext* context = CContext::getCurrent();
304      *isVarExisted = CVariable::has(context->getId(), varIdStr);
305
306      if (*isVarExisted)
307      {
308        CVariable::get(context->getId(), varIdStr)->setData<int>(data);
309        //CVariable::get(context->getId(), varIdStr)->sendValue();
310      }
311
312
313      CTimer::get("XIOS set variable data").suspend();
314      CTimer::get("XIOS").suspend();
315   }
316
317   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
318   {
319      std::string varIdStr;
320      if (!cstr2string(varId, varIdSize, varIdStr)) return;
321
322      CTimer::get("XIOS").resume();
323      CTimer::get("XIOS set variable data").resume();
324
325      CContext* context = CContext::getCurrent();
326      *isVarExisted = CVariable::has(context->getId(), varIdStr);
327
328      if (*isVarExisted)
329      {
330        CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
331        //CVariable::get(context->getId(), varIdStr)->sendValue();
332      }
333
334      CTimer::get("XIOS set variable data").suspend();
335      CTimer::get("XIOS").suspend();
336   }
337
338   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
339   {
340      std::string varIdStr, dataStr;
341      if (!cstr2string(varId, varIdSize, varIdStr)) return;
342      if (!cstr2string(data, dataSizeIn, dataStr))
343      {
344        *isVarExisted = false;
345        return;
346      }
347
348      CTimer::get("XIOS").resume();
349      CTimer::get("XIOS set variable data").resume();
350
351      CContext* context = CContext::getCurrent();
352      *isVarExisted = CVariable::has(context->getId(), varIdStr);
353
354      if (*isVarExisted)
355      {
356        CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
357        //CVariable::get(context->getId(), varIdStr)->sendValue();
358      }
359
360      CTimer::get("XIOS set variable data").suspend();
361      CTimer::get("XIOS").suspend();
362   }
363
364
365   // ---------------------- Ecriture des données ------------------------------
366
367   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
368   {
369      std::string fieldid_str;
370      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
371
372      CTimer::get("XIOS").resume();
373      CTimer::get("XIOS send field").resume();
374      CContext* context = CContext::getCurrent();
375      if (!context->hasServer && !context->client->isAttachedModeEnabled())
376        context->checkBuffersAndListen();
377      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
378      CField::get(fieldid_str)->setData(data);
379      CTimer::get("XIOS send field").suspend();
380      CTimer::get("XIOS").suspend();
381   }
382
383   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
384   {
385      std::string fieldid_str;
386      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
387
388      CTimer::get("XIOS").resume();
389      CTimer::get("XIOS send field").resume();
390
391      CContext* context = CContext::getCurrent();
392      if (!context->hasServer && !context->client->isAttachedModeEnabled())
393        context->checkBuffersAndListen();
394
395      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
396      CField::get(fieldid_str)->setData(data);
397
398      CTimer::get("XIOS send field").suspend();
399      CTimer::get("XIOS").suspend();
400   }
401
402   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
403   {
404      std::string fieldid_str;
405      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
406
407      CTimer::get("XIOS").resume();
408      CTimer::get("XIOS send field").resume();
409
410      CContext* context = CContext::getCurrent();
411      if (!context->hasServer && !context->client->isAttachedModeEnabled())
412        context->checkBuffersAndListen();
413
414      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
415      CField::get(fieldid_str)->setData(data);
416
417      CTimer::get("XIOS send field").suspend();
418      CTimer::get("XIOS").suspend();
419   }
420
421   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
422   {
423      std::string fieldid_str;
424      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
425
426      CTimer::get("XIOS").resume();
427      CTimer::get("XIOS send field").resume();
428
429      CContext* context = CContext::getCurrent();
430      if (!context->hasServer && !context->client->isAttachedModeEnabled())
431        context->checkBuffersAndListen();
432
433      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
434      CField::get(fieldid_str)->setData(data);
435
436      CTimer::get("XIOS send field").suspend();
437      CTimer::get("XIOS").suspend();
438   }
439
440   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)
441   {
442      std::string fieldid_str;
443      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
444
445      CTimer::get("XIOS").resume();
446      CTimer::get("XIOS send field").resume();
447
448      CContext* context = CContext::getCurrent();
449      if (!context->hasServer && !context->client->isAttachedModeEnabled())
450        context->checkBuffersAndListen();
451
452      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
453      CField::get(fieldid_str)->setData(data);
454
455      CTimer::get("XIOS send field").suspend();
456      CTimer::get("XIOS").suspend();
457   }
458
459   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
460                             int data_0size, int data_1size, int data_2size,
461                             int data_3size, int data_4size)
462   {
463      std::string fieldid_str;
464      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
465
466      CTimer::get("XIOS").resume();
467      CTimer::get("XIOS send field").resume();
468
469      CContext* context = CContext::getCurrent();
470      if (!context->hasServer && !context->client->isAttachedModeEnabled())
471        context->checkBuffersAndListen();
472
473      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
474      CField::get(fieldid_str)->setData(data);
475
476      CTimer::get("XIOS send field").suspend();
477      CTimer::get("XIOS").suspend();
478   }
479
480   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
481                             int data_0size, int data_1size, int data_2size,
482                             int data_3size, int data_4size, int data_5size)
483   {
484      std::string fieldid_str;
485      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
486
487      CTimer::get("XIOS").resume();
488      CTimer::get("XIOS send field").resume();
489
490      CContext* context = CContext::getCurrent();
491      if (!context->hasServer && !context->client->isAttachedModeEnabled())
492        context->checkBuffersAndListen();
493
494      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
495      CField::get(fieldid_str)->setData(data);
496
497      CTimer::get("XIOS send field").suspend();
498      CTimer::get("XIOS").suspend();
499   }
500
501   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
502                             int data_0size, int data_1size, int data_2size,
503                             int data_3size, int data_4size, int data_5size,
504                             int data_6size)
505   {
506      std::string fieldid_str;
507      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
508
509      CTimer::get("XIOS").resume();
510      CTimer::get("XIOS send field").resume();
511
512      CContext* context = CContext::getCurrent();
513      if (!context->hasServer && !context->client->isAttachedModeEnabled())
514        context->checkBuffersAndListen();
515
516      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
517      CField::get(fieldid_str)->setData(data);
518
519      CTimer::get("XIOS send field").suspend();
520      CTimer::get("XIOS").suspend();
521   }
522
523   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
524   {
525      std::string fieldid_str;
526      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
527
528      CTimer::get("XIOS").resume();
529      CTimer::get("XIOS send field").resume();
530      CContext* context = CContext::getCurrent();
531      if (!context->hasServer && !context->client->isAttachedModeEnabled())
532        context->checkBuffersAndListen();
533
534      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
535      CArray<double, 1> data(data_Xsize) ;
536      data = data_tmp;
537      CField::get(fieldid_str)->setData(data);
538      CTimer::get("XIOS send field").suspend();
539      CTimer::get("XIOS").suspend();
540   }
541
542   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
543   {
544      std::string fieldid_str;
545      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
546
547      CTimer::get("XIOS").resume();
548      CTimer::get("XIOS send field").resume();
549
550      CContext* context = CContext::getCurrent();
551      if (!context->hasServer && !context->client->isAttachedModeEnabled())
552        context->checkBuffersAndListen();
553
554      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
555      CArray<double, 1> data(data_Xsize);
556      data = data_tmp;
557      CField::get(fieldid_str)->setData(data);
558
559      CTimer::get("XIOS send field").suspend();
560      CTimer::get("XIOS").suspend();
561   }
562
563   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
564   {
565      std::string fieldid_str;
566      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
567
568      CTimer::get("XIOS").resume();
569      CTimer::get("XIOS send field").resume();
570
571      CContext* context = CContext::getCurrent();
572      if (!context->hasServer && !context->client->isAttachedModeEnabled())
573        context->checkBuffersAndListen();
574
575      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
576      CArray<double, 2> data(data_Xsize, data_Ysize);
577      data = data_tmp;
578      CField::get(fieldid_str)->setData(data);
579
580      CTimer::get("XIOS send field").suspend();
581      CTimer::get("XIOS").suspend();
582   }
583
584   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
585   {
586      std::string fieldid_str;
587      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
588
589      CTimer::get("XIOS").resume();
590      CTimer::get("XIOS send field").resume();
591
592      CContext* context = CContext::getCurrent();
593      if (!context->hasServer && !context->client->isAttachedModeEnabled())
594        context->checkBuffersAndListen();
595
596      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
597      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
598      data = data_tmp;
599      CField::get(fieldid_str)->setData(data);
600
601      CTimer::get("XIOS send field").suspend();
602      CTimer::get("XIOS").suspend();
603    }
604
605   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
606                             int data_0size, int data_1size, int data_2size,
607                             int data_3size)
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, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
620      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
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
628   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
629                             int data_0size, int data_1size, int data_2size,
630                             int data_3size, int data_4size)
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, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
643      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
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
651   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
652                             int data_0size, int data_1size, int data_2size,
653                             int data_3size, int data_4size, int data_5size)
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, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
666      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
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
674   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
675                             int data_0size, int data_1size, int data_2size,
676                             int data_3size, int data_4size, int data_5size,
677                             int data_6size)
678   {
679      std::string fieldid_str;
680      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
681
682      CTimer::get("XIOS").resume();
683      CTimer::get("XIOS send field").resume();
684
685      CContext* context = CContext::getCurrent();
686      if (!context->hasServer && !context->client->isAttachedModeEnabled())
687        context->checkBuffersAndListen();
688
689      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
690      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
691      data = data_tmp;
692      CField::get(fieldid_str)->setData(data);
693
694      CTimer::get("XIOS send field").suspend();
695      CTimer::get("XIOS").suspend();
696    }
697
698   // ---------------------- Lecture des données ------------------------------
699
700   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
701   {
702      std::string fieldid_str;
703      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
704
705      CTimer::get("XIOS").resume();
706      CTimer::get("XIOS recv field").resume();
707
708      CContext* context = CContext::getCurrent();
709      if (!context->hasServer && !context->client->isAttachedModeEnabled())
710        context->checkBuffersAndListen();
711
712      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
713      CField::get(fieldid_str)->getData(data);
714
715      CTimer::get("XIOS recv field").suspend();
716      CTimer::get("XIOS").suspend();
717   }
718
719   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
720   {
721      std::string fieldid_str;
722      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
723
724      CTimer::get("XIOS").resume();
725      CTimer::get("XIOS recv field").resume();
726
727      CContext* context = CContext::getCurrent();
728      if (!context->hasServer && !context->client->isAttachedModeEnabled())
729        context->checkBuffersAndListen();
730
731      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
732      CField::get(fieldid_str)->getData(data);
733
734      CTimer::get("XIOS recv field").suspend();
735      CTimer::get("XIOS").suspend();
736   }
737
738   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
739   {
740      std::string fieldid_str;
741      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
742
743      CTimer::get("XIOS").resume();
744      CTimer::get("XIOS recv field").resume();
745
746      CContext* context = CContext::getCurrent();
747      if (!context->hasServer && !context->client->isAttachedModeEnabled())
748        context->checkBuffersAndListen();
749
750      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
751      CField::get(fieldid_str)->getData(data);
752
753      CTimer::get("XIOS recv field").suspend();
754      CTimer::get("XIOS").suspend();
755   }
756
757   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
758                            int data_0size, int data_1size, int data_2size,
759                            int data_3size)
760   {
761      std::string fieldid_str;
762      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
763
764      CTimer::get("XIOS").resume();
765      CTimer::get("XIOS recv field").resume();
766
767      CContext* context = CContext::getCurrent();
768      if (!context->hasServer && !context->client->isAttachedModeEnabled())
769        context->checkBuffersAndListen();
770
771      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
772      CField::get(fieldid_str)->getData(data);
773
774      CTimer::get("XIOS recv field").suspend();
775      CTimer::get("XIOS").suspend();
776   }
777
778   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
779                            int data_0size, int data_1size, int data_2size,
780                            int data_3size, int data_4size)
781   {
782      std::string fieldid_str;
783      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
784
785      CTimer::get("XIOS").resume();
786      CTimer::get("XIOS recv field").resume();
787
788      CContext* context = CContext::getCurrent();
789      if (!context->hasServer && !context->client->isAttachedModeEnabled())
790        context->checkBuffersAndListen();
791
792      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
793      CField::get(fieldid_str)->getData(data);
794
795      CTimer::get("XIOS recv field").suspend();
796      CTimer::get("XIOS").suspend();
797   }
798
799   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
800                            int data_0size, int data_1size, int data_2size,
801                            int data_3size, int data_4size, int data_5size)
802   {
803      std::string fieldid_str;
804      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
805
806      CTimer::get("XIOS").resume();
807      CTimer::get("XIOS recv field").resume();
808
809      CContext* context = CContext::getCurrent();
810      if (!context->hasServer && !context->client->isAttachedModeEnabled())
811        context->checkBuffersAndListen();
812
813      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
814      CField::get(fieldid_str)->getData(data);
815
816      CTimer::get("XIOS recv field").suspend();
817      CTimer::get("XIOS").suspend();
818   }
819
820   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
821                            int data_0size, int data_1size, int data_2size,
822                            int data_3size, int data_4size, int data_5size,
823                            int data_6size)
824   {
825      std::string fieldid_str;
826      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
827
828      CTimer::get("XIOS").resume();
829      CTimer::get("XIOS recv field").resume();
830
831      CContext* context = CContext::getCurrent();
832      if (!context->hasServer && !context->client->isAttachedModeEnabled())
833        context->checkBuffersAndListen();
834
835      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
836      CField::get(fieldid_str)->getData(data);
837
838      CTimer::get("XIOS recv field").suspend();
839      CTimer::get("XIOS").suspend();
840   }
841
842   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
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, 1> data(data_Xsize);
855      CField::get(fieldid_str)->getData(data);
856      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
857      data_tmp = data;
858
859      CTimer::get("XIOS recv field").suspend();
860      CTimer::get("XIOS").suspend();
861   }
862
863   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
864   {
865      std::string fieldid_str;
866      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
867
868      CTimer::get("XIOS").resume();
869      CTimer::get("XIOS recv field").resume();
870
871      CContext* context = CContext::getCurrent();
872      if (!context->hasServer && !context->client->isAttachedModeEnabled())
873        context->checkBuffersAndListen();
874
875      CArray<double, 2> data(data_Xsize, data_Ysize);
876      CField::get(fieldid_str)->getData(data);
877      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
878      data_tmp = data;
879
880      CTimer::get("XIOS recv field").suspend();
881      CTimer::get("XIOS").suspend();
882   }
883
884   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
885   {
886      std::string fieldid_str;
887      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
888
889      CTimer::get("XIOS").resume();
890      CTimer::get("XIOS recv field").resume();
891
892      CContext* context = CContext::getCurrent();
893      if (!context->hasServer && !context->client->isAttachedModeEnabled())
894        context->checkBuffersAndListen();
895
896      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
897      CField::get(fieldid_str)->getData(data);
898      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
899      data_tmp = data;
900
901      CTimer::get("XIOS recv field").suspend();
902      CTimer::get("XIOS").suspend();
903    }
904
905   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
906                            int data_0size, int data_1size, int data_2size,
907                            int data_3size)
908   {
909      std::string fieldid_str;
910      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
911
912      CTimer::get("XIOS").resume();
913      CTimer::get("XIOS recv field").resume();
914
915      CContext* context = CContext::getCurrent();
916      if (!context->hasServer && !context->client->isAttachedModeEnabled())
917        context->checkBuffersAndListen();
918
919      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
920      CField::get(fieldid_str)->getData(data);
921      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
922      data_tmp = data;
923
924      CTimer::get("XIOS recv field").suspend();
925      CTimer::get("XIOS").suspend();
926    }
927
928   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
929                            int data_0size, int data_1size, int data_2size,
930                            int data_3size, int data_4size)
931   {
932      std::string fieldid_str;
933      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
934
935      CTimer::get("XIOS").resume();
936      CTimer::get("XIOS recv field").resume();
937
938      CContext* context = CContext::getCurrent();
939      if (!context->hasServer && !context->client->isAttachedModeEnabled())
940        context->checkBuffersAndListen();
941
942      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
943      CField::get(fieldid_str)->getData(data);
944      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
945      data_tmp = data;
946
947      CTimer::get("XIOS recv field").suspend();
948      CTimer::get("XIOS").suspend();
949    }
950
951   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
952                            int data_0size, int data_1size, int data_2size,
953                            int data_3size, int data_4size, int data_5size)
954   {
955      std::string fieldid_str;
956      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
957
958      CTimer::get("XIOS").resume();
959      CTimer::get("XIOS recv field").resume();
960
961      CContext* context = CContext::getCurrent();
962      if (!context->hasServer && !context->client->isAttachedModeEnabled())
963        context->checkBuffersAndListen();
964
965      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
966      CField::get(fieldid_str)->getData(data);
967      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
968      data_tmp = data;
969
970      CTimer::get("XIOS recv field").suspend();
971      CTimer::get("XIOS").suspend();
972    }
973
974   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
975                            int data_0size, int data_1size, int data_2size,
976                            int data_3size, int data_4size, int data_5size,
977                            int data_6size)
978   {
979      std::string fieldid_str;
980      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
981
982      CTimer::get("XIOS").resume();
983      CTimer::get("XIOS recv field").resume();
984
985      CContext* context = CContext::getCurrent();
986      if (!context->hasServer && !context->client->isAttachedModeEnabled())
987        context->checkBuffersAndListen();
988
989      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
990      CField::get(fieldid_str)->getData(data);
991      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
992      data_tmp = data;
993
994      CTimer::get("XIOS recv field").suspend();
995      CTimer::get("XIOS").suspend();
996    }
997} // extern "C"
Note: See TracBrowser for help on using the repository browser.