source: XIOS/dev/dev_trunk_omp/src/interface/c/icdata.cpp @ 1605

Last change on this file since 1605 was 1605, checked in by yushan, 5 years ago

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