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

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

Backporting recent changes to dev before merging it to trunk.

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