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

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

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