source: XIOS/dev/branch_yushan_merged/src/interface/c/icdata.cpp @ 1205

Last change on this file since 1205 was 1205, checked in by yushan, 7 years ago

branch merged with trunk @1200
  • 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: 38.0 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_std.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      ep_lib::MPI_Comm local_comm;
58      ep_lib::MPI_Comm return_comm;
59     
60      ep_lib::fc_comm_map.clear();
61
62      if (!cstr2string(client_id, len_client_id, str)) return;
63
64      int initialized;
65      MPI_Initialized(&initialized);
66
67      #ifdef _usingEP
68      if (initialized) local_comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_local_comm));
69      else local_comm = MPI_COMM_NULL;
70      #else
71      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
72      else local_comm = MPI_COMM_NULL;
73      #endif
74     
75     
76
77      CXios::initClientSide(str, local_comm, return_comm);
78
79      #ifdef _usingEP
80      *f_return_comm = ep_lib::EP_Comm_c2f(return_comm);
81      #else
82      *f_return_comm = MPI_Comm_c2f(return_comm);
83      #endif
84
85      CTimer::get("XIOS init").suspend();
86      CTimer::get("XIOS").suspend();
87   }
88
89   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
90   {
91     std::string str;
92     ep_lib::MPI_Comm comm;
93
94     if (!cstr2string(context_id, len_context_id, str)) return;
95     CTimer::get("XIOS").resume();
96     CTimer::get("XIOS init context").resume();
97     comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_comm));
98
99     CClient::registerContext(str,comm);
100         
101     CTimer::get("XIOS init context").suspend();
102     CTimer::get("XIOS").suspend();
103   }
104
105   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
106   {
107     std::string str;
108
109     if (!cstr2string(context_id, len_context_id, str)) return;
110     CTimer::get("XIOS").resume();
111     CContext* context = CContext::get(str, str);
112     *initialized=context->isInitialized();
113     CTimer::get("XIOS").suspend();
114   }
115
116    void cxios_context_close_definition()
117   {
118     CTimer::get("XIOS").resume();
119     CTimer::get("XIOS close definition").resume();
120     CContext* context = CContext::getCurrent();
121     context->closeDefinition();
122     CTimer::get("XIOS close definition").suspend();
123     CTimer::get("XIOS").suspend();
124   }
125
126   void cxios_context_finalize()
127   {
128     CTimer::get("XIOS").resume();
129     CTimer::get("XIOS context finalize").resume();
130     CContext* context = CContext::getCurrent();
131     context->finalize();
132     CTimer::get("XIOS context finalize").suspend();
133     CTimer::get("XIOS").suspend();
134   }
135
136   void cxios_finalize()
137   {
138     CTimer::get("XIOS").resume();
139     CTimer::get("XIOS finalize").resume();
140     CXios::clientFinalize();
141   }
142
143   void cxios_solve_inheritance()
144   {
145     CTimer::get("XIOS").resume();
146     CContext* context = CContext::getCurrent();
147     context->solveAllInheritance(false);
148     CTimer::get("XIOS").suspend();
149   }
150
151   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
152    *
153    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
154    * from a Fortran one, for example the value of a variable with id = "using_server".
155    * Each function corresponds to each basic type.
156    * \param varId        [in] id of the variable that we'd like to get
157    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
158    * \param dataInt      [in/out] the retrieved data
159    * \param isVarExisted [in/out] Verify whether variable with varId exists
160   */
161   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
162   {
163      std::string varIdStr;
164      if (!cstr2string(varId, varIdSize, varIdStr)) return;
165
166      CTimer::get("XIOS").resume();
167      CTimer::get("XIOS get variable data").resume();
168
169      CContext* context = CContext::getCurrent();
170      *isVarExisted = CVariable::has(context->getId(), varIdStr);
171
172      if (*isVarExisted)
173      {
174        *data = CVariable::get(context->getId(), varIdStr)->getData<double>();
175      }
176
177      CTimer::get("XIOS get variable data").suspend();
178      CTimer::get("XIOS").suspend();
179   }
180
181   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
182   {
183      std::string varIdStr;
184      if (!cstr2string(varId, varIdSize, varIdStr)) return;
185
186      CTimer::get("XIOS").resume();
187      CTimer::get("XIOS get variable data").resume();
188
189      CContext* context = CContext::getCurrent();
190      *isVarExisted = CVariable::has(context->getId(), varIdStr);
191
192      if (*isVarExisted)
193      {
194        *data = CVariable::get(context->getId(), varIdStr)->getData<float>();
195      }
196
197      CTimer::get("XIOS get variable data").suspend();
198      CTimer::get("XIOS").suspend();
199   }
200
201   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
202   {
203      std::string varIdStr;
204      if (!cstr2string(varId, varIdSize, varIdStr)) return;
205
206      CTimer::get("XIOS").resume();
207      CTimer::get("XIOS get variable data").resume();
208
209      CContext* context = CContext::getCurrent();
210      *isVarExisted = CVariable::has(context->getId(), varIdStr);
211
212      if (*isVarExisted)
213      {
214        *data = CVariable::get(context->getId(), varIdStr)->getData<int>();
215      }
216
217      CTimer::get("XIOS get variable data").suspend();
218      CTimer::get("XIOS").suspend();
219   }
220
221   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
222   {
223      std::string varIdStr;
224      if (!cstr2string(varId, varIdSize, varIdStr)) return;
225
226      CTimer::get("XIOS").resume();
227      CTimer::get("XIOS get variable data").resume();
228
229      CContext* context = CContext::getCurrent();
230      *isVarExisted = CVariable::has(context->getId(), varIdStr);
231
232      if (*isVarExisted)
233      {
234        *data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
235      }
236
237      CTimer::get("XIOS get variable data").suspend();
238      CTimer::get("XIOS").suspend();
239   }
240
241   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
242   {
243      std::string varIdStr;
244      if (!cstr2string(varId, varIdSize, varIdStr)) return;
245
246      CTimer::get("XIOS").resume();
247      CTimer::get("XIOS get variable data").resume();
248
249      CContext* context = CContext::getCurrent();
250      *isVarExisted = CVariable::has(context->getId(), varIdStr);
251
252      if (*isVarExisted)
253      {
254        int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
255        strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
256      }
257
258      CTimer::get("XIOS get variable data").suspend();
259      CTimer::get("XIOS").suspend();
260   }
261
262   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
263    *
264    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
265    * from a Fortran one, for example the value of a variable with id = "using_server".
266    * Each function corresponds to each basic type.
267    * \param varId        [in] id of the variable that we'd like to get
268    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
269    * \param data         [in] the input data
270    * \param isVarExisted [in/out] Verify whether variable with varId exists
271   */
272   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted)
273   {
274      std::string varIdStr;
275      if (!cstr2string(varId, varIdSize, varIdStr)) return;
276
277      CTimer::get("XIOS").resume();
278      CTimer::get("XIOS set variable data").resume();
279
280      CContext* context = CContext::getCurrent();
281      *isVarExisted = CVariable::has(context->getId(), varIdStr);
282
283      if (*isVarExisted)
284      {
285        CVariable::get(context->getId(), varIdStr)->setData<double>(data);
286        //CVariable::get(context->getId(), varIdStr)->sendValue();
287      }
288
289      CTimer::get("XIOS set variable data").suspend();
290      CTimer::get("XIOS").suspend();
291   }
292
293   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted)
294   {
295      std::string varIdStr;
296      if (!cstr2string(varId, varIdSize, varIdStr)) return;
297
298      CTimer::get("XIOS").resume();
299      CTimer::get("XIOS set variable data").resume();
300
301      CContext* context = CContext::getCurrent();
302      *isVarExisted = CVariable::has(context->getId(), varIdStr);
303
304      if (*isVarExisted)
305      {
306        CVariable::get(context->getId(), varIdStr)->setData<float>(data);
307        //CVariable::get(context->getId(), varIdStr)->sendValue();
308      }
309
310      CTimer::get("XIOS set variable data").suspend();
311      CTimer::get("XIOS").suspend();
312   }
313
314   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
315   {
316      std::string varIdStr;
317      if (!cstr2string(varId, varIdSize, varIdStr)) return;
318
319      CTimer::get("XIOS").resume();
320      CTimer::get("XIOS set variable data").resume();
321
322      CContext* context = CContext::getCurrent();
323      *isVarExisted = CVariable::has(context->getId(), varIdStr);
324
325      if (*isVarExisted)
326      {
327        CVariable::get(context->getId(), varIdStr)->setData<int>(data);
328        //CVariable::get(context->getId(), varIdStr)->sendValue();
329      }
330
331
332      CTimer::get("XIOS set variable data").suspend();
333      CTimer::get("XIOS").suspend();
334   }
335
336   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
337   {
338      std::string varIdStr;
339      if (!cstr2string(varId, varIdSize, varIdStr)) return;
340
341      CTimer::get("XIOS").resume();
342      CTimer::get("XIOS set variable data").resume();
343
344      CContext* context = CContext::getCurrent();
345      *isVarExisted = CVariable::has(context->getId(), varIdStr);
346
347      if (*isVarExisted)
348      {
349        CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
350        //CVariable::get(context->getId(), varIdStr)->sendValue();
351      }
352
353      CTimer::get("XIOS set variable data").suspend();
354      CTimer::get("XIOS").suspend();
355   }
356
357   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
358   {
359      std::string varIdStr, dataStr;
360      if (!cstr2string(varId, varIdSize, varIdStr)) return;
361      if (!cstr2string(data, dataSizeIn, dataStr))
362      {
363        *isVarExisted = false;
364        return;
365      }
366
367      CTimer::get("XIOS").resume();
368      CTimer::get("XIOS set variable data").resume();
369
370      CContext* context = CContext::getCurrent();
371      *isVarExisted = CVariable::has(context->getId(), varIdStr);
372
373      if (*isVarExisted)
374      {
375        CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
376        //CVariable::get(context->getId(), varIdStr)->sendValue();
377      }
378
379      CTimer::get("XIOS set variable data").suspend();
380      CTimer::get("XIOS").suspend();
381   }
382
383
384   // ---------------------- Ecriture des données ------------------------------
385
386   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
387   {
388      std::string fieldid_str;
389      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
390
391      CTimer::get("XIOS").resume();
392      CTimer::get("XIOS send field").resume();
393      CContext* context = CContext::getCurrent();
394      if (!context->hasServer && !context->client->isAttachedModeEnabled())
395        context->checkBuffersAndListen();
396      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
397      CField::get(fieldid_str)->setData(data);
398      CTimer::get("XIOS send field").suspend();
399      CTimer::get("XIOS").suspend();
400   }
401
402   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
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, 1> data(data_k8, shape(data_Xsize), 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_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
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, 2>data(data_k8, shape(data_Xsize, data_Ysize), 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_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
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      {
451        context->checkBuffersAndListen();
452      } 
453
454      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
455      CField::get(fieldid_str)->setData(data);
456
457      CTimer::get("XIOS send field").suspend();
458      CTimer::get("XIOS").suspend();
459   }
460
461   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)
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, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), 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_k85(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)
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, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), 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_k86(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   {
505      std::string fieldid_str;
506      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
507
508      CTimer::get("XIOS").resume();
509      CTimer::get("XIOS send field").resume();
510
511      CContext* context = CContext::getCurrent();
512      if (!context->hasServer && !context->client->isAttachedModeEnabled())
513        context->checkBuffersAndListen();
514
515      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
516      CField::get(fieldid_str)->setData(data);
517
518      CTimer::get("XIOS send field").suspend();
519      CTimer::get("XIOS").suspend();
520   }
521
522   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
523                             int data_0size, int data_1size, int data_2size,
524                             int data_3size, int data_4size, int data_5size,
525                             int data_6size)
526   {
527      std::string fieldid_str;
528      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
529
530      CTimer::get("XIOS").resume();
531      CTimer::get("XIOS send field").resume();
532
533      CContext* context = CContext::getCurrent();
534      if (!context->hasServer && !context->client->isAttachedModeEnabled())
535        context->checkBuffersAndListen();
536
537      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
538      CField::get(fieldid_str)->setData(data);
539
540      CTimer::get("XIOS send field").suspend();
541      CTimer::get("XIOS").suspend();
542   }
543
544   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
545   {
546      std::string fieldid_str;
547      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
548
549      CTimer::get("XIOS").resume();
550      CTimer::get("XIOS send field").resume();
551      CContext* context = CContext::getCurrent();
552      if (!context->hasServer && !context->client->isAttachedModeEnabled())
553        context->checkBuffersAndListen();
554
555      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
556      CArray<double, 1> data(data_Xsize) ;
557      data = data_tmp;
558      CField::get(fieldid_str)->setData(data);
559      CTimer::get("XIOS send field").suspend();
560      CTimer::get("XIOS").suspend();
561   }
562
563   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
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, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
576      CArray<double, 1> data(data_Xsize);
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_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
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, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
597      CArray<double, 2> data(data_Xsize, data_Ysize);
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_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
606   {
607      std::string fieldid_str;
608      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
609
610      CTimer::get("XIOS").resume();
611      CTimer::get("XIOS send field").resume();
612
613      CContext* context = CContext::getCurrent();
614      if (!context->hasServer && !context->client->isAttachedModeEnabled())
615        context->checkBuffersAndListen();
616
617      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
618      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
619      data = data_tmp;
620      CField::get(fieldid_str)->setData(data);
621
622      CTimer::get("XIOS send field").suspend();
623      CTimer::get("XIOS").suspend();
624    }
625
626   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
627                             int data_0size, int data_1size, int data_2size,
628                             int data_3size)
629   {
630      std::string fieldid_str;
631      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
632
633      CTimer::get("XIOS").resume();
634      CTimer::get("XIOS send field").resume();
635
636      CContext* context = CContext::getCurrent();
637      if (!context->hasServer && !context->client->isAttachedModeEnabled())
638        context->checkBuffersAndListen();
639
640      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
641      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
642      data = data_tmp;
643      CField::get(fieldid_str)->setData(data);
644
645      CTimer::get("XIOS send field").suspend();
646      CTimer::get("XIOS").suspend();
647    }
648
649   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
650                             int data_0size, int data_1size, int data_2size,
651                             int data_3size, int data_4size)
652   {
653      std::string fieldid_str;
654      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
655
656      CTimer::get("XIOS").resume();
657      CTimer::get("XIOS send field").resume();
658
659      CContext* context = CContext::getCurrent();
660      if (!context->hasServer && !context->client->isAttachedModeEnabled())
661        context->checkBuffersAndListen();
662
663      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
664      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
665      data = data_tmp;
666      CField::get(fieldid_str)->setData(data);
667
668      CTimer::get("XIOS send field").suspend();
669      CTimer::get("XIOS").suspend();
670    }
671
672   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
673                             int data_0size, int data_1size, int data_2size,
674                             int data_3size, int data_4size, int data_5size)
675   {
676      std::string fieldid_str;
677      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
678
679      CTimer::get("XIOS").resume();
680      CTimer::get("XIOS send field").resume();
681
682      CContext* context = CContext::getCurrent();
683      if (!context->hasServer && !context->client->isAttachedModeEnabled())
684        context->checkBuffersAndListen();
685
686      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
687      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
688      data = data_tmp;
689      CField::get(fieldid_str)->setData(data);
690
691      CTimer::get("XIOS send field").suspend();
692      CTimer::get("XIOS").suspend();
693    }
694
695   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
696                             int data_0size, int data_1size, int data_2size,
697                             int data_3size, int data_4size, int data_5size,
698                             int data_6size)
699   {
700      std::string fieldid_str;
701      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
702
703      CTimer::get("XIOS").resume();
704      CTimer::get("XIOS send field").resume();
705
706      CContext* context = CContext::getCurrent();
707      if (!context->hasServer && !context->client->isAttachedModeEnabled())
708        context->checkBuffersAndListen();
709
710      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
711      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
712      data = data_tmp;
713      CField::get(fieldid_str)->setData(data);
714
715      CTimer::get("XIOS send field").suspend();
716      CTimer::get("XIOS").suspend();
717    }
718
719   // ---------------------- Lecture des données ------------------------------
720
721   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
722   {
723      std::string fieldid_str;
724      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
725
726      CTimer::get("XIOS").resume();
727      CTimer::get("XIOS recv field").resume();
728
729      CContext* context = CContext::getCurrent();
730      if (!context->hasServer && !context->client->isAttachedModeEnabled())
731        context->checkBuffersAndListen();
732
733      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
734      CField::get(fieldid_str)->getData(data);
735
736      CTimer::get("XIOS recv field").suspend();
737      CTimer::get("XIOS").suspend();
738   }
739
740   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
741   {
742      std::string fieldid_str;
743      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
744
745      CTimer::get("XIOS").resume();
746      CTimer::get("XIOS recv field").resume();
747
748      CContext* context = CContext::getCurrent();
749      if (!context->hasServer && !context->client->isAttachedModeEnabled())
750        context->checkBuffersAndListen();
751
752      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
753      CField::get(fieldid_str)->getData(data);
754
755      CTimer::get("XIOS recv field").suspend();
756      CTimer::get("XIOS").suspend();
757   }
758
759   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
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, 2>data(data_k8, shape(data_Xsize, data_Ysize), 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_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
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, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), 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_k84(const char* fieldid, int fieldid_size, double* data_k8,
798                            int data_0size, int data_1size, int data_2size,
799                            int data_3size)
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, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), 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_k85(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)
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, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), 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_k86(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   {
843      std::string fieldid_str;
844      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
845
846      CTimer::get("XIOS").resume();
847      CTimer::get("XIOS recv field").resume();
848
849      CContext* context = CContext::getCurrent();
850      if (!context->hasServer && !context->client->isAttachedModeEnabled())
851        context->checkBuffersAndListen();
852
853      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
854      CField::get(fieldid_str)->getData(data);
855
856      CTimer::get("XIOS recv field").suspend();
857      CTimer::get("XIOS").suspend();
858   }
859
860   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
861                            int data_0size, int data_1size, int data_2size,
862                            int data_3size, int data_4size, int data_5size,
863                            int data_6size)
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, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
876      CField::get(fieldid_str)->getData(data);
877
878      CTimer::get("XIOS recv field").suspend();
879      CTimer::get("XIOS").suspend();
880   }
881
882   void cxios_read_data_k40(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_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
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, 1> data(data_Xsize);
916      CField::get(fieldid_str)->getData(data);
917      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), 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_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
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, 2> data(data_Xsize, data_Ysize);
937      CField::get(fieldid_str)->getData(data);
938      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), 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_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
946   {
947      std::string fieldid_str;
948      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
949
950      CTimer::get("XIOS").resume();
951      CTimer::get("XIOS recv field").resume();
952
953      CContext* context = CContext::getCurrent();
954      if (!context->hasServer && !context->client->isAttachedModeEnabled())
955        context->checkBuffersAndListen();
956
957      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
958      CField::get(fieldid_str)->getData(data);
959      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
960      data_tmp = data;
961
962      CTimer::get("XIOS recv field").suspend();
963      CTimer::get("XIOS").suspend();
964    }
965
966   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
967                            int data_0size, int data_1size, int data_2size,
968                            int data_3size)
969   {
970      std::string fieldid_str;
971      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
972
973      CTimer::get("XIOS").resume();
974      CTimer::get("XIOS recv field").resume();
975
976      CContext* context = CContext::getCurrent();
977      if (!context->hasServer && !context->client->isAttachedModeEnabled())
978        context->checkBuffersAndListen();
979
980      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
981      CField::get(fieldid_str)->getData(data);
982      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
983      data_tmp = data;
984
985      CTimer::get("XIOS recv field").suspend();
986      CTimer::get("XIOS").suspend();
987    }
988
989   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
990                            int data_0size, int data_1size, int data_2size,
991                            int data_3size, int data_4size)
992   {
993      std::string fieldid_str;
994      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
995
996      CTimer::get("XIOS").resume();
997      CTimer::get("XIOS recv field").resume();
998
999      CContext* context = CContext::getCurrent();
1000      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1001        context->checkBuffersAndListen();
1002
1003      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1004      CField::get(fieldid_str)->getData(data);
1005      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1006      data_tmp = data;
1007
1008      CTimer::get("XIOS recv field").suspend();
1009      CTimer::get("XIOS").suspend();
1010    }
1011
1012   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
1013                            int data_0size, int data_1size, int data_2size,
1014                            int data_3size, int data_4size, int data_5size)
1015   {
1016      std::string fieldid_str;
1017      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1018
1019      CTimer::get("XIOS").resume();
1020      CTimer::get("XIOS recv field").resume();
1021
1022      CContext* context = CContext::getCurrent();
1023      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1024        context->checkBuffersAndListen();
1025
1026      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1027      CField::get(fieldid_str)->getData(data);
1028      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1029      data_tmp = data;
1030
1031      CTimer::get("XIOS recv field").suspend();
1032      CTimer::get("XIOS").suspend();
1033    }
1034
1035   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1036                            int data_0size, int data_1size, int data_2size,
1037                            int data_3size, int data_4size, int data_5size,
1038                            int data_6size)
1039   {
1040      std::string fieldid_str;
1041      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1042
1043      CTimer::get("XIOS").resume();
1044      CTimer::get("XIOS recv field").resume();
1045
1046      CContext* context = CContext::getCurrent();
1047      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1048        context->checkBuffersAndListen();
1049
1050      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1051      CField::get(fieldid_str)->getData(data);
1052      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1053      data_tmp = data;
1054
1055      CTimer::get("XIOS recv field").suspend();
1056      CTimer::get("XIOS").suspend();
1057    }
1058} // extern "C"
Note: See TracBrowser for help on using the repository browser.