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

Last change on this file since 666 was 666, checked in by mhnguyen, 6 years ago

Change name of several axis attributes and remove some redundant variable of domain

+) Change name of axis attributes to make them consistent with ones of domain
+) Remove zoom_client_* of domain

Test
+) On Curie
+) All tests pass and are correct

  • 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: 25.9 KB
Line 
1/* ************************************************************************** *
2 *               Interface auto generated - do not modify                     *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include "xios.hpp"
8#include "attribute_template.hpp"
9#include "object_template.hpp"
10#include "group_template.hpp"
11#include "icutil.hpp"
12#include "icdate.hpp"
13#include "timer.hpp"
14#include "node_type.hpp"
15
16extern "C"
17{
18  typedef xios::CDomain* domain_Ptr;
19
20  void cxios_set_domain_area(domain_Ptr domain_hdl, double* area, int extent1, int extent2)
21  {
22    CTimer::get("XIOS").resume();
23    CArray<double,2> tmp(area, shape(extent1, extent2), neverDeleteData);
24    domain_hdl->area.reference(tmp.copy());
25     CTimer::get("XIOS").suspend();
26  }
27
28  void cxios_get_domain_area(domain_Ptr domain_hdl, double* area, int extent1, int extent2)
29  {
30    CTimer::get("XIOS").resume();
31    CArray<double,2> tmp(area, shape(extent1, extent2), neverDeleteData);
32    tmp=domain_hdl->area.getInheritedValue();
33     CTimer::get("XIOS").suspend();
34  }
35
36  bool cxios_is_defined_domain_area(domain_Ptr domain_hdl)
37  {
38     CTimer::get("XIOS").resume();
39     bool isDefined = domain_hdl->area.hasInheritedValue();
40     CTimer::get("XIOS").suspend();
41     return isDefined;
42  }
43
44
45  void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2)
46  {
47    CTimer::get("XIOS").resume();
48    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
49    domain_hdl->bounds_lat_1d.reference(tmp.copy());
50     CTimer::get("XIOS").suspend();
51  }
52
53  void cxios_get_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2)
54  {
55    CTimer::get("XIOS").resume();
56    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
57    tmp=domain_hdl->bounds_lat_1d.getInheritedValue();
58     CTimer::get("XIOS").suspend();
59  }
60
61  bool cxios_is_defined_domain_bounds_lat_1d(domain_Ptr domain_hdl)
62  {
63     CTimer::get("XIOS").resume();
64     bool isDefined = domain_hdl->bounds_lat_1d.hasInheritedValue();
65     CTimer::get("XIOS").suspend();
66     return isDefined;
67  }
68
69
70  void cxios_set_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
71  {
72    CTimer::get("XIOS").resume();
73    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
74    domain_hdl->bounds_lat_2d.reference(tmp.copy());
75     CTimer::get("XIOS").suspend();
76  }
77
78  void cxios_get_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
79  {
80    CTimer::get("XIOS").resume();
81    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
82    tmp=domain_hdl->bounds_lat_2d.getInheritedValue();
83     CTimer::get("XIOS").suspend();
84  }
85
86  bool cxios_is_defined_domain_bounds_lat_2d(domain_Ptr domain_hdl)
87  {
88     CTimer::get("XIOS").resume();
89     bool isDefined = domain_hdl->bounds_lat_2d.hasInheritedValue();
90     CTimer::get("XIOS").suspend();
91     return isDefined;
92  }
93
94
95  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2)
96  {
97    CTimer::get("XIOS").resume();
98    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
99    domain_hdl->bounds_lon_1d.reference(tmp.copy());
100     CTimer::get("XIOS").suspend();
101  }
102
103  void cxios_get_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2)
104  {
105    CTimer::get("XIOS").resume();
106    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
107    tmp=domain_hdl->bounds_lon_1d.getInheritedValue();
108     CTimer::get("XIOS").suspend();
109  }
110
111  bool cxios_is_defined_domain_bounds_lon_1d(domain_Ptr domain_hdl)
112  {
113     CTimer::get("XIOS").resume();
114     bool isDefined = domain_hdl->bounds_lon_1d.hasInheritedValue();
115     CTimer::get("XIOS").suspend();
116     return isDefined;
117  }
118
119
120  void cxios_set_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
121  {
122    CTimer::get("XIOS").resume();
123    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
124    domain_hdl->bounds_lon_2d.reference(tmp.copy());
125     CTimer::get("XIOS").suspend();
126  }
127
128  void cxios_get_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
129  {
130    CTimer::get("XIOS").resume();
131    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
132    tmp=domain_hdl->bounds_lon_2d.getInheritedValue();
133     CTimer::get("XIOS").suspend();
134  }
135
136  bool cxios_is_defined_domain_bounds_lon_2d(domain_Ptr domain_hdl)
137  {
138     CTimer::get("XIOS").resume();
139     bool isDefined = domain_hdl->bounds_lon_2d.hasInheritedValue();
140     CTimer::get("XIOS").suspend();
141     return isDefined;
142  }
143
144
145  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
146  {
147    CTimer::get("XIOS").resume();
148    domain_hdl->data_dim.setValue(data_dim);
149    CTimer::get("XIOS").suspend();
150  }
151
152  void cxios_get_domain_data_dim(domain_Ptr domain_hdl, int* data_dim)
153  {
154    CTimer::get("XIOS").resume();
155    *data_dim = domain_hdl->data_dim.getInheritedValue();
156    CTimer::get("XIOS").suspend();
157  }
158
159  bool cxios_is_defined_domain_data_dim(domain_Ptr domain_hdl)
160  {
161     CTimer::get("XIOS").resume();
162     bool isDefined = domain_hdl->data_dim.hasInheritedValue();
163     CTimer::get("XIOS").suspend();
164     return isDefined;
165  }
166
167
168  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
169  {
170    CTimer::get("XIOS").resume();
171    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData);
172    domain_hdl->data_i_index.reference(tmp.copy());
173     CTimer::get("XIOS").suspend();
174  }
175
176  void cxios_get_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
177  {
178    CTimer::get("XIOS").resume();
179    CArray<int,1> tmp(data_i_index, shape(extent1), neverDeleteData);
180    tmp=domain_hdl->data_i_index.getInheritedValue();
181     CTimer::get("XIOS").suspend();
182  }
183
184  bool cxios_is_defined_domain_data_i_index(domain_Ptr domain_hdl)
185  {
186     CTimer::get("XIOS").resume();
187     bool isDefined = domain_hdl->data_i_index.hasInheritedValue();
188     CTimer::get("XIOS").suspend();
189     return isDefined;
190  }
191
192
193  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
194  {
195    CTimer::get("XIOS").resume();
196    domain_hdl->data_ibegin.setValue(data_ibegin);
197    CTimer::get("XIOS").suspend();
198  }
199
200  void cxios_get_domain_data_ibegin(domain_Ptr domain_hdl, int* data_ibegin)
201  {
202    CTimer::get("XIOS").resume();
203    *data_ibegin = domain_hdl->data_ibegin.getInheritedValue();
204    CTimer::get("XIOS").suspend();
205  }
206
207  bool cxios_is_defined_domain_data_ibegin(domain_Ptr domain_hdl)
208  {
209     CTimer::get("XIOS").resume();
210     bool isDefined = domain_hdl->data_ibegin.hasInheritedValue();
211     CTimer::get("XIOS").suspend();
212     return isDefined;
213  }
214
215
216  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)
217  {
218    CTimer::get("XIOS").resume();
219    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData);
220    domain_hdl->data_j_index.reference(tmp.copy());
221     CTimer::get("XIOS").suspend();
222  }
223
224  void cxios_get_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)
225  {
226    CTimer::get("XIOS").resume();
227    CArray<int,1> tmp(data_j_index, shape(extent1), neverDeleteData);
228    tmp=domain_hdl->data_j_index.getInheritedValue();
229     CTimer::get("XIOS").suspend();
230  }
231
232  bool cxios_is_defined_domain_data_j_index(domain_Ptr domain_hdl)
233  {
234     CTimer::get("XIOS").resume();
235     bool isDefined = domain_hdl->data_j_index.hasInheritedValue();
236     CTimer::get("XIOS").suspend();
237     return isDefined;
238  }
239
240
241  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
242  {
243    CTimer::get("XIOS").resume();
244    domain_hdl->data_jbegin.setValue(data_jbegin);
245    CTimer::get("XIOS").suspend();
246  }
247
248  void cxios_get_domain_data_jbegin(domain_Ptr domain_hdl, int* data_jbegin)
249  {
250    CTimer::get("XIOS").resume();
251    *data_jbegin = domain_hdl->data_jbegin.getInheritedValue();
252    CTimer::get("XIOS").suspend();
253  }
254
255  bool cxios_is_defined_domain_data_jbegin(domain_Ptr domain_hdl)
256  {
257     CTimer::get("XIOS").resume();
258     bool isDefined = domain_hdl->data_jbegin.hasInheritedValue();
259     CTimer::get("XIOS").suspend();
260     return isDefined;
261  }
262
263
264  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
265  {
266    CTimer::get("XIOS").resume();
267    domain_hdl->data_ni.setValue(data_ni);
268    CTimer::get("XIOS").suspend();
269  }
270
271  void cxios_get_domain_data_ni(domain_Ptr domain_hdl, int* data_ni)
272  {
273    CTimer::get("XIOS").resume();
274    *data_ni = domain_hdl->data_ni.getInheritedValue();
275    CTimer::get("XIOS").suspend();
276  }
277
278  bool cxios_is_defined_domain_data_ni(domain_Ptr domain_hdl)
279  {
280     CTimer::get("XIOS").resume();
281     bool isDefined = domain_hdl->data_ni.hasInheritedValue();
282     CTimer::get("XIOS").suspend();
283     return isDefined;
284  }
285
286
287  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
288  {
289    CTimer::get("XIOS").resume();
290    domain_hdl->data_nj.setValue(data_nj);
291    CTimer::get("XIOS").suspend();
292  }
293
294  void cxios_get_domain_data_nj(domain_Ptr domain_hdl, int* data_nj)
295  {
296    CTimer::get("XIOS").resume();
297    *data_nj = domain_hdl->data_nj.getInheritedValue();
298    CTimer::get("XIOS").suspend();
299  }
300
301  bool cxios_is_defined_domain_data_nj(domain_Ptr domain_hdl)
302  {
303     CTimer::get("XIOS").resume();
304     bool isDefined = domain_hdl->data_nj.hasInheritedValue();
305     CTimer::get("XIOS").suspend();
306     return isDefined;
307  }
308
309
310  void cxios_set_domain_domain_group_ref(domain_Ptr domain_hdl, const char * domain_group_ref, int domain_group_ref_size)
311  {
312    std::string domain_group_ref_str;
313    if (!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
314    CTimer::get("XIOS").resume();
315    domain_hdl->domain_group_ref.setValue(domain_group_ref_str);
316    CTimer::get("XIOS").suspend();
317  }
318
319  void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)
320  {
321    CTimer::get("XIOS").resume();
322    if (!string_copy(domain_hdl->domain_group_ref.getInheritedValue(), domain_group_ref, domain_group_ref_size))
323      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", << "Input string is too short");
324    CTimer::get("XIOS").suspend();
325  }
326
327  bool cxios_is_defined_domain_domain_group_ref(domain_Ptr domain_hdl)
328  {
329     CTimer::get("XIOS").resume();
330     bool isDefined = domain_hdl->domain_group_ref.hasInheritedValue();
331     CTimer::get("XIOS").suspend();
332     return isDefined;
333  }
334
335
336  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size)
337  {
338    std::string domain_ref_str;
339    if (!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
340    CTimer::get("XIOS").resume();
341    domain_hdl->domain_ref.setValue(domain_ref_str);
342    CTimer::get("XIOS").suspend();
343  }
344
345  void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)
346  {
347    CTimer::get("XIOS").resume();
348    if (!string_copy(domain_hdl->domain_ref.getInheritedValue(), domain_ref, domain_ref_size))
349      ERROR("void cxios_get_domain_domain_ref(domain_Ptr domain_hdl, char * domain_ref, int domain_ref_size)", << "Input string is too short");
350    CTimer::get("XIOS").suspend();
351  }
352
353  bool cxios_is_defined_domain_domain_ref(domain_Ptr domain_hdl)
354  {
355     CTimer::get("XIOS").resume();
356     bool isDefined = domain_hdl->domain_ref.hasInheritedValue();
357     CTimer::get("XIOS").suspend();
358     return isDefined;
359  }
360
361
362  void cxios_set_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1)
363  {
364    CTimer::get("XIOS").resume();
365    CArray<int,1> tmp(i_index, shape(extent1), neverDeleteData);
366    domain_hdl->i_index.reference(tmp.copy());
367     CTimer::get("XIOS").suspend();
368  }
369
370  void cxios_get_domain_i_index(domain_Ptr domain_hdl, int* i_index, int extent1)
371  {
372    CTimer::get("XIOS").resume();
373    CArray<int,1> tmp(i_index, shape(extent1), neverDeleteData);
374    tmp=domain_hdl->i_index.getInheritedValue();
375     CTimer::get("XIOS").suspend();
376  }
377
378  bool cxios_is_defined_domain_i_index(domain_Ptr domain_hdl)
379  {
380     CTimer::get("XIOS").resume();
381     bool isDefined = domain_hdl->i_index.hasInheritedValue();
382     CTimer::get("XIOS").suspend();
383     return isDefined;
384  }
385
386
387  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
388  {
389    CTimer::get("XIOS").resume();
390    domain_hdl->ibegin.setValue(ibegin);
391    CTimer::get("XIOS").suspend();
392  }
393
394  void cxios_get_domain_ibegin(domain_Ptr domain_hdl, int* ibegin)
395  {
396    CTimer::get("XIOS").resume();
397    *ibegin = domain_hdl->ibegin.getInheritedValue();
398    CTimer::get("XIOS").suspend();
399  }
400
401  bool cxios_is_defined_domain_ibegin(domain_Ptr domain_hdl)
402  {
403     CTimer::get("XIOS").resume();
404     bool isDefined = domain_hdl->ibegin.hasInheritedValue();
405     CTimer::get("XIOS").suspend();
406     return isDefined;
407  }
408
409
410  void cxios_set_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1)
411  {
412    CTimer::get("XIOS").resume();
413    CArray<int,1> tmp(j_index, shape(extent1), neverDeleteData);
414    domain_hdl->j_index.reference(tmp.copy());
415     CTimer::get("XIOS").suspend();
416  }
417
418  void cxios_get_domain_j_index(domain_Ptr domain_hdl, int* j_index, int extent1)
419  {
420    CTimer::get("XIOS").resume();
421    CArray<int,1> tmp(j_index, shape(extent1), neverDeleteData);
422    tmp=domain_hdl->j_index.getInheritedValue();
423     CTimer::get("XIOS").suspend();
424  }
425
426  bool cxios_is_defined_domain_j_index(domain_Ptr domain_hdl)
427  {
428     CTimer::get("XIOS").resume();
429     bool isDefined = domain_hdl->j_index.hasInheritedValue();
430     CTimer::get("XIOS").suspend();
431     return isDefined;
432  }
433
434
435  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
436  {
437    CTimer::get("XIOS").resume();
438    domain_hdl->jbegin.setValue(jbegin);
439    CTimer::get("XIOS").suspend();
440  }
441
442  void cxios_get_domain_jbegin(domain_Ptr domain_hdl, int* jbegin)
443  {
444    CTimer::get("XIOS").resume();
445    *jbegin = domain_hdl->jbegin.getInheritedValue();
446    CTimer::get("XIOS").suspend();
447  }
448
449  bool cxios_is_defined_domain_jbegin(domain_Ptr domain_hdl)
450  {
451     CTimer::get("XIOS").resume();
452     bool isDefined = domain_hdl->jbegin.hasInheritedValue();
453     CTimer::get("XIOS").suspend();
454     return isDefined;
455  }
456
457
458  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1)
459  {
460    CTimer::get("XIOS").resume();
461    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
462    domain_hdl->latvalue_1d.reference(tmp.copy());
463     CTimer::get("XIOS").suspend();
464  }
465
466  void cxios_get_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1)
467  {
468    CTimer::get("XIOS").resume();
469    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
470    tmp=domain_hdl->latvalue_1d.getInheritedValue();
471     CTimer::get("XIOS").suspend();
472  }
473
474  bool cxios_is_defined_domain_latvalue_1d(domain_Ptr domain_hdl)
475  {
476     CTimer::get("XIOS").resume();
477     bool isDefined = domain_hdl->latvalue_1d.hasInheritedValue();
478     CTimer::get("XIOS").suspend();
479     return isDefined;
480  }
481
482
483  void cxios_set_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2)
484  {
485    CTimer::get("XIOS").resume();
486    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
487    domain_hdl->latvalue_2d.reference(tmp.copy());
488     CTimer::get("XIOS").suspend();
489  }
490
491  void cxios_get_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2)
492  {
493    CTimer::get("XIOS").resume();
494    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
495    tmp=domain_hdl->latvalue_2d.getInheritedValue();
496     CTimer::get("XIOS").suspend();
497  }
498
499  bool cxios_is_defined_domain_latvalue_2d(domain_Ptr domain_hdl)
500  {
501     CTimer::get("XIOS").resume();
502     bool isDefined = domain_hdl->latvalue_2d.hasInheritedValue();
503     CTimer::get("XIOS").suspend();
504     return isDefined;
505  }
506
507
508  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size)
509  {
510    std::string long_name_str;
511    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
512    CTimer::get("XIOS").resume();
513    domain_hdl->long_name.setValue(long_name_str);
514    CTimer::get("XIOS").suspend();
515  }
516
517  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
518  {
519    CTimer::get("XIOS").resume();
520    if (!string_copy(domain_hdl->long_name.getInheritedValue(), long_name, long_name_size))
521      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", << "Input string is too short");
522    CTimer::get("XIOS").suspend();
523  }
524
525  bool cxios_is_defined_domain_long_name(domain_Ptr domain_hdl)
526  {
527     CTimer::get("XIOS").resume();
528     bool isDefined = domain_hdl->long_name.hasInheritedValue();
529     CTimer::get("XIOS").suspend();
530     return isDefined;
531  }
532
533
534  void cxios_set_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1)
535  {
536    CTimer::get("XIOS").resume();
537    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
538    domain_hdl->lonvalue_1d.reference(tmp.copy());
539     CTimer::get("XIOS").suspend();
540  }
541
542  void cxios_get_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1)
543  {
544    CTimer::get("XIOS").resume();
545    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
546    tmp=domain_hdl->lonvalue_1d.getInheritedValue();
547     CTimer::get("XIOS").suspend();
548  }
549
550  bool cxios_is_defined_domain_lonvalue_1d(domain_Ptr domain_hdl)
551  {
552     CTimer::get("XIOS").resume();
553     bool isDefined = domain_hdl->lonvalue_1d.hasInheritedValue();
554     CTimer::get("XIOS").suspend();
555     return isDefined;
556  }
557
558
559  void cxios_set_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2)
560  {
561    CTimer::get("XIOS").resume();
562    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
563    domain_hdl->lonvalue_2d.reference(tmp.copy());
564     CTimer::get("XIOS").suspend();
565  }
566
567  void cxios_get_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2)
568  {
569    CTimer::get("XIOS").resume();
570    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
571    tmp=domain_hdl->lonvalue_2d.getInheritedValue();
572     CTimer::get("XIOS").suspend();
573  }
574
575  bool cxios_is_defined_domain_lonvalue_2d(domain_Ptr domain_hdl)
576  {
577     CTimer::get("XIOS").resume();
578     bool isDefined = domain_hdl->lonvalue_2d.hasInheritedValue();
579     CTimer::get("XIOS").suspend();
580     return isDefined;
581  }
582
583
584  void cxios_set_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1)
585  {
586    CTimer::get("XIOS").resume();
587    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
588    domain_hdl->mask_1d.reference(tmp.copy());
589     CTimer::get("XIOS").suspend();
590  }
591
592  void cxios_get_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1)
593  {
594    CTimer::get("XIOS").resume();
595    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
596    tmp=domain_hdl->mask_1d.getInheritedValue();
597     CTimer::get("XIOS").suspend();
598  }
599
600  bool cxios_is_defined_domain_mask_1d(domain_Ptr domain_hdl)
601  {
602     CTimer::get("XIOS").resume();
603     bool isDefined = domain_hdl->mask_1d.hasInheritedValue();
604     CTimer::get("XIOS").suspend();
605     return isDefined;
606  }
607
608
609  void cxios_set_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2)
610  {
611    CTimer::get("XIOS").resume();
612    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
613    domain_hdl->mask_2d.reference(tmp.copy());
614     CTimer::get("XIOS").suspend();
615  }
616
617  void cxios_get_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2)
618  {
619    CTimer::get("XIOS").resume();
620    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
621    tmp=domain_hdl->mask_2d.getInheritedValue();
622     CTimer::get("XIOS").suspend();
623  }
624
625  bool cxios_is_defined_domain_mask_2d(domain_Ptr domain_hdl)
626  {
627     CTimer::get("XIOS").resume();
628     bool isDefined = domain_hdl->mask_2d.hasInheritedValue();
629     CTimer::get("XIOS").suspend();
630     return isDefined;
631  }
632
633
634  void cxios_set_domain_name(domain_Ptr domain_hdl, const char * name, int name_size)
635  {
636    std::string name_str;
637    if (!cstr2string(name, name_size, name_str)) return;
638    CTimer::get("XIOS").resume();
639    domain_hdl->name.setValue(name_str);
640    CTimer::get("XIOS").suspend();
641  }
642
643  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
644  {
645    CTimer::get("XIOS").resume();
646    if (!string_copy(domain_hdl->name.getInheritedValue(), name, name_size))
647      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", << "Input string is too short");
648    CTimer::get("XIOS").suspend();
649  }
650
651  bool cxios_is_defined_domain_name(domain_Ptr domain_hdl)
652  {
653     CTimer::get("XIOS").resume();
654     bool isDefined = domain_hdl->name.hasInheritedValue();
655     CTimer::get("XIOS").suspend();
656     return isDefined;
657  }
658
659
660  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
661  {
662    CTimer::get("XIOS").resume();
663    domain_hdl->ni.setValue(ni);
664    CTimer::get("XIOS").suspend();
665  }
666
667  void cxios_get_domain_ni(domain_Ptr domain_hdl, int* ni)
668  {
669    CTimer::get("XIOS").resume();
670    *ni = domain_hdl->ni.getInheritedValue();
671    CTimer::get("XIOS").suspend();
672  }
673
674  bool cxios_is_defined_domain_ni(domain_Ptr domain_hdl)
675  {
676     CTimer::get("XIOS").resume();
677     bool isDefined = domain_hdl->ni.hasInheritedValue();
678     CTimer::get("XIOS").suspend();
679     return isDefined;
680  }
681
682
683  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
684  {
685    CTimer::get("XIOS").resume();
686    domain_hdl->ni_glo.setValue(ni_glo);
687    CTimer::get("XIOS").suspend();
688  }
689
690  void cxios_get_domain_ni_glo(domain_Ptr domain_hdl, int* ni_glo)
691  {
692    CTimer::get("XIOS").resume();
693    *ni_glo = domain_hdl->ni_glo.getInheritedValue();
694    CTimer::get("XIOS").suspend();
695  }
696
697  bool cxios_is_defined_domain_ni_glo(domain_Ptr domain_hdl)
698  {
699     CTimer::get("XIOS").resume();
700     bool isDefined = domain_hdl->ni_glo.hasInheritedValue();
701     CTimer::get("XIOS").suspend();
702     return isDefined;
703  }
704
705
706  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
707  {
708    CTimer::get("XIOS").resume();
709    domain_hdl->nj.setValue(nj);
710    CTimer::get("XIOS").suspend();
711  }
712
713  void cxios_get_domain_nj(domain_Ptr domain_hdl, int* nj)
714  {
715    CTimer::get("XIOS").resume();
716    *nj = domain_hdl->nj.getInheritedValue();
717    CTimer::get("XIOS").suspend();
718  }
719
720  bool cxios_is_defined_domain_nj(domain_Ptr domain_hdl)
721  {
722     CTimer::get("XIOS").resume();
723     bool isDefined = domain_hdl->nj.hasInheritedValue();
724     CTimer::get("XIOS").suspend();
725     return isDefined;
726  }
727
728
729  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
730  {
731    CTimer::get("XIOS").resume();
732    domain_hdl->nj_glo.setValue(nj_glo);
733    CTimer::get("XIOS").suspend();
734  }
735
736  void cxios_get_domain_nj_glo(domain_Ptr domain_hdl, int* nj_glo)
737  {
738    CTimer::get("XIOS").resume();
739    *nj_glo = domain_hdl->nj_glo.getInheritedValue();
740    CTimer::get("XIOS").suspend();
741  }
742
743  bool cxios_is_defined_domain_nj_glo(domain_Ptr domain_hdl)
744  {
745     CTimer::get("XIOS").resume();
746     bool isDefined = domain_hdl->nj_glo.hasInheritedValue();
747     CTimer::get("XIOS").suspend();
748     return isDefined;
749  }
750
751
752  void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex)
753  {
754    CTimer::get("XIOS").resume();
755    domain_hdl->nvertex.setValue(nvertex);
756    CTimer::get("XIOS").suspend();
757  }
758
759  void cxios_get_domain_nvertex(domain_Ptr domain_hdl, int* nvertex)
760  {
761    CTimer::get("XIOS").resume();
762    *nvertex = domain_hdl->nvertex.getInheritedValue();
763    CTimer::get("XIOS").suspend();
764  }
765
766  bool cxios_is_defined_domain_nvertex(domain_Ptr domain_hdl)
767  {
768     CTimer::get("XIOS").resume();
769     bool isDefined = domain_hdl->nvertex.hasInheritedValue();
770     CTimer::get("XIOS").suspend();
771     return isDefined;
772  }
773
774
775  void cxios_set_domain_standard_name(domain_Ptr domain_hdl, const char * standard_name, int standard_name_size)
776  {
777    std::string standard_name_str;
778    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
779    CTimer::get("XIOS").resume();
780    domain_hdl->standard_name.setValue(standard_name_str);
781    CTimer::get("XIOS").suspend();
782  }
783
784  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
785  {
786    CTimer::get("XIOS").resume();
787    if (!string_copy(domain_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
788      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
789    CTimer::get("XIOS").suspend();
790  }
791
792  bool cxios_is_defined_domain_standard_name(domain_Ptr domain_hdl)
793  {
794     CTimer::get("XIOS").resume();
795     bool isDefined = domain_hdl->standard_name.hasInheritedValue();
796     CTimer::get("XIOS").suspend();
797     return isDefined;
798  }
799
800
801  void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size)
802  {
803    std::string type_str;
804    if (!cstr2string(type, type_size, type_str)) return;
805    CTimer::get("XIOS").resume();
806    domain_hdl->type.fromString(type_str);
807    CTimer::get("XIOS").suspend();
808  }
809
810  void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)
811  {
812    CTimer::get("XIOS").resume();
813    if (!string_copy(domain_hdl->type.getInheritedStringValue(), type, type_size))
814      ERROR("void cxios_get_domain_type(domain_Ptr domain_hdl, char * type, int type_size)", << "Input string is too short");
815    CTimer::get("XIOS").suspend();
816  }
817
818  bool cxios_is_defined_domain_type(domain_Ptr domain_hdl)
819  {
820     CTimer::get("XIOS").resume();
821     bool isDefined = domain_hdl->type.hasInheritedValue();
822     CTimer::get("XIOS").suspend();
823     return isDefined;
824  }
825}
Note: See TracBrowser for help on using the repository browser.