source: XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

Last change on this file was 2131, checked in by oabramkina, 13 months ago

Merging branch dev_oa with tiling into trunk

  • 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.7 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                     *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include "xios.hpp"
7#include "attribute_template.hpp"
8#include "object_template.hpp"
9#include "group_template.hpp"
10#include "icutil.hpp"
11#include "icdate.hpp"
12#include "timer.hpp"
13#include "node_type.hpp"
14
15extern "C"
16{
17  typedef xios::CDomain* domain_Ptr;
18
19  void cxios_set_domain_area(domain_Ptr domain_hdl, double* area, int* extent)
20  {
21    CTimer::get("XIOS").resume();
22    CArray<double,2> tmp(area, shape(extent[0], extent[1]), neverDeleteData);
23    domain_hdl->area.reference(tmp.copy());
24     CTimer::get("XIOS").suspend();
25  }
26
27  void cxios_get_domain_area(domain_Ptr domain_hdl, double* area, int* extent)
28  {
29    CTimer::get("XIOS").resume();
30    CArray<double,2> tmp(area, shape(extent[0], extent[1]), neverDeleteData);
31    tmp=domain_hdl->area.getInheritedValue();
32     CTimer::get("XIOS").suspend();
33  }
34
35  bool cxios_is_defined_domain_area(domain_Ptr domain_hdl)
36  {
37     CTimer::get("XIOS").resume();
38     bool isDefined = domain_hdl->area.hasInheritedValue();
39     CTimer::get("XIOS").suspend();
40     return isDefined;
41  }
42
43
44  void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int* extent)
45  {
46    CTimer::get("XIOS").resume();
47    CArray<double,2> tmp(bounds_lat_1d, shape(extent[0], extent[1]), neverDeleteData);
48    domain_hdl->bounds_lat_1d.reference(tmp.copy());
49     CTimer::get("XIOS").suspend();
50  }
51
52  void cxios_get_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int* extent)
53  {
54    CTimer::get("XIOS").resume();
55    CArray<double,2> tmp(bounds_lat_1d, shape(extent[0], extent[1]), neverDeleteData);
56    tmp=domain_hdl->bounds_lat_1d.getInheritedValue();
57     CTimer::get("XIOS").suspend();
58  }
59
60  bool cxios_is_defined_domain_bounds_lat_1d(domain_Ptr domain_hdl)
61  {
62     CTimer::get("XIOS").resume();
63     bool isDefined = domain_hdl->bounds_lat_1d.hasInheritedValue();
64     CTimer::get("XIOS").suspend();
65     return isDefined;
66  }
67
68
69  void cxios_set_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int* extent)
70  {
71    CTimer::get("XIOS").resume();
72    CArray<double,3> tmp(bounds_lat_2d, shape(extent[0], extent[1], extent[2]), neverDeleteData);
73    domain_hdl->bounds_lat_2d.reference(tmp.copy());
74     CTimer::get("XIOS").suspend();
75  }
76
77  void cxios_get_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int* extent)
78  {
79    CTimer::get("XIOS").resume();
80    CArray<double,3> tmp(bounds_lat_2d, shape(extent[0], extent[1], extent[2]), neverDeleteData);
81    tmp=domain_hdl->bounds_lat_2d.getInheritedValue();
82     CTimer::get("XIOS").suspend();
83  }
84
85  bool cxios_is_defined_domain_bounds_lat_2d(domain_Ptr domain_hdl)
86  {
87     CTimer::get("XIOS").resume();
88     bool isDefined = domain_hdl->bounds_lat_2d.hasInheritedValue();
89     CTimer::get("XIOS").suspend();
90     return isDefined;
91  }
92
93
94  void cxios_set_domain_bounds_lat_name(domain_Ptr domain_hdl, const char * bounds_lat_name, int bounds_lat_name_size)
95  {
96    std::string bounds_lat_name_str;
97    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return;
98    CTimer::get("XIOS").resume();
99    domain_hdl->bounds_lat_name.setValue(bounds_lat_name_str);
100    CTimer::get("XIOS").suspend();
101  }
102
103  void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size)
104  {
105    CTimer::get("XIOS").resume();
106    if (!string_copy(domain_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size))
107      ERROR("void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short");
108    CTimer::get("XIOS").suspend();
109  }
110
111  bool cxios_is_defined_domain_bounds_lat_name(domain_Ptr domain_hdl)
112  {
113     CTimer::get("XIOS").resume();
114     bool isDefined = domain_hdl->bounds_lat_name.hasInheritedValue();
115     CTimer::get("XIOS").suspend();
116     return isDefined;
117  }
118
119
120  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int* extent)
121  {
122    CTimer::get("XIOS").resume();
123    CArray<double,2> tmp(bounds_lon_1d, shape(extent[0], extent[1]), neverDeleteData);
124    domain_hdl->bounds_lon_1d.reference(tmp.copy());
125     CTimer::get("XIOS").suspend();
126  }
127
128  void cxios_get_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int* extent)
129  {
130    CTimer::get("XIOS").resume();
131    CArray<double,2> tmp(bounds_lon_1d, shape(extent[0], extent[1]), neverDeleteData);
132    tmp=domain_hdl->bounds_lon_1d.getInheritedValue();
133     CTimer::get("XIOS").suspend();
134  }
135
136  bool cxios_is_defined_domain_bounds_lon_1d(domain_Ptr domain_hdl)
137  {
138     CTimer::get("XIOS").resume();
139     bool isDefined = domain_hdl->bounds_lon_1d.hasInheritedValue();
140     CTimer::get("XIOS").suspend();
141     return isDefined;
142  }
143
144
145  void cxios_set_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int* extent)
146  {
147    CTimer::get("XIOS").resume();
148    CArray<double,3> tmp(bounds_lon_2d, shape(extent[0], extent[1], extent[2]), neverDeleteData);
149    domain_hdl->bounds_lon_2d.reference(tmp.copy());
150     CTimer::get("XIOS").suspend();
151  }
152
153  void cxios_get_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int* extent)
154  {
155    CTimer::get("XIOS").resume();
156    CArray<double,3> tmp(bounds_lon_2d, shape(extent[0], extent[1], extent[2]), neverDeleteData);
157    tmp=domain_hdl->bounds_lon_2d.getInheritedValue();
158     CTimer::get("XIOS").suspend();
159  }
160
161  bool cxios_is_defined_domain_bounds_lon_2d(domain_Ptr domain_hdl)
162  {
163     CTimer::get("XIOS").resume();
164     bool isDefined = domain_hdl->bounds_lon_2d.hasInheritedValue();
165     CTimer::get("XIOS").suspend();
166     return isDefined;
167  }
168
169
170  void cxios_set_domain_bounds_lon_name(domain_Ptr domain_hdl, const char * bounds_lon_name, int bounds_lon_name_size)
171  {
172    std::string bounds_lon_name_str;
173    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return;
174    CTimer::get("XIOS").resume();
175    domain_hdl->bounds_lon_name.setValue(bounds_lon_name_str);
176    CTimer::get("XIOS").suspend();
177  }
178
179  void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size)
180  {
181    CTimer::get("XIOS").resume();
182    if (!string_copy(domain_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size))
183      ERROR("void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short");
184    CTimer::get("XIOS").suspend();
185  }
186
187  bool cxios_is_defined_domain_bounds_lon_name(domain_Ptr domain_hdl)
188  {
189     CTimer::get("XIOS").resume();
190     bool isDefined = domain_hdl->bounds_lon_name.hasInheritedValue();
191     CTimer::get("XIOS").suspend();
192     return isDefined;
193  }
194
195
196  void cxios_set_domain_comment(domain_Ptr domain_hdl, const char * comment, int comment_size)
197  {
198    std::string comment_str;
199    if (!cstr2string(comment, comment_size, comment_str)) return;
200    CTimer::get("XIOS").resume();
201    domain_hdl->comment.setValue(comment_str);
202    CTimer::get("XIOS").suspend();
203  }
204
205  void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)
206  {
207    CTimer::get("XIOS").resume();
208    if (!string_copy(domain_hdl->comment.getInheritedValue(), comment, comment_size))
209      ERROR("void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)", << "Input string is too short");
210    CTimer::get("XIOS").suspend();
211  }
212
213  bool cxios_is_defined_domain_comment(domain_Ptr domain_hdl)
214  {
215     CTimer::get("XIOS").resume();
216     bool isDefined = domain_hdl->comment.hasInheritedValue();
217     CTimer::get("XIOS").suspend();
218     return isDefined;
219  }
220
221
222  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
223  {
224    CTimer::get("XIOS").resume();
225    domain_hdl->data_dim.setValue(data_dim);
226    CTimer::get("XIOS").suspend();
227  }
228
229  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim)
230  {
231    CTimer::get("XIOS").resume();
232    *data_dim = domain_hdl->data_dim.getInheritedValue();
233    CTimer::get("XIOS").suspend();
234  }
235
236  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl)
237  {
238     CTimer::get("XIOS").resume();
239     bool isDefined = domain_hdl->data_dim.hasInheritedValue();
240     CTimer::get("XIOS").suspend();
241     return isDefined;
242  }
243
244
245  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int* extent)
246  {
247    CTimer::get("XIOS").resume();
248    CArray<int,1> tmp(data_i_index, shape(extent[0]), neverDeleteData);
249    domain_hdl->data_i_index.reference(tmp.copy());
250     CTimer::get("XIOS").suspend();
251  }
252
253  void cxios_get_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int* extent)
254  {
255    CTimer::get("XIOS").resume();
256    CArray<int,1> tmp(data_i_index, shape(extent[0]), neverDeleteData);
257    tmp=domain_hdl->data_i_index.getInheritedValue();
258     CTimer::get("XIOS").suspend();
259  }
260
261  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl)
262  {
263     CTimer::get("XIOS").resume();
264     bool isDefined = domain_hdl->data_i_index.hasInheritedValue();
265     CTimer::get("XIOS").suspend();
266     return isDefined;
267  }
268
269
270  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
271  {
272    CTimer::get("XIOS").resume();
273    domain_hdl->data_ibegin.setValue(data_ibegin);
274    CTimer::get("XIOS").suspend();
275  }
276
277  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin)
278  {
279    CTimer::get("XIOS").resume();
280    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue();
281    CTimer::get("XIOS").suspend();
282  }
283
284  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl)
285  {
286     CTimer::get("XIOS").resume();
287     bool isDefined = domain_hdl->data_ibegin.hasInheritedValue();
288     CTimer::get("XIOS").suspend();
289     return isDefined;
290  }
291
292
293  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int* extent)
294  {
295    CTimer::get("XIOS").resume();
296    CArray<int,1> tmp(data_j_index, shape(extent[0]), neverDeleteData);
297    domain_hdl->data_j_index.reference(tmp.copy());
298     CTimer::get("XIOS").suspend();
299  }
300
301  void cxios_get_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int* extent)
302  {
303    CTimer::get("XIOS").resume();
304    CArray<int,1> tmp(data_j_index, shape(extent[0]), neverDeleteData);
305    tmp=domain_hdl->data_j_index.getInheritedValue();
306     CTimer::get("XIOS").suspend();
307  }
308
309  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl)
310  {
311     CTimer::get("XIOS").resume();
312     bool isDefined = domain_hdl->data_j_index.hasInheritedValue();
313     CTimer::get("XIOS").suspend();
314     return isDefined;
315  }
316
317
318  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
319  {
320    CTimer::get("XIOS").resume();
321    domain_hdl->data_jbegin.setValue(data_jbegin);
322    CTimer::get("XIOS").suspend();
323  }
324
325  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin)
326  {
327    CTimer::get("XIOS").resume();
328    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue();
329    CTimer::get("XIOS").suspend();
330  }
331
332  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl)
333  {
334     CTimer::get("XIOS").resume();
335     bool isDefined = domain_hdl->data_jbegin.hasInheritedValue();
336     CTimer::get("XIOS").suspend();
337     return isDefined;
338  }
339
340
341  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
342  {
343    CTimer::get("XIOS").resume();
344    domain_hdl->data_ni.setValue(data_ni);
345    CTimer::get("XIOS").suspend();
346  }
347
348  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni)
349  {
350    CTimer::get("XIOS").resume();
351    *data_ni = domain_hdl->data_ni.getInheritedValue();
352    CTimer::get("XIOS").suspend();
353  }
354
355  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl)
356  {
357     CTimer::get("XIOS").resume();
358     bool isDefined = domain_hdl->data_ni.hasInheritedValue();
359     CTimer::get("XIOS").suspend();
360     return isDefined;
361  }
362
363
364  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
365  {
366    CTimer::get("XIOS").resume();
367    domain_hdl->data_nj.setValue(data_nj);
368    CTimer::get("XIOS").suspend();
369  }
370
371  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj)
372  {
373    CTimer::get("XIOS").resume();
374    *data_nj = domain_hdl->data_nj.getInheritedValue();
375    CTimer::get("XIOS").suspend();
376  }
377
378  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl)
379  {
380     CTimer::get("XIOS").resume();
381     bool isDefined = domain_hdl->data_nj.hasInheritedValue();
382     CTimer::get("XIOS").suspend();
383     return isDefined;
384  }
385
386
387  void cxios_set_domain_dim_i_name(domain_Ptr domain_hdl, const char * dim_i_name, int dim_i_name_size)
388  {
389    std::string dim_i_name_str;
390    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return;
391    CTimer::get("XIOS").resume();
392    domain_hdl->dim_i_name.setValue(dim_i_name_str);
393    CTimer::get("XIOS").suspend();
394  }
395
396  void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size)
397  {
398    CTimer::get("XIOS").resume();
399    if (!string_copy(domain_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size))
400      ERROR("void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short");
401    CTimer::get("XIOS").suspend();
402  }
403
404  bool cxios_is_defined_domain_dim_i_name(domain_Ptr domain_hdl)
405  {
406     CTimer::get("XIOS").resume();
407     bool isDefined = domain_hdl->dim_i_name.hasInheritedValue();
408     CTimer::get("XIOS").suspend();
409     return isDefined;
410  }
411
412
413  void cxios_set_domain_dim_j_name(domain_Ptr domain_hdl, const char * dim_j_name, int dim_j_name_size)
414  {
415    std::string dim_j_name_str;
416    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return;
417    CTimer::get("XIOS").resume();
418    domain_hdl->dim_j_name.setValue(dim_j_name_str);
419    CTimer::get("XIOS").suspend();
420  }
421
422  void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size)
423  {
424    CTimer::get("XIOS").resume();
425    if (!string_copy(domain_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size))
426      ERROR("void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short");
427    CTimer::get("XIOS").suspend();
428  }
429
430  bool cxios_is_defined_domain_dim_j_name(domain_Ptr domain_hdl)
431  {
432     CTimer::get("XIOS").resume();
433     bool isDefined = domain_hdl->dim_j_name.hasInheritedValue();
434     CTimer::get("XIOS").suspend();
435     return isDefined;
436  }
437
438
439  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size)
440  {
441    std::string domain_ref_str;
442    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
443    CTimer::get("XIOS").resume();
444    domain_hdl->domain_ref.setValue(domain_ref_str);
445    CTimer::get("XIOS").suspend();
446  }
447
448  void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)
449  {
450    CTimer::get("XIOS").resume();
451    if (!string_copy(domain_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size))
452      ERROR("void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short");
453    CTimer::get("XIOS").suspend();
454  }
455
456  bool cxios_is_defined_domain_domain_ref(domain_Ptr domain_hdl)
457  {
458     CTimer::get("XIOS").resume();
459     bool isDefined = domain_hdl->domain_ref.hasInheritedValue();
460     CTimer::get("XIOS").suspend();
461     return isDefined;
462  }
463
464
465  void cxios_set_domain_i_index(domain_Ptr domain_hdl, int* i_index, int* extent)
466  {
467    CTimer::get("XIOS").resume();
468    CArray<int,1> tmp(i_index, shape(extent[0]), neverDeleteData);
469    domain_hdl->i_index.reference(tmp.copy());
470     CTimer::get("XIOS").suspend();
471  }
472
473  void cxios_get_domain_i_index(domain_Ptr domain_hdl, int* i_index, int* extent)
474  {
475    CTimer::get("XIOS").resume();
476    CArray<int,1> tmp(i_index, shape(extent[0]), neverDeleteData);
477    tmp=domain_hdl->i_index.getInheritedValue();
478     CTimer::get("XIOS").suspend();
479  }
480
481  bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl)
482  {
483     CTimer::get("XIOS").resume();
484     bool isDefined = domain_hdl->i_index.hasInheritedValue();
485     CTimer::get("XIOS").suspend();
486     return isDefined;
487  }
488
489
490  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
491  {
492    CTimer::get("XIOS").resume();
493    domain_hdl->ibegin.setValue(ibegin);
494    CTimer::get("XIOS").suspend();
495  }
496
497  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin)
498  {
499    CTimer::get("XIOS").resume();
500    *ibegin = domain_hdl->ibegin.getInheritedValue();
501    CTimer::get("XIOS").suspend();
502  }
503
504  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl)
505  {
506     CTimer::get("XIOS").resume();
507     bool isDefined = domain_hdl->ibegin.hasInheritedValue();
508     CTimer::get("XIOS").suspend();
509     return isDefined;
510  }
511
512
513  void cxios_set_domain_j_index(domain_Ptr domain_hdl, int* j_index, int* extent)
514  {
515    CTimer::get("XIOS").resume();
516    CArray<int,1> tmp(j_index, shape(extent[0]), neverDeleteData);
517    domain_hdl->j_index.reference(tmp.copy());
518     CTimer::get("XIOS").suspend();
519  }
520
521  void cxios_get_domain_j_index(domain_Ptr domain_hdl, int* j_index, int* extent)
522  {
523    CTimer::get("XIOS").resume();
524    CArray<int,1> tmp(j_index, shape(extent[0]), neverDeleteData);
525    tmp=domain_hdl->j_index.getInheritedValue();
526     CTimer::get("XIOS").suspend();
527  }
528
529  bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl)
530  {
531     CTimer::get("XIOS").resume();
532     bool isDefined = domain_hdl->j_index.hasInheritedValue();
533     CTimer::get("XIOS").suspend();
534     return isDefined;
535  }
536
537
538  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
539  {
540    CTimer::get("XIOS").resume();
541    domain_hdl->jbegin.setValue(jbegin);
542    CTimer::get("XIOS").suspend();
543  }
544
545  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin)
546  {
547    CTimer::get("XIOS").resume();
548    *jbegin = domain_hdl->jbegin.getInheritedValue();
549    CTimer::get("XIOS").suspend();
550  }
551
552  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl)
553  {
554     CTimer::get("XIOS").resume();
555     bool isDefined = domain_hdl->jbegin.hasInheritedValue();
556     CTimer::get("XIOS").suspend();
557     return isDefined;
558  }
559
560
561  void cxios_set_domain_lat_name(domain_Ptr domain_hdl, const char * lat_name, int lat_name_size)
562  {
563    std::string lat_name_str;
564    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return;
565    CTimer::get("XIOS").resume();
566    domain_hdl->lat_name.setValue(lat_name_str);
567    CTimer::get("XIOS").suspend();
568  }
569
570  void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)
571  {
572    CTimer::get("XIOS").resume();
573    if (!string_copy(domain_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size))
574      ERROR("void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)", << "Input string is too short");
575    CTimer::get("XIOS").suspend();
576  }
577
578  bool cxios_is_defined_domain_lat_name(domain_Ptr domain_hdl)
579  {
580     CTimer::get("XIOS").resume();
581     bool isDefined = domain_hdl->lat_name.hasInheritedValue();
582     CTimer::get("XIOS").suspend();
583     return isDefined;
584  }
585
586
587  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent)
588  {
589    CTimer::get("XIOS").resume();
590    CArray<double,1> tmp(latvalue_1d, shape(extent[0]), neverDeleteData);
591    domain_hdl->latvalue_1d.reference(tmp.copy());
592     CTimer::get("XIOS").suspend();
593  }
594
595  void cxios_get_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent)
596  {
597    CTimer::get("XIOS").resume();
598    CArray<double,1> tmp(latvalue_1d, shape(extent[0]), neverDeleteData);
599    tmp=domain_hdl->latvalue_1d.getInheritedValue();
600     CTimer::get("XIOS").suspend();
601  }
602
603  bool cxios_is_defined_domain_latvalue_1d(domain_Ptr domain_hdl)
604  {
605     CTimer::get("XIOS").resume();
606     bool isDefined = domain_hdl->latvalue_1d.hasInheritedValue();
607     CTimer::get("XIOS").suspend();
608     return isDefined;
609  }
610
611
612  void cxios_set_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int* extent)
613  {
614    CTimer::get("XIOS").resume();
615    CArray<double,2> tmp(latvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
616    domain_hdl->latvalue_2d.reference(tmp.copy());
617     CTimer::get("XIOS").suspend();
618  }
619
620  void cxios_get_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int* extent)
621  {
622    CTimer::get("XIOS").resume();
623    CArray<double,2> tmp(latvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
624    tmp=domain_hdl->latvalue_2d.getInheritedValue();
625     CTimer::get("XIOS").suspend();
626  }
627
628  bool cxios_is_defined_domain_latvalue_2d(domain_Ptr domain_hdl)
629  {
630     CTimer::get("XIOS").resume();
631     bool isDefined = domain_hdl->latvalue_2d.hasInheritedValue();
632     CTimer::get("XIOS").suspend();
633     return isDefined;
634  }
635
636
637  void cxios_set_domain_lon_name(domain_Ptr domain_hdl, const char * lon_name, int lon_name_size)
638  {
639    std::string lon_name_str;
640    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return;
641    CTimer::get("XIOS").resume();
642    domain_hdl->lon_name.setValue(lon_name_str);
643    CTimer::get("XIOS").suspend();
644  }
645
646  void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)
647  {
648    CTimer::get("XIOS").resume();
649    if (!string_copy(domain_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size))
650      ERROR("void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)", << "Input string is too short");
651    CTimer::get("XIOS").suspend();
652  }
653
654  bool cxios_is_defined_domain_lon_name(domain_Ptr domain_hdl)
655  {
656     CTimer::get("XIOS").resume();
657     bool isDefined = domain_hdl->lon_name.hasInheritedValue();
658     CTimer::get("XIOS").suspend();
659     return isDefined;
660  }
661
662
663  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
664  {
665    std::string long_name_str;
666    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
667    CTimer::get("XIOS").resume();
668    domain_hdl->long_name.setValue(long_name_str);
669    CTimer::get("XIOS").suspend();
670  }
671
672  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
673  {
674    CTimer::get("XIOS").resume();
675    if (!string_copy(domain_hdl->long_name.getInheritedValue(), long_name, long_name_size))
676      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", << "Input string is too short");
677    CTimer::get("XIOS").suspend();
678  }
679
680  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl)
681  {
682     CTimer::get("XIOS").resume();
683     bool isDefined = domain_hdl->long_name.hasInheritedValue();
684     CTimer::get("XIOS").suspend();
685     return isDefined;
686  }
687
688
689  void cxios_set_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int* extent)
690  {
691    CTimer::get("XIOS").resume();
692    CArray<double,1> tmp(lonvalue_1d, shape(extent[0]), neverDeleteData);
693    domain_hdl->lonvalue_1d.reference(tmp.copy());
694     CTimer::get("XIOS").suspend();
695  }
696
697  void cxios_get_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int* extent)
698  {
699    CTimer::get("XIOS").resume();
700    CArray<double,1> tmp(lonvalue_1d, shape(extent[0]), neverDeleteData);
701    tmp=domain_hdl->lonvalue_1d.getInheritedValue();
702     CTimer::get("XIOS").suspend();
703  }
704
705  bool cxios_is_defined_domain_lonvalue_1d(domain_Ptr domain_hdl)
706  {
707     CTimer::get("XIOS").resume();
708     bool isDefined = domain_hdl->lonvalue_1d.hasInheritedValue();
709     CTimer::get("XIOS").suspend();
710     return isDefined;
711  }
712
713
714  void cxios_set_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int* extent)
715  {
716    CTimer::get("XIOS").resume();
717    CArray<double,2> tmp(lonvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
718    domain_hdl->lonvalue_2d.reference(tmp.copy());
719     CTimer::get("XIOS").suspend();
720  }
721
722  void cxios_get_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int* extent)
723  {
724    CTimer::get("XIOS").resume();
725    CArray<double,2> tmp(lonvalue_2d, shape(extent[0], extent[1]), neverDeleteData);
726    tmp=domain_hdl->lonvalue_2d.getInheritedValue();
727     CTimer::get("XIOS").suspend();
728  }
729
730  bool cxios_is_defined_domain_lonvalue_2d(domain_Ptr domain_hdl)
731  {
732     CTimer::get("XIOS").resume();
733     bool isDefined = domain_hdl->lonvalue_2d.hasInheritedValue();
734     CTimer::get("XIOS").suspend();
735     return isDefined;
736  }
737
738
739  void cxios_set_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int* extent)
740  {
741    CTimer::get("XIOS").resume();
742    CArray<bool,1> tmp(mask_1d, shape(extent[0]), neverDeleteData);
743    domain_hdl->mask_1d.reference(tmp.copy());
744     CTimer::get("XIOS").suspend();
745  }
746
747  void cxios_get_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int* extent)
748  {
749    CTimer::get("XIOS").resume();
750    CArray<bool,1> tmp(mask_1d, shape(extent[0]), neverDeleteData);
751    tmp=domain_hdl->mask_1d.getInheritedValue();
752     CTimer::get("XIOS").suspend();
753  }
754
755  bool cxios_is_defined_domain_mask_1d(domain_Ptr domain_hdl)
756  {
757     CTimer::get("XIOS").resume();
758     bool isDefined = domain_hdl->mask_1d.hasInheritedValue();
759     CTimer::get("XIOS").suspend();
760     return isDefined;
761  }
762
763
764  void cxios_set_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int* extent)
765  {
766    CTimer::get("XIOS").resume();
767    CArray<bool,2> tmp(mask_2d, shape(extent[0], extent[1]), neverDeleteData);
768    domain_hdl->mask_2d.reference(tmp.copy());
769     CTimer::get("XIOS").suspend();
770  }
771
772  void cxios_get_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int* extent)
773  {
774    CTimer::get("XIOS").resume();
775    CArray<bool,2> tmp(mask_2d, shape(extent[0], extent[1]), neverDeleteData);
776    tmp=domain_hdl->mask_2d.getInheritedValue();
777     CTimer::get("XIOS").suspend();
778  }
779
780  bool cxios_is_defined_domain_mask_2d(domain_Ptr domain_hdl)
781  {
782     CTimer::get("XIOS").resume();
783     bool isDefined = domain_hdl->mask_2d.hasInheritedValue();
784     CTimer::get("XIOS").suspend();
785     return isDefined;
786  }
787
788
789  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
790  {
791    std::string name_str;
792    if (!cstr2string(name, name_size, name_str)) return;
793    CTimer::get("XIOS").resume();
794    domain_hdl->name.setValue(name_str);
795    CTimer::get("XIOS").suspend();
796  }
797
798  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
799  {
800    CTimer::get("XIOS").resume();
801    if (!string_copy(domain_hdl->name.getInheritedValue(), name, name_size))
802      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", << "Input string is too short");
803    CTimer::get("XIOS").suspend();
804  }
805
806  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl)
807  {
808     CTimer::get("XIOS").resume();
809     bool isDefined = domain_hdl->name.hasInheritedValue();
810     CTimer::get("XIOS").suspend();
811     return isDefined;
812  }
813
814
815  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
816  {
817    CTimer::get("XIOS").resume();
818    domain_hdl->ni.setValue(ni);
819    CTimer::get("XIOS").suspend();
820  }
821
822  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni)
823  {
824    CTimer::get("XIOS").resume();
825    *ni = domain_hdl->ni.getInheritedValue();
826    CTimer::get("XIOS").suspend();
827  }
828
829  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl)
830  {
831     CTimer::get("XIOS").resume();
832     bool isDefined = domain_hdl->ni.hasInheritedValue();
833     CTimer::get("XIOS").suspend();
834     return isDefined;
835  }
836
837
838  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
839  {
840    CTimer::get("XIOS").resume();
841    domain_hdl->ni_glo.setValue(ni_glo);
842    CTimer::get("XIOS").suspend();
843  }
844
845  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo)
846  {
847    CTimer::get("XIOS").resume();
848    *ni_glo = domain_hdl->ni_glo.getInheritedValue();
849    CTimer::get("XIOS").suspend();
850  }
851
852  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl)
853  {
854     CTimer::get("XIOS").resume();
855     bool isDefined = domain_hdl->ni_glo.hasInheritedValue();
856     CTimer::get("XIOS").suspend();
857     return isDefined;
858  }
859
860
861  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
862  {
863    CTimer::get("XIOS").resume();
864    domain_hdl->nj.setValue(nj);
865    CTimer::get("XIOS").suspend();
866  }
867
868  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj)
869  {
870    CTimer::get("XIOS").resume();
871    *nj = domain_hdl->nj.getInheritedValue();
872    CTimer::get("XIOS").suspend();
873  }
874
875  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl)
876  {
877     CTimer::get("XIOS").resume();
878     bool isDefined = domain_hdl->nj.hasInheritedValue();
879     CTimer::get("XIOS").suspend();
880     return isDefined;
881  }
882
883
884  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
885  {
886    CTimer::get("XIOS").resume();
887    domain_hdl->nj_glo.setValue(nj_glo);
888    CTimer::get("XIOS").suspend();
889  }
890
891  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo)
892  {
893    CTimer::get("XIOS").resume();
894    *nj_glo = domain_hdl->nj_glo.getInheritedValue();
895    CTimer::get("XIOS").suspend();
896  }
897
898  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl)
899  {
900     CTimer::get("XIOS").resume();
901     bool isDefined = domain_hdl->nj_glo.hasInheritedValue();
902     CTimer::get("XIOS").suspend();
903     return isDefined;
904  }
905
906
907  void cxios_set_domain_ntiles(domain_Ptr domain_hdl, int ntiles)
908  {
909    CTimer::get("XIOS").resume();
910    domain_hdl->ntiles.setValue(ntiles);
911    CTimer::get("XIOS").suspend();
912  }
913
914  void cxios_get_domain_ntiles(domain_Ptr domain_hdl, int* ntiles)
915  {
916    CTimer::get("XIOS").resume();
917    *ntiles = domain_hdl->ntiles.getInheritedValue();
918    CTimer::get("XIOS").suspend();
919  }
920
921  bool cxios_is_defined_domain_ntiles(domain_Ptr domain_hdl)
922  {
923     CTimer::get("XIOS").resume();
924     bool isDefined = domain_hdl->ntiles.hasInheritedValue();
925     CTimer::get("XIOS").suspend();
926     return isDefined;
927  }
928
929
930  void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex)
931  {
932    CTimer::get("XIOS").resume();
933    domain_hdl->nvertex.setValue(nvertex);
934    CTimer::get("XIOS").suspend();
935  }
936
937  void cxios_get_domain_nvertex(domain_Ptr domain_hdl, int* nvertex)
938  {
939    CTimer::get("XIOS").resume();
940    *nvertex = domain_hdl->nvertex.getInheritedValue();
941    CTimer::get("XIOS").suspend();
942  }
943
944  bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl)
945  {
946     CTimer::get("XIOS").resume();
947     bool isDefined = domain_hdl->nvertex.hasInheritedValue();
948     CTimer::get("XIOS").suspend();
949     return isDefined;
950  }
951
952
953  void cxios_set_domain_prec(domain_Ptr domain_hdl, int prec)
954  {
955    CTimer::get("XIOS").resume();
956    domain_hdl->prec.setValue(prec);
957    CTimer::get("XIOS").suspend();
958  }
959
960  void cxios_get_domain_prec(domain_Ptr domain_hdl, int* prec)
961  {
962    CTimer::get("XIOS").resume();
963    *prec = domain_hdl->prec.getInheritedValue();
964    CTimer::get("XIOS").suspend();
965  }
966
967  bool cxios_is_defined_domain_prec(domain_Ptr domain_hdl)
968  {
969     CTimer::get("XIOS").resume();
970     bool isDefined = domain_hdl->prec.hasInheritedValue();
971     CTimer::get("XIOS").suspend();
972     return isDefined;
973  }
974
975
976  void cxios_set_domain_radius(domain_Ptr domain_hdl, double radius)
977  {
978    CTimer::get("XIOS").resume();
979    domain_hdl->radius.setValue(radius);
980    CTimer::get("XIOS").suspend();
981  }
982
983  void cxios_get_domain_radius(domain_Ptr domain_hdl, double* radius)
984  {
985    CTimer::get("XIOS").resume();
986    *radius = domain_hdl->radius.getInheritedValue();
987    CTimer::get("XIOS").suspend();
988  }
989
990  bool cxios_is_defined_domain_radius(domain_Ptr domain_hdl)
991  {
992     CTimer::get("XIOS").resume();
993     bool isDefined = domain_hdl->radius.hasInheritedValue();
994     CTimer::get("XIOS").suspend();
995     return isDefined;
996  }
997
998
999  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
1000  {
1001    std::string standard_name_str;
1002    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
1003    CTimer::get("XIOS").resume();
1004    domain_hdl->standard_name.setValue(standard_name_str);
1005    CTimer::get("XIOS").suspend();
1006  }
1007
1008  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
1009  {
1010    CTimer::get("XIOS").resume();
1011    if (!string_copy(domain_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
1012      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
1013    CTimer::get("XIOS").suspend();
1014  }
1015
1016  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl)
1017  {
1018     CTimer::get("XIOS").resume();
1019     bool isDefined = domain_hdl->standard_name.hasInheritedValue();
1020     CTimer::get("XIOS").suspend();
1021     return isDefined;
1022  }
1023
1024
1025  void cxios_set_domain_tile_data_ibegin(domain_Ptr domain_hdl, int* tile_data_ibegin, int* extent)
1026  {
1027    CTimer::get("XIOS").resume();
1028    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
1029    domain_hdl->tile_data_ibegin.reference(tmp.copy());
1030     CTimer::get("XIOS").suspend();
1031  }
1032
1033  void cxios_get_domain_tile_data_ibegin(domain_Ptr domain_hdl, int* tile_data_ibegin, int* extent)
1034  {
1035    CTimer::get("XIOS").resume();
1036    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
1037    tmp=domain_hdl->tile_data_ibegin.getInheritedValue();
1038     CTimer::get("XIOS").suspend();
1039  }
1040
1041  bool cxios_is_defined_domain_tile_data_ibegin(domain_Ptr domain_hdl)
1042  {
1043     CTimer::get("XIOS").resume();
1044     bool isDefined = domain_hdl->tile_data_ibegin.hasInheritedValue();
1045     CTimer::get("XIOS").suspend();
1046     return isDefined;
1047  }
1048
1049
1050  void cxios_set_domain_tile_data_jbegin(domain_Ptr domain_hdl, int* tile_data_jbegin, int* extent)
1051  {
1052    CTimer::get("XIOS").resume();
1053    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
1054    domain_hdl->tile_data_jbegin.reference(tmp.copy());
1055     CTimer::get("XIOS").suspend();
1056  }
1057
1058  void cxios_get_domain_tile_data_jbegin(domain_Ptr domain_hdl, int* tile_data_jbegin, int* extent)
1059  {
1060    CTimer::get("XIOS").resume();
1061    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
1062    tmp=domain_hdl->tile_data_jbegin.getInheritedValue();
1063     CTimer::get("XIOS").suspend();
1064  }
1065
1066  bool cxios_is_defined_domain_tile_data_jbegin(domain_Ptr domain_hdl)
1067  {
1068     CTimer::get("XIOS").resume();
1069     bool isDefined = domain_hdl->tile_data_jbegin.hasInheritedValue();
1070     CTimer::get("XIOS").suspend();
1071     return isDefined;
1072  }
1073
1074
1075  void cxios_set_domain_tile_data_ni(domain_Ptr domain_hdl, int* tile_data_ni, int* extent)
1076  {
1077    CTimer::get("XIOS").resume();
1078    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
1079    domain_hdl->tile_data_ni.reference(tmp.copy());
1080     CTimer::get("XIOS").suspend();
1081  }
1082
1083  void cxios_get_domain_tile_data_ni(domain_Ptr domain_hdl, int* tile_data_ni, int* extent)
1084  {
1085    CTimer::get("XIOS").resume();
1086    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
1087    tmp=domain_hdl->tile_data_ni.getInheritedValue();
1088     CTimer::get("XIOS").suspend();
1089  }
1090
1091  bool cxios_is_defined_domain_tile_data_ni(domain_Ptr domain_hdl)
1092  {
1093     CTimer::get("XIOS").resume();
1094     bool isDefined = domain_hdl->tile_data_ni.hasInheritedValue();
1095     CTimer::get("XIOS").suspend();
1096     return isDefined;
1097  }
1098
1099
1100  void cxios_set_domain_tile_data_nj(domain_Ptr domain_hdl, int* tile_data_nj, int* extent)
1101  {
1102    CTimer::get("XIOS").resume();
1103    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
1104    domain_hdl->tile_data_nj.reference(tmp.copy());
1105     CTimer::get("XIOS").suspend();
1106  }
1107
1108  void cxios_get_domain_tile_data_nj(domain_Ptr domain_hdl, int* tile_data_nj, int* extent)
1109  {
1110    CTimer::get("XIOS").resume();
1111    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
1112    tmp=domain_hdl->tile_data_nj.getInheritedValue();
1113     CTimer::get("XIOS").suspend();
1114  }
1115
1116  bool cxios_is_defined_domain_tile_data_nj(domain_Ptr domain_hdl)
1117  {
1118     CTimer::get("XIOS").resume();
1119     bool isDefined = domain_hdl->tile_data_nj.hasInheritedValue();
1120     CTimer::get("XIOS").suspend();
1121     return isDefined;
1122  }
1123
1124
1125  void cxios_set_domain_tile_ibegin(domain_Ptr domain_hdl, int* tile_ibegin, int* extent)
1126  {
1127    CTimer::get("XIOS").resume();
1128    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
1129    domain_hdl->tile_ibegin.reference(tmp.copy());
1130     CTimer::get("XIOS").suspend();
1131  }
1132
1133  void cxios_get_domain_tile_ibegin(domain_Ptr domain_hdl, int* tile_ibegin, int* extent)
1134  {
1135    CTimer::get("XIOS").resume();
1136    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
1137    tmp=domain_hdl->tile_ibegin.getInheritedValue();
1138     CTimer::get("XIOS").suspend();
1139  }
1140
1141  bool cxios_is_defined_domain_tile_ibegin(domain_Ptr domain_hdl)
1142  {
1143     CTimer::get("XIOS").resume();
1144     bool isDefined = domain_hdl->tile_ibegin.hasInheritedValue();
1145     CTimer::get("XIOS").suspend();
1146     return isDefined;
1147  }
1148
1149
1150  void cxios_set_domain_tile_jbegin(domain_Ptr domain_hdl, int* tile_jbegin, int* extent)
1151  {
1152    CTimer::get("XIOS").resume();
1153    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
1154    domain_hdl->tile_jbegin.reference(tmp.copy());
1155     CTimer::get("XIOS").suspend();
1156  }
1157
1158  void cxios_get_domain_tile_jbegin(domain_Ptr domain_hdl, int* tile_jbegin, int* extent)
1159  {
1160    CTimer::get("XIOS").resume();
1161    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
1162    tmp=domain_hdl->tile_jbegin.getInheritedValue();
1163     CTimer::get("XIOS").suspend();
1164  }
1165
1166  bool cxios_is_defined_domain_tile_jbegin(domain_Ptr domain_hdl)
1167  {
1168     CTimer::get("XIOS").resume();
1169     bool isDefined = domain_hdl->tile_jbegin.hasInheritedValue();
1170     CTimer::get("XIOS").suspend();
1171     return isDefined;
1172  }
1173
1174
1175  void cxios_set_domain_tile_ni(domain_Ptr domain_hdl, int* tile_ni, int* extent)
1176  {
1177    CTimer::get("XIOS").resume();
1178    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
1179    domain_hdl->tile_ni.reference(tmp.copy());
1180     CTimer::get("XIOS").suspend();
1181  }
1182
1183  void cxios_get_domain_tile_ni(domain_Ptr domain_hdl, int* tile_ni, int* extent)
1184  {
1185    CTimer::get("XIOS").resume();
1186    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
1187    tmp=domain_hdl->tile_ni.getInheritedValue();
1188     CTimer::get("XIOS").suspend();
1189  }
1190
1191  bool cxios_is_defined_domain_tile_ni(domain_Ptr domain_hdl)
1192  {
1193     CTimer::get("XIOS").resume();
1194     bool isDefined = domain_hdl->tile_ni.hasInheritedValue();
1195     CTimer::get("XIOS").suspend();
1196     return isDefined;
1197  }
1198
1199
1200  void cxios_set_domain_tile_nj(domain_Ptr domain_hdl, int* tile_nj, int* extent)
1201  {
1202    CTimer::get("XIOS").resume();
1203    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
1204    domain_hdl->tile_nj.reference(tmp.copy());
1205     CTimer::get("XIOS").suspend();
1206  }
1207
1208  void cxios_get_domain_tile_nj(domain_Ptr domain_hdl, int* tile_nj, int* extent)
1209  {
1210    CTimer::get("XIOS").resume();
1211    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
1212    tmp=domain_hdl->tile_nj.getInheritedValue();
1213     CTimer::get("XIOS").suspend();
1214  }
1215
1216  bool cxios_is_defined_domain_tile_nj(domain_Ptr domain_hdl)
1217  {
1218     CTimer::get("XIOS").resume();
1219     bool isDefined = domain_hdl->tile_nj.hasInheritedValue();
1220     CTimer::get("XIOS").suspend();
1221     return isDefined;
1222  }
1223
1224
1225  void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size)
1226  {
1227    std::string type_str;
1228    if (!cstr2string(type, type_size, type_str)) return;
1229    CTimer::get("XIOS").resume();
1230    domain_hdl->type.fromString(type_str);
1231    CTimer::get("XIOS").suspend();
1232  }
1233
1234  void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)
1235  {
1236    CTimer::get("XIOS").resume();
1237    if (!string_copy(domain_hdl->type.getInheritedStringValue(), type, type_size))
1238      ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", << "Input string is too short");
1239    CTimer::get("XIOS").suspend();
1240  }
1241
1242  bool cxios_is_defined_domain_type(domain_Ptr domain_hdl)
1243  {
1244     CTimer::get("XIOS").resume();
1245     bool isDefined = domain_hdl->type.hasInheritedValue();
1246     CTimer::get("XIOS").suspend();
1247     return isDefined;
1248  }
1249}
Note: See TracBrowser for help on using the repository browser.