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

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

Fortran interface: Receiving scalar value

  • 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: 37.6 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_k80(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_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
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, 1> data(data_k8, shape(data_Xsize), 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_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
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, 2>data(data_k8, shape(data_Xsize, data_Ysize), 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_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
758   {
759      std::string fieldid_str;
760      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
761
762      CTimer::get("XIOS").resume();
763      CTimer::get("XIOS recv field").resume();
764
765      CContext* context = CContext::getCurrent();
766      if (!context->hasServer && !context->client->isAttachedModeEnabled())
767        context->checkBuffersAndListen();
768
769      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
770      CField::get(fieldid_str)->getData(data);
771
772      CTimer::get("XIOS recv field").suspend();
773      CTimer::get("XIOS").suspend();
774   }
775
776   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
777                            int data_0size, int data_1size, int data_2size,
778                            int data_3size)
779   {
780      std::string fieldid_str;
781      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
782
783      CTimer::get("XIOS").resume();
784      CTimer::get("XIOS recv field").resume();
785
786      CContext* context = CContext::getCurrent();
787      if (!context->hasServer && !context->client->isAttachedModeEnabled())
788        context->checkBuffersAndListen();
789
790      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
791      CField::get(fieldid_str)->getData(data);
792
793      CTimer::get("XIOS recv field").suspend();
794      CTimer::get("XIOS").suspend();
795   }
796
797   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
798                            int data_0size, int data_1size, int data_2size,
799                            int data_3size, int data_4size)
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, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
812      CField::get(fieldid_str)->getData(data);
813
814      CTimer::get("XIOS recv field").suspend();
815      CTimer::get("XIOS").suspend();
816   }
817
818   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
819                            int data_0size, int data_1size, int data_2size,
820                            int data_3size, int data_4size, int data_5size)
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, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
833      CField::get(fieldid_str)->getData(data);
834
835      CTimer::get("XIOS recv field").suspend();
836      CTimer::get("XIOS").suspend();
837   }
838
839   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
840                            int data_0size, int data_1size, int data_2size,
841                            int data_3size, int data_4size, int data_5size,
842                            int data_6size)
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, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
855      CField::get(fieldid_str)->getData(data);
856
857      CTimer::get("XIOS recv field").suspend();
858      CTimer::get("XIOS").suspend();
859   }
860
861   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
862   {
863      std::string fieldid_str;
864      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
865
866      CTimer::get("XIOS").resume();
867      CTimer::get("XIOS recv field").resume();
868
869      CContext* context = CContext::getCurrent();
870      if (!context->hasServer && !context->client->isAttachedModeEnabled())
871        context->checkBuffersAndListen();
872
873      CArray<double, 1> data(data_Xsize);
874      CField::get(fieldid_str)->getData(data);
875      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
876      data_tmp = data;
877
878      CTimer::get("XIOS recv field").suspend();
879      CTimer::get("XIOS").suspend();
880   }
881
882   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
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, 1> data(data_Xsize);
895      CField::get(fieldid_str)->getData(data);
896      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
897      data_tmp = data;
898
899      CTimer::get("XIOS recv field").suspend();
900      CTimer::get("XIOS").suspend();
901   }
902
903   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
904   {
905      std::string fieldid_str;
906      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
907
908      CTimer::get("XIOS").resume();
909      CTimer::get("XIOS recv field").resume();
910
911      CContext* context = CContext::getCurrent();
912      if (!context->hasServer && !context->client->isAttachedModeEnabled())
913        context->checkBuffersAndListen();
914
915      CArray<double, 2> data(data_Xsize, data_Ysize);
916      CField::get(fieldid_str)->getData(data);
917      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
918      data_tmp = data;
919
920      CTimer::get("XIOS recv field").suspend();
921      CTimer::get("XIOS").suspend();
922   }
923
924   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
925   {
926      std::string fieldid_str;
927      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
928
929      CTimer::get("XIOS").resume();
930      CTimer::get("XIOS recv field").resume();
931
932      CContext* context = CContext::getCurrent();
933      if (!context->hasServer && !context->client->isAttachedModeEnabled())
934        context->checkBuffersAndListen();
935
936      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
937      CField::get(fieldid_str)->getData(data);
938      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
939      data_tmp = data;
940
941      CTimer::get("XIOS recv field").suspend();
942      CTimer::get("XIOS").suspend();
943    }
944
945   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
946                            int data_0size, int data_1size, int data_2size,
947                            int data_3size)
948   {
949      std::string fieldid_str;
950      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
951
952      CTimer::get("XIOS").resume();
953      CTimer::get("XIOS recv field").resume();
954
955      CContext* context = CContext::getCurrent();
956      if (!context->hasServer && !context->client->isAttachedModeEnabled())
957        context->checkBuffersAndListen();
958
959      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
960      CField::get(fieldid_str)->getData(data);
961      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
962      data_tmp = data;
963
964      CTimer::get("XIOS recv field").suspend();
965      CTimer::get("XIOS").suspend();
966    }
967
968   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
969                            int data_0size, int data_1size, int data_2size,
970                            int data_3size, int data_4size)
971   {
972      std::string fieldid_str;
973      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
974
975      CTimer::get("XIOS").resume();
976      CTimer::get("XIOS recv field").resume();
977
978      CContext* context = CContext::getCurrent();
979      if (!context->hasServer && !context->client->isAttachedModeEnabled())
980        context->checkBuffersAndListen();
981
982      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
983      CField::get(fieldid_str)->getData(data);
984      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
985      data_tmp = data;
986
987      CTimer::get("XIOS recv field").suspend();
988      CTimer::get("XIOS").suspend();
989    }
990
991   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
992                            int data_0size, int data_1size, int data_2size,
993                            int data_3size, int data_4size, int data_5size)
994   {
995      std::string fieldid_str;
996      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
997
998      CTimer::get("XIOS").resume();
999      CTimer::get("XIOS recv field").resume();
1000
1001      CContext* context = CContext::getCurrent();
1002      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1003        context->checkBuffersAndListen();
1004
1005      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1006      CField::get(fieldid_str)->getData(data);
1007      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1008      data_tmp = data;
1009
1010      CTimer::get("XIOS recv field").suspend();
1011      CTimer::get("XIOS").suspend();
1012    }
1013
1014   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1015                            int data_0size, int data_1size, int data_2size,
1016                            int data_3size, int data_4size, int data_5size,
1017                            int data_6size)
1018   {
1019      std::string fieldid_str;
1020      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1021
1022      CTimer::get("XIOS").resume();
1023      CTimer::get("XIOS recv field").resume();
1024
1025      CContext* context = CContext::getCurrent();
1026      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1027        context->checkBuffersAndListen();
1028
1029      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1030      CField::get(fieldid_str)->getData(data);
1031      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1032      data_tmp = data;
1033
1034      CTimer::get("XIOS recv field").suspend();
1035      CTimer::get("XIOS").suspend();
1036    }
1037} // extern "C"
Note: See TracBrowser for help on using the repository browser.