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

Last change on this file since 1037 was 1037, checked in by yushan, 4 years ago

initialize the branch

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