source: XIOS/dev/branch_yushan/src/interface/c/icdata.cpp @ 1068

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

minor modification for using intelmpi

  • 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.2 KB
Line 
1/* ************************************************************************** *
2 *      Copyright  IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include <string>
8#include <cstring>
9#include <iostream>
10
11
12#include "xios.hpp"
13//#include "oasis_cinterface.hpp"
14
15#include "attribute_template.hpp"
16#include "object_template.hpp"
17#include "group_template.hpp"
18
19#include "icutil.hpp"
20#include "cxios.hpp"
21#include "client.hpp"
22#include "field.hpp"
23#include "context.hpp"
24#include "context_client.hpp"
25#include "mpi_std.hpp"
26#include "timer.hpp"
27#include "array_new.hpp"
28
29extern "C"
30{
31// /////////////////////////////// Dfinitions ////////////////////////////// //
32
33   // ----------------------- Redfinition de types ----------------------------
34
35   typedef enum { NETCDF4 = 0 } XFileType;
36
37   typedef xios::CContext* XContextPtr;
38
39   // -------------------- Traitement des donnes ------------------------------
40
41   // This function is not exported to the public Fortran interface,
42   // it is only used from the parse_xml.exe standalone test tool.
43   void cxios_init(void)
44   {
45     CXios::initialize();
46   }
47
48   void cxios_init_server(void)
49   {
50     CXios::initServerSide();
51   }
52
53   void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
54   {
55      std::string str;
56      ep_lib::MPI_Comm local_comm;
57      ep_lib::MPI_Comm return_comm;
58     
59      ep_lib::fc_comm_map.clear();
60
61      if (!cstr2string(client_id, len_client_id, str)) return;
62
63      int initialized;
64      MPI_Initialized(&initialized);
65
66      #ifdef _usingEP
67      if (initialized) local_comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_local_comm));
68      else local_comm = MPI_COMM_NULL;
69      #else
70      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
71      else local_comm = MPI_COMM_NULL;
72      #endif
73     
74
75      CXios::initClientSide(str, local_comm, return_comm);
76
77      #ifdef _usingEP
78      *f_return_comm = ep_lib::EP_Comm_c2f(return_comm);
79      #else
80      *f_return_comm = MPI_Comm_c2f(return_comm);
81      #endif
82
83      CTimer::get("XIOS init").suspend();
84      CTimer::get("XIOS").suspend();
85   }
86
87   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
88   {
89     std::string str;
90     ep_lib::MPI_Comm comm;
91
92     if (!cstr2string(context_id, len_context_id, str)) return;
93     CTimer::get("XIOS").resume();
94     CTimer::get("XIOS init context").resume();
95     comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_comm));
96
97   
98     CClient::registerContext(str,comm);
99     
100     //printf("icdata.cpp: client register context %s : %p\n", context_id, &comm);
101     
102     CTimer::get("XIOS init context").suspend();
103     CTimer::get("XIOS").suspend();
104   }
105
106   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
107   {
108     std::string str;
109
110     if (!cstr2string(context_id, len_context_id, str)) return;
111     CTimer::get("XIOS").resume();
112     CContext* context = CContext::get(str, str);
113     *initialized=context->isInitialized();
114     CTimer::get("XIOS").suspend();
115   }
116
117    void cxios_context_close_definition()
118   {
119     CTimer::get("XIOS").resume();
120     CTimer::get("XIOS close definition").resume();
121     CContext* context = CContext::getCurrent();
122     
123     context->closeDefinition();
124     
125     CTimer::get("XIOS close definition").suspend();
126     CTimer::get("XIOS").suspend();
127   }
128
129   void cxios_context_finalize()
130   {
131     CTimer::get("XIOS").resume();
132     CTimer::get("XIOS context finalize").resume();
133     
134     
135     
136     CContext* context = CContext::getCurrent();
137     context->finalize();
138     
139     printf("client context_finalize OK\n");
140     
141     CTimer::get("XIOS context finalize").suspend();
142     CTimer::get("XIOS").suspend();
143   }
144
145   void cxios_finalize()
146   {
147     CTimer::get("XIOS").resume();
148     CTimer::get("XIOS finalize").resume();
149     CXios::clientFinalize();
150   }
151
152   void cxios_solve_inheritance()
153   {
154     CTimer::get("XIOS").resume();
155     CContext* context = CContext::getCurrent();
156     context->solveAllInheritance(false);
157     CTimer::get("XIOS").suspend();
158   }
159
160   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
161    *
162    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
163    * from a Fortran one, for example the value of a variable with id = "using_server".
164    * Each function corresponds to each basic type.
165    * \param varId        [in] id of the variable that we'd like to get
166    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
167    * \param dataInt      [in/out] the retrieved data
168    * \param isVarExisted [in/out] Verify whether variable with varId exists
169   */
170   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted)
171   {
172      std::string varIdStr;
173      if (!cstr2string(varId, varIdSize, varIdStr)) return;
174
175      CTimer::get("XIOS").resume();
176      CTimer::get("XIOS get variable data").resume();
177
178      CContext* context = CContext::getCurrent();
179      *isVarExisted = CVariable::has(context->getId(), varIdStr);
180
181      if (*isVarExisted)
182      {
183        *data = CVariable::get(context->getId(), varIdStr)->getData<double>();
184      }
185
186      CTimer::get("XIOS get variable data").suspend();
187      CTimer::get("XIOS").suspend();
188   }
189
190   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted)
191   {
192      std::string varIdStr;
193      if (!cstr2string(varId, varIdSize, varIdStr)) return;
194
195      CTimer::get("XIOS").resume();
196      CTimer::get("XIOS get variable data").resume();
197
198      CContext* context = CContext::getCurrent();
199      *isVarExisted = CVariable::has(context->getId(), varIdStr);
200
201      if (*isVarExisted)
202      {
203        *data = CVariable::get(context->getId(), varIdStr)->getData<float>();
204      }
205
206      CTimer::get("XIOS get variable data").suspend();
207      CTimer::get("XIOS").suspend();
208   }
209
210   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted)
211   {
212      std::string varIdStr;
213      if (!cstr2string(varId, varIdSize, varIdStr)) return;
214
215      CTimer::get("XIOS").resume();
216      CTimer::get("XIOS get variable data").resume();
217
218      CContext* context = CContext::getCurrent();
219      *isVarExisted = CVariable::has(context->getId(), varIdStr);
220
221      if (*isVarExisted)
222      {
223        *data = CVariable::get(context->getId(), varIdStr)->getData<int>();
224      }
225
226      CTimer::get("XIOS get variable data").suspend();
227      CTimer::get("XIOS").suspend();
228   }
229
230   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted)
231   {
232      std::string varIdStr;
233      if (!cstr2string(varId, varIdSize, varIdStr)) return;
234
235      CTimer::get("XIOS").resume();
236      CTimer::get("XIOS get variable data").resume();
237
238      CContext* context = CContext::getCurrent();
239      *isVarExisted = CVariable::has(context->getId(), varIdStr);
240
241      if (*isVarExisted)
242      {
243        *data = CVariable::get(context->getId(), varIdStr)->getData<bool>();
244      }
245
246      CTimer::get("XIOS get variable data").suspend();
247      CTimer::get("XIOS").suspend();
248   }
249
250   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted)
251   {
252      std::string varIdStr;
253      if (!cstr2string(varId, varIdSize, varIdStr)) return;
254
255      CTimer::get("XIOS").resume();
256      CTimer::get("XIOS get variable data").resume();
257
258      CContext* context = CContext::getCurrent();
259      *isVarExisted = CVariable::has(context->getId(), varIdStr);
260
261      if (*isVarExisted)
262      {
263        int dataSizeOut = CVariable::get(context->getId(), varIdStr)->getData<string>().length();
264        strncpy(data, CVariable::get(context->getId(), varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
265      }
266
267      CTimer::get("XIOS get variable data").suspend();
268      CTimer::get("XIOS").suspend();
269   }
270
271   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
272    *
273    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
274    * from a Fortran one, for example the value of a variable with id = "using_server".
275    * Each function corresponds to each basic type.
276    * \param varId        [in] id of the variable that we'd like to get
277    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
278    * \param data         [in] the input data
279    * \param isVarExisted [in/out] Verify whether variable with varId exists
280   */
281   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double 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<double>(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_k4(const char* varId, int varIdSize, float 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<float>(data);
316        //CVariable::get(context->getId(), varIdStr)->sendValue();
317      }
318
319      CTimer::get("XIOS set variable data").suspend();
320      CTimer::get("XIOS").suspend();
321   }
322
323   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted)
324   {
325      std::string varIdStr;
326      if (!cstr2string(varId, varIdSize, varIdStr)) return;
327
328      CTimer::get("XIOS").resume();
329      CTimer::get("XIOS set variable data").resume();
330
331      CContext* context = CContext::getCurrent();
332      *isVarExisted = CVariable::has(context->getId(), varIdStr);
333
334      if (*isVarExisted)
335      {
336        CVariable::get(context->getId(), varIdStr)->setData<int>(data);
337        //CVariable::get(context->getId(), varIdStr)->sendValue();
338      }
339
340
341      CTimer::get("XIOS set variable data").suspend();
342      CTimer::get("XIOS").suspend();
343   }
344
345   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted)
346   {
347      std::string varIdStr;
348      if (!cstr2string(varId, varIdSize, varIdStr)) return;
349
350      CTimer::get("XIOS").resume();
351      CTimer::get("XIOS set variable data").resume();
352
353      CContext* context = CContext::getCurrent();
354      *isVarExisted = CVariable::has(context->getId(), varIdStr);
355
356      if (*isVarExisted)
357      {
358        CVariable::get(context->getId(), varIdStr)->setData<bool>(data);
359        //CVariable::get(context->getId(), varIdStr)->sendValue();
360      }
361
362      CTimer::get("XIOS set variable data").suspend();
363      CTimer::get("XIOS").suspend();
364   }
365
366   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted)
367   {
368      std::string varIdStr, dataStr;
369      if (!cstr2string(varId, varIdSize, varIdStr)) return;
370      if (!cstr2string(data, dataSizeIn, dataStr))
371      {
372        *isVarExisted = false;
373        return;
374      }
375
376      CTimer::get("XIOS").resume();
377      CTimer::get("XIOS set variable data").resume();
378
379      CContext* context = CContext::getCurrent();
380      *isVarExisted = CVariable::has(context->getId(), varIdStr);
381
382      if (*isVarExisted)
383      {
384        CVariable::get(context->getId(), varIdStr)->setData<string>(dataStr);
385        //CVariable::get(context->getId(), varIdStr)->sendValue();
386      }
387
388      CTimer::get("XIOS set variable data").suspend();
389      CTimer::get("XIOS").suspend();
390   }
391
392
393   // ---------------------- Ecriture des donnes ------------------------------
394
395   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
396   {
397      std::string fieldid_str;
398      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
399
400      CTimer::get("XIOS").resume();
401      CTimer::get("XIOS send field").resume();
402      CContext* context = CContext::getCurrent();
403      if (!context->hasServer && !context->client->isAttachedModeEnabled())
404        context->checkBuffersAndListen();
405      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
406      CField::get(fieldid_str)->setData(data);
407      CTimer::get("XIOS send field").suspend();
408      CTimer::get("XIOS").suspend();
409   }
410
411   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
412   {
413      std::string fieldid_str;
414      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
415
416      CTimer::get("XIOS").resume();
417      CTimer::get("XIOS send field").resume();
418
419      CContext* context = CContext::getCurrent();
420      if (!context->hasServer && !context->client->isAttachedModeEnabled())
421        context->checkBuffersAndListen();
422
423      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
424      CField::get(fieldid_str)->setData(data);
425
426      CTimer::get("XIOS send field").suspend();
427      CTimer::get("XIOS").suspend();
428   }
429
430   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
431   {
432      std::string fieldid_str;
433      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
434
435      CTimer::get("XIOS").resume();
436      CTimer::get("XIOS send field").resume();
437
438      CContext* context = CContext::getCurrent();
439      if (!context->hasServer && !context->client->isAttachedModeEnabled())
440        context->checkBuffersAndListen();
441
442      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
443      CField::get(fieldid_str)->setData(data);
444
445      CTimer::get("XIOS send field").suspend();
446      CTimer::get("XIOS").suspend();
447   }
448
449   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
450   {
451      std::string fieldid_str;
452      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
453
454      CTimer::get("XIOS").resume();
455      CTimer::get("XIOS send field").resume();
456
457      CContext* context = CContext::getCurrent();
458      if (!context->hasServer && !context->client->isAttachedModeEnabled())
459      {
460        context->checkBuffersAndListen();
461      } 
462
463      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
464      CField::get(fieldid_str)->setData(data);
465
466      CTimer::get("XIOS send field").suspend();
467      CTimer::get("XIOS").suspend();
468   }
469
470   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)
471   {
472      std::string fieldid_str;
473      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
474
475      CTimer::get("XIOS").resume();
476      CTimer::get("XIOS send field").resume();
477
478      CContext* context = CContext::getCurrent();
479      if (!context->hasServer && !context->client->isAttachedModeEnabled())
480        context->checkBuffersAndListen();
481
482      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
483      CField::get(fieldid_str)->setData(data);
484
485      CTimer::get("XIOS send field").suspend();
486      CTimer::get("XIOS").suspend();
487   }
488
489   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
490                             int data_0size, int data_1size, int data_2size,
491                             int data_3size, int data_4size)
492   {
493      std::string fieldid_str;
494      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
495
496      CTimer::get("XIOS").resume();
497      CTimer::get("XIOS send field").resume();
498
499      CContext* context = CContext::getCurrent();
500      if (!context->hasServer && !context->client->isAttachedModeEnabled())
501        context->checkBuffersAndListen();
502
503      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
504      CField::get(fieldid_str)->setData(data);
505
506      CTimer::get("XIOS send field").suspend();
507      CTimer::get("XIOS").suspend();
508   }
509
510   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
511                             int data_0size, int data_1size, int data_2size,
512                             int data_3size, int data_4size, int data_5size)
513   {
514      std::string fieldid_str;
515      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
516
517      CTimer::get("XIOS").resume();
518      CTimer::get("XIOS send field").resume();
519
520      CContext* context = CContext::getCurrent();
521      if (!context->hasServer && !context->client->isAttachedModeEnabled())
522        context->checkBuffersAndListen();
523
524      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
525      CField::get(fieldid_str)->setData(data);
526
527      CTimer::get("XIOS send field").suspend();
528      CTimer::get("XIOS").suspend();
529   }
530
531   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
532                             int data_0size, int data_1size, int data_2size,
533                             int data_3size, int data_4size, int data_5size,
534                             int data_6size)
535   {
536      std::string fieldid_str;
537      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
538
539      CTimer::get("XIOS").resume();
540      CTimer::get("XIOS send field").resume();
541
542      CContext* context = CContext::getCurrent();
543      if (!context->hasServer && !context->client->isAttachedModeEnabled())
544        context->checkBuffersAndListen();
545
546      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
547      CField::get(fieldid_str)->setData(data);
548
549      CTimer::get("XIOS send field").suspend();
550      CTimer::get("XIOS").suspend();
551   }
552
553   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
554   {
555      std::string fieldid_str;
556      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
557
558      CTimer::get("XIOS").resume();
559      CTimer::get("XIOS send field").resume();
560      CContext* context = CContext::getCurrent();
561      if (!context->hasServer && !context->client->isAttachedModeEnabled())
562        context->checkBuffersAndListen();
563
564      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
565      CArray<double, 1> data(data_Xsize) ;
566      data = data_tmp;
567      CField::get(fieldid_str)->setData(data);
568      CTimer::get("XIOS send field").suspend();
569      CTimer::get("XIOS").suspend();
570   }
571
572   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
573   {
574      std::string fieldid_str;
575      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
576
577      CTimer::get("XIOS").resume();
578      CTimer::get("XIOS send field").resume();
579
580      CContext* context = CContext::getCurrent();
581      if (!context->hasServer && !context->client->isAttachedModeEnabled())
582        context->checkBuffersAndListen();
583
584      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
585      CArray<double, 1> data(data_Xsize);
586      data = data_tmp;
587      CField::get(fieldid_str)->setData(data);
588
589      CTimer::get("XIOS send field").suspend();
590      CTimer::get("XIOS").suspend();
591   }
592
593   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
594   {
595      std::string fieldid_str;
596      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
597
598      CTimer::get("XIOS").resume();
599      CTimer::get("XIOS send field").resume();
600
601      CContext* context = CContext::getCurrent();
602      if (!context->hasServer && !context->client->isAttachedModeEnabled())
603        context->checkBuffersAndListen();
604
605      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
606      CArray<double, 2> data(data_Xsize, data_Ysize);
607      data = data_tmp;
608      CField::get(fieldid_str)->setData(data);
609
610      CTimer::get("XIOS send field").suspend();
611      CTimer::get("XIOS").suspend();
612   }
613
614   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
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, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
627      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
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_k44(const char* fieldid, int fieldid_size, float* data_k4,
636                             int data_0size, int data_1size, int data_2size,
637                             int data_3size)
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, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
650      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
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_k45(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)
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, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
673      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
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_k46(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   {
685      std::string fieldid_str;
686      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
687
688      CTimer::get("XIOS").resume();
689      CTimer::get("XIOS send field").resume();
690
691      CContext* context = CContext::getCurrent();
692      if (!context->hasServer && !context->client->isAttachedModeEnabled())
693        context->checkBuffersAndListen();
694
695      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
696      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
697      data = data_tmp;
698      CField::get(fieldid_str)->setData(data);
699
700      CTimer::get("XIOS send field").suspend();
701      CTimer::get("XIOS").suspend();
702    }
703
704   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
705                             int data_0size, int data_1size, int data_2size,
706                             int data_3size, int data_4size, int data_5size,
707                             int data_6size)
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 send field").resume();
714
715      CContext* context = CContext::getCurrent();
716      if (!context->hasServer && !context->client->isAttachedModeEnabled())
717        context->checkBuffersAndListen();
718
719      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
720      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
721      data = data_tmp;
722      CField::get(fieldid_str)->setData(data);
723
724      CTimer::get("XIOS send field").suspend();
725      CTimer::get("XIOS").suspend();
726    }
727
728   // ---------------------- Lecture des donnes ------------------------------
729
730   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
731   {
732      std::string fieldid_str;
733      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
734
735      CTimer::get("XIOS").resume();
736      CTimer::get("XIOS recv field").resume();
737
738      CContext* context = CContext::getCurrent();
739      if (!context->hasServer && !context->client->isAttachedModeEnabled())
740        context->checkBuffersAndListen();
741
742      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
743      CField::get(fieldid_str)->getData(data);
744
745      CTimer::get("XIOS recv field").suspend();
746      CTimer::get("XIOS").suspend();
747   }
748
749   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
750   {
751      std::string fieldid_str;
752      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
753
754      CTimer::get("XIOS").resume();
755      CTimer::get("XIOS recv field").resume();
756
757      CContext* context = CContext::getCurrent();
758      if (!context->hasServer && !context->client->isAttachedModeEnabled())
759        context->checkBuffersAndListen();
760
761      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
762      CField::get(fieldid_str)->getData(data);
763
764      CTimer::get("XIOS recv field").suspend();
765      CTimer::get("XIOS").suspend();
766   }
767
768   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
769   {
770      std::string fieldid_str;
771      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
772
773      CTimer::get("XIOS").resume();
774      CTimer::get("XIOS recv field").resume();
775
776      CContext* context = CContext::getCurrent();
777      if (!context->hasServer && !context->client->isAttachedModeEnabled())
778        context->checkBuffersAndListen();
779
780      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
781      CField::get(fieldid_str)->getData(data);
782
783      CTimer::get("XIOS recv field").suspend();
784      CTimer::get("XIOS").suspend();
785   }
786
787   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
788   {
789      std::string fieldid_str;
790      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
791
792      CTimer::get("XIOS").resume();
793      CTimer::get("XIOS recv field").resume();
794
795      CContext* context = CContext::getCurrent();
796      if (!context->hasServer && !context->client->isAttachedModeEnabled())
797        context->checkBuffersAndListen();
798
799      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
800      CField::get(fieldid_str)->getData(data);
801
802      CTimer::get("XIOS recv field").suspend();
803      CTimer::get("XIOS").suspend();
804   }
805
806   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
807                            int data_0size, int data_1size, int data_2size,
808                            int data_3size)
809   {
810      std::string fieldid_str;
811      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
812
813      CTimer::get("XIOS").resume();
814      CTimer::get("XIOS recv field").resume();
815
816      CContext* context = CContext::getCurrent();
817      if (!context->hasServer && !context->client->isAttachedModeEnabled())
818        context->checkBuffersAndListen();
819
820      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
821      CField::get(fieldid_str)->getData(data);
822
823      CTimer::get("XIOS recv field").suspend();
824      CTimer::get("XIOS").suspend();
825   }
826
827   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
828                            int data_0size, int data_1size, int data_2size,
829                            int data_3size, int data_4size)
830   {
831      std::string fieldid_str;
832      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
833
834      CTimer::get("XIOS").resume();
835      CTimer::get("XIOS recv field").resume();
836
837      CContext* context = CContext::getCurrent();
838      if (!context->hasServer && !context->client->isAttachedModeEnabled())
839        context->checkBuffersAndListen();
840
841      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
842      CField::get(fieldid_str)->getData(data);
843
844      CTimer::get("XIOS recv field").suspend();
845      CTimer::get("XIOS").suspend();
846   }
847
848   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
849                            int data_0size, int data_1size, int data_2size,
850                            int data_3size, int data_4size, int data_5size)
851   {
852      std::string fieldid_str;
853      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
854
855      CTimer::get("XIOS").resume();
856      CTimer::get("XIOS recv field").resume();
857
858      CContext* context = CContext::getCurrent();
859      if (!context->hasServer && !context->client->isAttachedModeEnabled())
860        context->checkBuffersAndListen();
861
862      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
863      CField::get(fieldid_str)->getData(data);
864
865      CTimer::get("XIOS recv field").suspend();
866      CTimer::get("XIOS").suspend();
867   }
868
869   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
870                            int data_0size, int data_1size, int data_2size,
871                            int data_3size, int data_4size, int data_5size,
872                            int data_6size)
873   {
874      std::string fieldid_str;
875      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
876
877      CTimer::get("XIOS").resume();
878      CTimer::get("XIOS recv field").resume();
879
880      CContext* context = CContext::getCurrent();
881      if (!context->hasServer && !context->client->isAttachedModeEnabled())
882        context->checkBuffersAndListen();
883
884      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
885      CField::get(fieldid_str)->getData(data);
886
887      CTimer::get("XIOS recv field").suspend();
888      CTimer::get("XIOS").suspend();
889   }
890
891   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
892   {
893      std::string fieldid_str;
894      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
895
896      CTimer::get("XIOS").resume();
897      CTimer::get("XIOS recv field").resume();
898
899      CContext* context = CContext::getCurrent();
900      if (!context->hasServer && !context->client->isAttachedModeEnabled())
901        context->checkBuffersAndListen();
902
903      CArray<double, 1> data(data_Xsize);
904      CField::get(fieldid_str)->getData(data);
905      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
906      data_tmp = data;
907
908      CTimer::get("XIOS recv field").suspend();
909      CTimer::get("XIOS").suspend();
910   }
911
912   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
913   {
914      std::string fieldid_str;
915      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
916
917      CTimer::get("XIOS").resume();
918      CTimer::get("XIOS recv field").resume();
919
920      CContext* context = CContext::getCurrent();
921      if (!context->hasServer && !context->client->isAttachedModeEnabled())
922        context->checkBuffersAndListen();
923
924      CArray<double, 1> data(data_Xsize);
925      CField::get(fieldid_str)->getData(data);
926      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
927      data_tmp = data;
928
929      CTimer::get("XIOS recv field").suspend();
930      CTimer::get("XIOS").suspend();
931   }
932
933   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
934   {
935      std::string fieldid_str;
936      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
937
938      CTimer::get("XIOS").resume();
939      CTimer::get("XIOS recv field").resume();
940
941      CContext* context = CContext::getCurrent();
942      if (!context->hasServer && !context->client->isAttachedModeEnabled())
943        context->checkBuffersAndListen();
944
945      CArray<double, 2> data(data_Xsize, data_Ysize);
946      CField::get(fieldid_str)->getData(data);
947      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
948      data_tmp = data;
949
950      CTimer::get("XIOS recv field").suspend();
951      CTimer::get("XIOS").suspend();
952   }
953
954   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
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, 3> data(data_Xsize, data_Ysize, data_Zsize);
967      CField::get(fieldid_str)->getData(data);
968      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), 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_k44(const char* fieldid, int fieldid_size, float* data_k4,
976                            int data_0size, int data_1size, int data_2size,
977                            int data_3size)
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, 4> data(data_0size, data_1size, data_2size, data_3size);
990      CField::get(fieldid_str)->getData(data);
991      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), 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_k45(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)
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, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1013      CField::get(fieldid_str)->getData(data);
1014      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), 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_k46(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   {
1025      std::string fieldid_str;
1026      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1027
1028      CTimer::get("XIOS").resume();
1029      CTimer::get("XIOS recv field").resume();
1030
1031      CContext* context = CContext::getCurrent();
1032      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1033        context->checkBuffersAndListen();
1034
1035      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1036      CField::get(fieldid_str)->getData(data);
1037      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1038      data_tmp = data;
1039
1040      CTimer::get("XIOS recv field").suspend();
1041      CTimer::get("XIOS").suspend();
1042    }
1043
1044   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1045                            int data_0size, int data_1size, int data_2size,
1046                            int data_3size, int data_4size, int data_5size,
1047                            int data_6size)
1048   {
1049      std::string fieldid_str;
1050      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1051
1052      CTimer::get("XIOS").resume();
1053      CTimer::get("XIOS recv field").resume();
1054
1055      CContext* context = CContext::getCurrent();
1056      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1057        context->checkBuffersAndListen();
1058
1059      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1060      CField::get(fieldid_str)->getData(data);
1061      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1062      data_tmp = data;
1063
1064      CTimer::get("XIOS recv field").suspend();
1065      CTimer::get("XIOS").suspend();
1066    }
1067} // extern "C"
Note: See TracBrowser for help on using the repository browser.