source: XIOS/dev/dev_ym/XIOS_COUPLING/src/interface/c/icdata.cpp @ 1780

Last change on this file since 1780 was 1761, checked in by ymipsl, 5 years ago

implementing first guess for service functionnalities.

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