source: XIOS/dev/dev_oa/src/interface/c/icdata.cpp @ 1963

Last change on this file since 1963 was 1963, checked in by oabramkina, 4 years ago

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