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

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

branch merged with trunk r1130
  • 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.1 KB
Line 
1/* ************************************************************************** *
2 *      Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include <string>
8#include <cstring>
9#include <iostream>
10
11
12#include "xios.hpp"
13//#include "oasis_cinterface.hpp"
14
15#include "attribute_template.hpp"
16#include "object_template.hpp"
17#include "group_template.hpp"
18
19#include "icutil.hpp"
20#include "cxios.hpp"
21#include "client.hpp"
22#include "field.hpp"
23#include "context.hpp"
24#include "context_client.hpp"
25#include "mpi_std.hpp"
26#include "timer.hpp"
27#include "array_new.hpp"
28
29
30extern "C"
31{
32// /////////////////////////////// Définitions ////////////////////////////// //
33
34   // ----------------------- Redéfinition de types ----------------------------
35
36   typedef enum { NETCDF4 = 0 } XFileType;
37
38   typedef xios::CContext* XContextPtr;
39
40   // -------------------- Traitement des données ------------------------------
41
42   // This function is not exported to the public Fortran interface,
43   // it is only used from the parse_xml.exe standalone test tool.
44   void cxios_init(void)
45   {
46     CXios::initialize();
47   }
48
49   void cxios_init_server(void)
50   {
51     CXios::initServerSide();
52   }
53
54   void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
55   {
56      std::string str;
57      ep_lib::MPI_Comm local_comm;
58      ep_lib::MPI_Comm return_comm;
59     
60      ep_lib::fc_comm_map.clear();
61
62      if (!cstr2string(client_id, len_client_id, str)) return;
63
64      int initialized;
65      MPI_Initialized(&initialized);
66
67      #ifdef _usingEP
68      if (initialized) local_comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_local_comm));
69      else local_comm = MPI_COMM_NULL;
70      #else
71      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm);
72      else local_comm = MPI_COMM_NULL;
73      #endif
74     
75     
76
77      CXios::initClientSide(str, local_comm, return_comm);
78
79      #ifdef _usingEP
80      *f_return_comm = ep_lib::EP_Comm_c2f(return_comm);
81      #else
82      *f_return_comm = MPI_Comm_c2f(return_comm);
83      #endif
84
85      CTimer::get("XIOS init").suspend();
86      CTimer::get("XIOS").suspend();
87   }
88
89   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm)
90   {
91     std::string str;
92     ep_lib::MPI_Comm comm;
93
94     if (!cstr2string(context_id, len_context_id, str)) return;
95     CTimer::get("XIOS").resume();
96     CTimer::get("XIOS init context").resume();
97     comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_comm));
98
99     CClient::registerContext(str,comm);
100         
101     CTimer::get("XIOS init context").suspend();
102     CTimer::get("XIOS").suspend();
103   }
104
105   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized)
106   {
107     std::string str;
108
109     if (!cstr2string(context_id, len_context_id, str)) return;
110     CTimer::get("XIOS").resume();
111     CContext* context = CContext::get(str, str);
112     *initialized=context->isInitialized();
113     CTimer::get("XIOS").suspend();
114   }
115
116    void cxios_context_close_definition()
117   {
118     CTimer::get("XIOS").resume();
119     CTimer::get("XIOS close definition").resume();
120     CContext* context = CContext::getCurrent();
121     
122     context->closeDefinition();
123     
124     CTimer::get("XIOS close definition").suspend();
125     CTimer::get("XIOS").suspend();
126   }
127
128   void cxios_context_finalize()
129   {
130     CTimer::get("XIOS").resume();
131     CTimer::get("XIOS context finalize").resume();
132     
133     
134     
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      {
456        context->checkBuffersAndListen();
457      } 
458
459      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
460      CField::get(fieldid_str)->setData(data);
461
462      CTimer::get("XIOS send field").suspend();
463      CTimer::get("XIOS").suspend();
464   }
465
466   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)
467   {
468      std::string fieldid_str;
469      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
470
471      CTimer::get("XIOS").resume();
472      CTimer::get("XIOS send field").resume();
473
474      CContext* context = CContext::getCurrent();
475      if (!context->hasServer && !context->client->isAttachedModeEnabled())
476        context->checkBuffersAndListen();
477
478      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
479      CField::get(fieldid_str)->setData(data);
480
481      CTimer::get("XIOS send field").suspend();
482      CTimer::get("XIOS").suspend();
483   }
484
485   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
486                             int data_0size, int data_1size, int data_2size,
487                             int data_3size, int data_4size)
488   {
489      std::string fieldid_str;
490      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
491
492      CTimer::get("XIOS").resume();
493      CTimer::get("XIOS send field").resume();
494
495      CContext* context = CContext::getCurrent();
496      if (!context->hasServer && !context->client->isAttachedModeEnabled())
497        context->checkBuffersAndListen();
498
499      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
500      CField::get(fieldid_str)->setData(data);
501
502      CTimer::get("XIOS send field").suspend();
503      CTimer::get("XIOS").suspend();
504   }
505
506   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
507                             int data_0size, int data_1size, int data_2size,
508                             int data_3size, int data_4size, int data_5size)
509   {
510      std::string fieldid_str;
511      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
512
513      CTimer::get("XIOS").resume();
514      CTimer::get("XIOS send field").resume();
515
516      CContext* context = CContext::getCurrent();
517      if (!context->hasServer && !context->client->isAttachedModeEnabled())
518        context->checkBuffersAndListen();
519
520      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
521      CField::get(fieldid_str)->setData(data);
522
523      CTimer::get("XIOS send field").suspend();
524      CTimer::get("XIOS").suspend();
525   }
526
527   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
528                             int data_0size, int data_1size, int data_2size,
529                             int data_3size, int data_4size, int data_5size,
530                             int data_6size)
531   {
532      std::string fieldid_str;
533      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
534
535      CTimer::get("XIOS").resume();
536      CTimer::get("XIOS send field").resume();
537
538      CContext* context = CContext::getCurrent();
539      if (!context->hasServer && !context->client->isAttachedModeEnabled())
540        context->checkBuffersAndListen();
541
542      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
543      CField::get(fieldid_str)->setData(data);
544
545      CTimer::get("XIOS send field").suspend();
546      CTimer::get("XIOS").suspend();
547   }
548
549   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
550   {
551      std::string fieldid_str;
552      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
553
554      CTimer::get("XIOS").resume();
555      CTimer::get("XIOS send field").resume();
556      CContext* context = CContext::getCurrent();
557      if (!context->hasServer && !context->client->isAttachedModeEnabled())
558        context->checkBuffersAndListen();
559
560      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
561      CArray<double, 1> data(data_Xsize) ;
562      data = data_tmp;
563      CField::get(fieldid_str)->setData(data);
564      CTimer::get("XIOS send field").suspend();
565      CTimer::get("XIOS").suspend();
566   }
567
568   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
569   {
570      std::string fieldid_str;
571      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
572
573      CTimer::get("XIOS").resume();
574      CTimer::get("XIOS send field").resume();
575
576      CContext* context = CContext::getCurrent();
577      if (!context->hasServer && !context->client->isAttachedModeEnabled())
578        context->checkBuffersAndListen();
579
580      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
581      CArray<double, 1> data(data_Xsize);
582      data = data_tmp;
583      CField::get(fieldid_str)->setData(data);
584
585      CTimer::get("XIOS send field").suspend();
586      CTimer::get("XIOS").suspend();
587   }
588
589   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
590   {
591      std::string fieldid_str;
592      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
593
594      CTimer::get("XIOS").resume();
595      CTimer::get("XIOS send field").resume();
596
597      CContext* context = CContext::getCurrent();
598      if (!context->hasServer && !context->client->isAttachedModeEnabled())
599        context->checkBuffersAndListen();
600
601      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
602      CArray<double, 2> data(data_Xsize, data_Ysize);
603      data = data_tmp;
604      CField::get(fieldid_str)->setData(data);
605
606      CTimer::get("XIOS send field").suspend();
607      CTimer::get("XIOS").suspend();
608   }
609
610   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
611   {
612      std::string fieldid_str;
613      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
614
615      CTimer::get("XIOS").resume();
616      CTimer::get("XIOS send field").resume();
617
618      CContext* context = CContext::getCurrent();
619      if (!context->hasServer && !context->client->isAttachedModeEnabled())
620        context->checkBuffersAndListen();
621
622      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
623      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
624      data = data_tmp;
625      CField::get(fieldid_str)->setData(data);
626
627      CTimer::get("XIOS send field").suspend();
628      CTimer::get("XIOS").suspend();
629    }
630
631   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
632                             int data_0size, int data_1size, int data_2size,
633                             int data_3size)
634   {
635      std::string fieldid_str;
636      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
637
638      CTimer::get("XIOS").resume();
639      CTimer::get("XIOS send field").resume();
640
641      CContext* context = CContext::getCurrent();
642      if (!context->hasServer && !context->client->isAttachedModeEnabled())
643        context->checkBuffersAndListen();
644
645      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
646      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
647      data = data_tmp;
648      CField::get(fieldid_str)->setData(data);
649
650      CTimer::get("XIOS send field").suspend();
651      CTimer::get("XIOS").suspend();
652    }
653
654   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
655                             int data_0size, int data_1size, int data_2size,
656                             int data_3size, int data_4size)
657   {
658      std::string fieldid_str;
659      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
660
661      CTimer::get("XIOS").resume();
662      CTimer::get("XIOS send field").resume();
663
664      CContext* context = CContext::getCurrent();
665      if (!context->hasServer && !context->client->isAttachedModeEnabled())
666        context->checkBuffersAndListen();
667
668      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
669      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
670      data = data_tmp;
671      CField::get(fieldid_str)->setData(data);
672
673      CTimer::get("XIOS send field").suspend();
674      CTimer::get("XIOS").suspend();
675    }
676
677   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
678                             int data_0size, int data_1size, int data_2size,
679                             int data_3size, int data_4size, int data_5size)
680   {
681      std::string fieldid_str;
682      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
683
684      CTimer::get("XIOS").resume();
685      CTimer::get("XIOS send field").resume();
686
687      CContext* context = CContext::getCurrent();
688      if (!context->hasServer && !context->client->isAttachedModeEnabled())
689        context->checkBuffersAndListen();
690
691      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
692      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
693      data = data_tmp;
694      CField::get(fieldid_str)->setData(data);
695
696      CTimer::get("XIOS send field").suspend();
697      CTimer::get("XIOS").suspend();
698    }
699
700   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
701                             int data_0size, int data_1size, int data_2size,
702                             int data_3size, int data_4size, int data_5size,
703                             int data_6size)
704   {
705      std::string fieldid_str;
706      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
707
708      CTimer::get("XIOS").resume();
709      CTimer::get("XIOS send field").resume();
710
711      CContext* context = CContext::getCurrent();
712      if (!context->hasServer && !context->client->isAttachedModeEnabled())
713        context->checkBuffersAndListen();
714
715      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
716      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
717      data = data_tmp;
718      CField::get(fieldid_str)->setData(data);
719
720      CTimer::get("XIOS send field").suspend();
721      CTimer::get("XIOS").suspend();
722    }
723
724   // ---------------------- Lecture des données ------------------------------
725
726   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
727   {
728      std::string fieldid_str;
729      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
730
731      CTimer::get("XIOS").resume();
732      CTimer::get("XIOS recv field").resume();
733
734      CContext* context = CContext::getCurrent();
735      if (!context->hasServer && !context->client->isAttachedModeEnabled())
736        context->checkBuffersAndListen();
737
738      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
739      CField::get(fieldid_str)->getData(data);
740
741      CTimer::get("XIOS recv field").suspend();
742      CTimer::get("XIOS").suspend();
743   }
744
745   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
746   {
747      std::string fieldid_str;
748      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
749
750      CTimer::get("XIOS").resume();
751      CTimer::get("XIOS recv field").resume();
752
753      CContext* context = CContext::getCurrent();
754      if (!context->hasServer && !context->client->isAttachedModeEnabled())
755        context->checkBuffersAndListen();
756
757      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
758      CField::get(fieldid_str)->getData(data);
759
760      CTimer::get("XIOS recv field").suspend();
761      CTimer::get("XIOS").suspend();
762   }
763
764   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
765   {
766      std::string fieldid_str;
767      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
768
769      CTimer::get("XIOS").resume();
770      CTimer::get("XIOS recv field").resume();
771
772      CContext* context = CContext::getCurrent();
773      if (!context->hasServer && !context->client->isAttachedModeEnabled())
774        context->checkBuffersAndListen();
775
776      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
777      CField::get(fieldid_str)->getData(data);
778
779      CTimer::get("XIOS recv field").suspend();
780      CTimer::get("XIOS").suspend();
781   }
782
783   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
784   {
785      std::string fieldid_str;
786      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
787
788      CTimer::get("XIOS").resume();
789      CTimer::get("XIOS recv field").resume();
790
791      CContext* context = CContext::getCurrent();
792      if (!context->hasServer && !context->client->isAttachedModeEnabled())
793        context->checkBuffersAndListen();
794
795      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
796      CField::get(fieldid_str)->getData(data);
797
798      CTimer::get("XIOS recv field").suspend();
799      CTimer::get("XIOS").suspend();
800   }
801
802   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
803                            int data_0size, int data_1size, int data_2size,
804                            int data_3size)
805   {
806      std::string fieldid_str;
807      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
808
809      CTimer::get("XIOS").resume();
810      CTimer::get("XIOS recv field").resume();
811
812      CContext* context = CContext::getCurrent();
813      if (!context->hasServer && !context->client->isAttachedModeEnabled())
814        context->checkBuffersAndListen();
815
816      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
817      CField::get(fieldid_str)->getData(data);
818
819      CTimer::get("XIOS recv field").suspend();
820      CTimer::get("XIOS").suspend();
821   }
822
823   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
824                            int data_0size, int data_1size, int data_2size,
825                            int data_3size, int data_4size)
826   {
827      std::string fieldid_str;
828      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
829
830      CTimer::get("XIOS").resume();
831      CTimer::get("XIOS recv field").resume();
832
833      CContext* context = CContext::getCurrent();
834      if (!context->hasServer && !context->client->isAttachedModeEnabled())
835        context->checkBuffersAndListen();
836
837      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
838      CField::get(fieldid_str)->getData(data);
839
840      CTimer::get("XIOS recv field").suspend();
841      CTimer::get("XIOS").suspend();
842   }
843
844   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
845                            int data_0size, int data_1size, int data_2size,
846                            int data_3size, int data_4size, int data_5size)
847   {
848      std::string fieldid_str;
849      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
850
851      CTimer::get("XIOS").resume();
852      CTimer::get("XIOS recv field").resume();
853
854      CContext* context = CContext::getCurrent();
855      if (!context->hasServer && !context->client->isAttachedModeEnabled())
856        context->checkBuffersAndListen();
857
858      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
859      CField::get(fieldid_str)->getData(data);
860
861      CTimer::get("XIOS recv field").suspend();
862      CTimer::get("XIOS").suspend();
863   }
864
865   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8,
866                            int data_0size, int data_1size, int data_2size,
867                            int data_3size, int data_4size, int data_5size,
868                            int data_6size)
869   {
870      std::string fieldid_str;
871      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
872
873      CTimer::get("XIOS").resume();
874      CTimer::get("XIOS recv field").resume();
875
876      CContext* context = CContext::getCurrent();
877      if (!context->hasServer && !context->client->isAttachedModeEnabled())
878        context->checkBuffersAndListen();
879
880      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
881      CField::get(fieldid_str)->getData(data);
882
883      CTimer::get("XIOS recv field").suspend();
884      CTimer::get("XIOS").suspend();
885   }
886
887   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
888   {
889      std::string fieldid_str;
890      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
891
892      CTimer::get("XIOS").resume();
893      CTimer::get("XIOS recv field").resume();
894
895      CContext* context = CContext::getCurrent();
896      if (!context->hasServer && !context->client->isAttachedModeEnabled())
897        context->checkBuffersAndListen();
898
899      CArray<double, 1> data(data_Xsize);
900      CField::get(fieldid_str)->getData(data);
901      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
902      data_tmp = data;
903
904      CTimer::get("XIOS recv field").suspend();
905      CTimer::get("XIOS").suspend();
906   }
907
908   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
909   {
910      std::string fieldid_str;
911      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
912
913      CTimer::get("XIOS").resume();
914      CTimer::get("XIOS recv field").resume();
915
916      CContext* context = CContext::getCurrent();
917      if (!context->hasServer && !context->client->isAttachedModeEnabled())
918        context->checkBuffersAndListen();
919
920      CArray<double, 1> data(data_Xsize);
921      CField::get(fieldid_str)->getData(data);
922      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData);
923      data_tmp = data;
924
925      CTimer::get("XIOS recv field").suspend();
926      CTimer::get("XIOS").suspend();
927   }
928
929   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
930   {
931      std::string fieldid_str;
932      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
933
934      CTimer::get("XIOS").resume();
935      CTimer::get("XIOS recv field").resume();
936
937      CContext* context = CContext::getCurrent();
938      if (!context->hasServer && !context->client->isAttachedModeEnabled())
939        context->checkBuffersAndListen();
940
941      CArray<double, 2> data(data_Xsize, data_Ysize);
942      CField::get(fieldid_str)->getData(data);
943      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData);
944      data_tmp = data;
945
946      CTimer::get("XIOS recv field").suspend();
947      CTimer::get("XIOS").suspend();
948   }
949
950   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
951   {
952      std::string fieldid_str;
953      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
954
955      CTimer::get("XIOS").resume();
956      CTimer::get("XIOS recv field").resume();
957
958      CContext* context = CContext::getCurrent();
959      if (!context->hasServer && !context->client->isAttachedModeEnabled())
960        context->checkBuffersAndListen();
961
962      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
963      CField::get(fieldid_str)->getData(data);
964      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
965      data_tmp = data;
966
967      CTimer::get("XIOS recv field").suspend();
968      CTimer::get("XIOS").suspend();
969    }
970
971   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
972                            int data_0size, int data_1size, int data_2size,
973                            int data_3size)
974   {
975      std::string fieldid_str;
976      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
977
978      CTimer::get("XIOS").resume();
979      CTimer::get("XIOS recv field").resume();
980
981      CContext* context = CContext::getCurrent();
982      if (!context->hasServer && !context->client->isAttachedModeEnabled())
983        context->checkBuffersAndListen();
984
985      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
986      CField::get(fieldid_str)->getData(data);
987      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
988      data_tmp = data;
989
990      CTimer::get("XIOS recv field").suspend();
991      CTimer::get("XIOS").suspend();
992    }
993
994   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
995                            int data_0size, int data_1size, int data_2size,
996                            int data_3size, int data_4size)
997   {
998      std::string fieldid_str;
999      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1000
1001      CTimer::get("XIOS").resume();
1002      CTimer::get("XIOS recv field").resume();
1003
1004      CContext* context = CContext::getCurrent();
1005      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1006        context->checkBuffersAndListen();
1007
1008      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
1009      CField::get(fieldid_str)->getData(data);
1010      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
1011      data_tmp = data;
1012
1013      CTimer::get("XIOS recv field").suspend();
1014      CTimer::get("XIOS").suspend();
1015    }
1016
1017   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
1018                            int data_0size, int data_1size, int data_2size,
1019                            int data_3size, int data_4size, int data_5size)
1020   {
1021      std::string fieldid_str;
1022      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1023
1024      CTimer::get("XIOS").resume();
1025      CTimer::get("XIOS recv field").resume();
1026
1027      CContext* context = CContext::getCurrent();
1028      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1029        context->checkBuffersAndListen();
1030
1031      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
1032      CField::get(fieldid_str)->getData(data);
1033      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
1034      data_tmp = data;
1035
1036      CTimer::get("XIOS recv field").suspend();
1037      CTimer::get("XIOS").suspend();
1038    }
1039
1040   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4,
1041                            int data_0size, int data_1size, int data_2size,
1042                            int data_3size, int data_4size, int data_5size,
1043                            int data_6size)
1044   {
1045      std::string fieldid_str;
1046      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
1047
1048      CTimer::get("XIOS").resume();
1049      CTimer::get("XIOS recv field").resume();
1050
1051      CContext* context = CContext::getCurrent();
1052      if (!context->hasServer && !context->client->isAttachedModeEnabled())
1053        context->checkBuffersAndListen();
1054
1055      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
1056      CField::get(fieldid_str)->getData(data);
1057      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
1058      data_tmp = data;
1059
1060      CTimer::get("XIOS recv field").suspend();
1061      CTimer::get("XIOS").suspend();
1062    }
1063} // extern "C"
Note: See TracBrowser for help on using the repository browser.