Changeset 1492


Ignore:
Timestamp:
04/24/18 18:03:18 (3 years ago)
Author:
oabramkina
Message:

Updating fortran interface for attributes that have been recently introduced and the following filters:

duplicate_scalar_to_axis
reduce_axis_to_axis
reduce_scalar_to_scalar
reorder_domain
temporal_splitting.

Location:
XIOS/dev/XIOS_DEV_CMIP6/src
Files:
30 added
49 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/XIOS_DEV_CMIP6/src/generate_fortran_interface.cpp

    r1457 r1492  
    302302  file.open((path+"iexpand_domain_attr.F90").c_str()); 
    303303  expandDomain.generateFortranInterface(file); 
     304  file.close(); 
    304305 
    305306  file.open((path+"reorder_domain_interface_attr.F90").c_str()); 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icaxis_attr.cpp

    r1158 r1492  
    4444 
    4545 
     46  void cxios_set_axis_axis_type(axis_Ptr axis_hdl, const char * axis_type, int axis_type_size) 
     47  { 
     48    std::string axis_type_str; 
     49    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     50    CTimer::get("XIOS").resume(); 
     51    axis_hdl->axis_type.fromString(axis_type_str); 
     52    CTimer::get("XIOS").suspend(); 
     53  } 
     54 
     55  void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size) 
     56  { 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(axis_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     59      ERROR("void cxios_get_axis_axis_type(axis_Ptr axis_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
     61  } 
     62 
     63  bool cxios_is_defined_axis_axis_type(axis_Ptr axis_hdl) 
     64  { 
     65     CTimer::get("XIOS").resume(); 
     66     bool isDefined = axis_hdl->axis_type.hasInheritedValue(); 
     67     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
     69  } 
     70 
     71 
    4672  void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin) 
    4773  { 
     
    92118 
    93119 
     120  void cxios_set_axis_bounds_name(axis_Ptr axis_hdl, const char * bounds_name, int bounds_name_size) 
     121  { 
     122    std::string bounds_name_str; 
     123    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     124    CTimer::get("XIOS").resume(); 
     125    axis_hdl->bounds_name.setValue(bounds_name_str); 
     126    CTimer::get("XIOS").suspend(); 
     127  } 
     128 
     129  void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size) 
     130  { 
     131    CTimer::get("XIOS").resume(); 
     132    if (!string_copy(axis_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     133      ERROR("void cxios_get_axis_bounds_name(axis_Ptr axis_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     134    CTimer::get("XIOS").suspend(); 
     135  } 
     136 
     137  bool cxios_is_defined_axis_bounds_name(axis_Ptr axis_hdl) 
     138  { 
     139     CTimer::get("XIOS").resume(); 
     140     bool isDefined = axis_hdl->bounds_name.hasInheritedValue(); 
     141     CTimer::get("XIOS").suspend(); 
     142     return isDefined; 
     143  } 
     144 
     145 
     146  void cxios_set_axis_comment(axis_Ptr axis_hdl, const char * comment, int comment_size) 
     147  { 
     148    std::string comment_str; 
     149    if (!cstr2string(comment, comment_size, comment_str)) return; 
     150    CTimer::get("XIOS").resume(); 
     151    axis_hdl->comment.setValue(comment_str); 
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size) 
     156  { 
     157    CTimer::get("XIOS").resume(); 
     158    if (!string_copy(axis_hdl->comment.getInheritedValue(), comment, comment_size)) 
     159      ERROR("void cxios_get_axis_comment(axis_Ptr axis_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     160    CTimer::get("XIOS").suspend(); 
     161  } 
     162 
     163  bool cxios_is_defined_axis_comment(axis_Ptr axis_hdl) 
     164  { 
     165     CTimer::get("XIOS").resume(); 
     166     bool isDefined = axis_hdl->comment.hasInheritedValue(); 
     167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
     169  } 
     170 
     171 
    94172  void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin) 
    95173  { 
     
    158236     CTimer::get("XIOS").resume(); 
    159237     bool isDefined = axis_hdl->data_n.hasInheritedValue(); 
     238     CTimer::get("XIOS").suspend(); 
     239     return isDefined; 
     240  } 
     241 
     242 
     243  void cxios_set_axis_dim_name(axis_Ptr axis_hdl, const char * dim_name, int dim_name_size) 
     244  { 
     245    std::string dim_name_str; 
     246    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return; 
     247    CTimer::get("XIOS").resume(); 
     248    axis_hdl->dim_name.setValue(dim_name_str); 
     249    CTimer::get("XIOS").suspend(); 
     250  } 
     251 
     252  void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size) 
     253  { 
     254    CTimer::get("XIOS").resume(); 
     255    if (!string_copy(axis_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size)) 
     256      ERROR("void cxios_get_axis_dim_name(axis_Ptr axis_hdl, char * dim_name, int dim_name_size)", << "Input string is too short"); 
     257    CTimer::get("XIOS").suspend(); 
     258  } 
     259 
     260  bool cxios_is_defined_axis_dim_name(axis_Ptr axis_hdl) 
     261  { 
     262     CTimer::get("XIOS").resume(); 
     263     bool isDefined = axis_hdl->dim_name.hasInheritedValue(); 
     264     CTimer::get("XIOS").suspend(); 
     265     return isDefined; 
     266  } 
     267 
     268 
     269  void cxios_set_axis_formula(axis_Ptr axis_hdl, const char * formula, int formula_size) 
     270  { 
     271    std::string formula_str; 
     272    if (!cstr2string(formula, formula_size, formula_str)) return; 
     273    CTimer::get("XIOS").resume(); 
     274    axis_hdl->formula.setValue(formula_str); 
     275    CTimer::get("XIOS").suspend(); 
     276  } 
     277 
     278  void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size) 
     279  { 
     280    CTimer::get("XIOS").resume(); 
     281    if (!string_copy(axis_hdl->formula.getInheritedValue(), formula, formula_size)) 
     282      ERROR("void cxios_get_axis_formula(axis_Ptr axis_hdl, char * formula, int formula_size)", << "Input string is too short"); 
     283    CTimer::get("XIOS").suspend(); 
     284  } 
     285 
     286  bool cxios_is_defined_axis_formula(axis_Ptr axis_hdl) 
     287  { 
     288     CTimer::get("XIOS").resume(); 
     289     bool isDefined = axis_hdl->formula.hasInheritedValue(); 
     290     CTimer::get("XIOS").suspend(); 
     291     return isDefined; 
     292  } 
     293 
     294 
     295  void cxios_set_axis_formula_bounds(axis_Ptr axis_hdl, const char * formula_bounds, int formula_bounds_size) 
     296  { 
     297    std::string formula_bounds_str; 
     298    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return; 
     299    CTimer::get("XIOS").resume(); 
     300    axis_hdl->formula_bounds.setValue(formula_bounds_str); 
     301    CTimer::get("XIOS").suspend(); 
     302  } 
     303 
     304  void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size) 
     305  { 
     306    CTimer::get("XIOS").resume(); 
     307    if (!string_copy(axis_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size)) 
     308      ERROR("void cxios_get_axis_formula_bounds(axis_Ptr axis_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short"); 
     309    CTimer::get("XIOS").suspend(); 
     310  } 
     311 
     312  bool cxios_is_defined_axis_formula_bounds(axis_Ptr axis_hdl) 
     313  { 
     314     CTimer::get("XIOS").resume(); 
     315     bool isDefined = axis_hdl->formula_bounds.hasInheritedValue(); 
     316     CTimer::get("XIOS").suspend(); 
     317     return isDefined; 
     318  } 
     319 
     320 
     321  void cxios_set_axis_formula_term(axis_Ptr axis_hdl, const char * formula_term, int formula_term_size) 
     322  { 
     323    std::string formula_term_str; 
     324    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return; 
     325    CTimer::get("XIOS").resume(); 
     326    axis_hdl->formula_term.setValue(formula_term_str); 
     327    CTimer::get("XIOS").suspend(); 
     328  } 
     329 
     330  void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size) 
     331  { 
     332    CTimer::get("XIOS").resume(); 
     333    if (!string_copy(axis_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size)) 
     334      ERROR("void cxios_get_axis_formula_term(axis_Ptr axis_hdl, char * formula_term, int formula_term_size)", << "Input string is too short"); 
     335    CTimer::get("XIOS").suspend(); 
     336  } 
     337 
     338  bool cxios_is_defined_axis_formula_term(axis_Ptr axis_hdl) 
     339  { 
     340     CTimer::get("XIOS").resume(); 
     341     bool isDefined = axis_hdl->formula_term.hasInheritedValue(); 
     342     CTimer::get("XIOS").suspend(); 
     343     return isDefined; 
     344  } 
     345 
     346 
     347  void cxios_set_axis_formula_term_bounds(axis_Ptr axis_hdl, const char * formula_term_bounds, int formula_term_bounds_size) 
     348  { 
     349    std::string formula_term_bounds_str; 
     350    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return; 
     351    CTimer::get("XIOS").resume(); 
     352    axis_hdl->formula_term_bounds.setValue(formula_term_bounds_str); 
     353    CTimer::get("XIOS").suspend(); 
     354  } 
     355 
     356  void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size) 
     357  { 
     358    CTimer::get("XIOS").resume(); 
     359    if (!string_copy(axis_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size)) 
     360      ERROR("void cxios_get_axis_formula_term_bounds(axis_Ptr axis_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short"); 
     361    CTimer::get("XIOS").suspend(); 
     362  } 
     363 
     364  bool cxios_is_defined_axis_formula_term_bounds(axis_Ptr axis_hdl) 
     365  { 
     366     CTimer::get("XIOS").resume(); 
     367     bool isDefined = axis_hdl->formula_term_bounds.hasInheritedValue(); 
    160368     CTimer::get("XIOS").suspend(); 
    161369     return isDefined; 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icaxisgroup_attr.cpp

    r1158 r1492  
    4444 
    4545 
     46  void cxios_set_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, const char * axis_type, int axis_type_size) 
     47  { 
     48    std::string axis_type_str; 
     49    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     50    CTimer::get("XIOS").resume(); 
     51    axisgroup_hdl->axis_type.fromString(axis_type_str); 
     52    CTimer::get("XIOS").suspend(); 
     53  } 
     54 
     55  void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size) 
     56  { 
     57    CTimer::get("XIOS").resume(); 
     58    if (!string_copy(axisgroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     59      ERROR("void cxios_get_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     60    CTimer::get("XIOS").suspend(); 
     61  } 
     62 
     63  bool cxios_is_defined_axisgroup_axis_type(axisgroup_Ptr axisgroup_hdl) 
     64  { 
     65     CTimer::get("XIOS").resume(); 
     66     bool isDefined = axisgroup_hdl->axis_type.hasInheritedValue(); 
     67     CTimer::get("XIOS").suspend(); 
     68     return isDefined; 
     69  } 
     70 
     71 
    4672  void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin) 
    4773  { 
     
    92118 
    93119 
     120  void cxios_set_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, const char * bounds_name, int bounds_name_size) 
     121  { 
     122    std::string bounds_name_str; 
     123    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     124    CTimer::get("XIOS").resume(); 
     125    axisgroup_hdl->bounds_name.setValue(bounds_name_str); 
     126    CTimer::get("XIOS").suspend(); 
     127  } 
     128 
     129  void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size) 
     130  { 
     131    CTimer::get("XIOS").resume(); 
     132    if (!string_copy(axisgroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     133      ERROR("void cxios_get_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     134    CTimer::get("XIOS").suspend(); 
     135  } 
     136 
     137  bool cxios_is_defined_axisgroup_bounds_name(axisgroup_Ptr axisgroup_hdl) 
     138  { 
     139     CTimer::get("XIOS").resume(); 
     140     bool isDefined = axisgroup_hdl->bounds_name.hasInheritedValue(); 
     141     CTimer::get("XIOS").suspend(); 
     142     return isDefined; 
     143  } 
     144 
     145 
     146  void cxios_set_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, const char * comment, int comment_size) 
     147  { 
     148    std::string comment_str; 
     149    if (!cstr2string(comment, comment_size, comment_str)) return; 
     150    CTimer::get("XIOS").resume(); 
     151    axisgroup_hdl->comment.setValue(comment_str); 
     152    CTimer::get("XIOS").suspend(); 
     153  } 
     154 
     155  void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size) 
     156  { 
     157    CTimer::get("XIOS").resume(); 
     158    if (!string_copy(axisgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     159      ERROR("void cxios_get_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     160    CTimer::get("XIOS").suspend(); 
     161  } 
     162 
     163  bool cxios_is_defined_axisgroup_comment(axisgroup_Ptr axisgroup_hdl) 
     164  { 
     165     CTimer::get("XIOS").resume(); 
     166     bool isDefined = axisgroup_hdl->comment.hasInheritedValue(); 
     167     CTimer::get("XIOS").suspend(); 
     168     return isDefined; 
     169  } 
     170 
     171 
    94172  void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin) 
    95173  { 
     
    158236     CTimer::get("XIOS").resume(); 
    159237     bool isDefined = axisgroup_hdl->data_n.hasInheritedValue(); 
     238     CTimer::get("XIOS").suspend(); 
     239     return isDefined; 
     240  } 
     241 
     242 
     243  void cxios_set_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, const char * dim_name, int dim_name_size) 
     244  { 
     245    std::string dim_name_str; 
     246    if (!cstr2string(dim_name, dim_name_size, dim_name_str)) return; 
     247    CTimer::get("XIOS").resume(); 
     248    axisgroup_hdl->dim_name.setValue(dim_name_str); 
     249    CTimer::get("XIOS").suspend(); 
     250  } 
     251 
     252  void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size) 
     253  { 
     254    CTimer::get("XIOS").resume(); 
     255    if (!string_copy(axisgroup_hdl->dim_name.getInheritedValue(), dim_name, dim_name_size)) 
     256      ERROR("void cxios_get_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl, char * dim_name, int dim_name_size)", << "Input string is too short"); 
     257    CTimer::get("XIOS").suspend(); 
     258  } 
     259 
     260  bool cxios_is_defined_axisgroup_dim_name(axisgroup_Ptr axisgroup_hdl) 
     261  { 
     262     CTimer::get("XIOS").resume(); 
     263     bool isDefined = axisgroup_hdl->dim_name.hasInheritedValue(); 
     264     CTimer::get("XIOS").suspend(); 
     265     return isDefined; 
     266  } 
     267 
     268 
     269  void cxios_set_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, const char * formula, int formula_size) 
     270  { 
     271    std::string formula_str; 
     272    if (!cstr2string(formula, formula_size, formula_str)) return; 
     273    CTimer::get("XIOS").resume(); 
     274    axisgroup_hdl->formula.setValue(formula_str); 
     275    CTimer::get("XIOS").suspend(); 
     276  } 
     277 
     278  void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size) 
     279  { 
     280    CTimer::get("XIOS").resume(); 
     281    if (!string_copy(axisgroup_hdl->formula.getInheritedValue(), formula, formula_size)) 
     282      ERROR("void cxios_get_axisgroup_formula(axisgroup_Ptr axisgroup_hdl, char * formula, int formula_size)", << "Input string is too short"); 
     283    CTimer::get("XIOS").suspend(); 
     284  } 
     285 
     286  bool cxios_is_defined_axisgroup_formula(axisgroup_Ptr axisgroup_hdl) 
     287  { 
     288     CTimer::get("XIOS").resume(); 
     289     bool isDefined = axisgroup_hdl->formula.hasInheritedValue(); 
     290     CTimer::get("XIOS").suspend(); 
     291     return isDefined; 
     292  } 
     293 
     294 
     295  void cxios_set_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_bounds, int formula_bounds_size) 
     296  { 
     297    std::string formula_bounds_str; 
     298    if (!cstr2string(formula_bounds, formula_bounds_size, formula_bounds_str)) return; 
     299    CTimer::get("XIOS").resume(); 
     300    axisgroup_hdl->formula_bounds.setValue(formula_bounds_str); 
     301    CTimer::get("XIOS").suspend(); 
     302  } 
     303 
     304  void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size) 
     305  { 
     306    CTimer::get("XIOS").resume(); 
     307    if (!string_copy(axisgroup_hdl->formula_bounds.getInheritedValue(), formula_bounds, formula_bounds_size)) 
     308      ERROR("void cxios_get_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_bounds, int formula_bounds_size)", << "Input string is too short"); 
     309    CTimer::get("XIOS").suspend(); 
     310  } 
     311 
     312  bool cxios_is_defined_axisgroup_formula_bounds(axisgroup_Ptr axisgroup_hdl) 
     313  { 
     314     CTimer::get("XIOS").resume(); 
     315     bool isDefined = axisgroup_hdl->formula_bounds.hasInheritedValue(); 
     316     CTimer::get("XIOS").suspend(); 
     317     return isDefined; 
     318  } 
     319 
     320 
     321  void cxios_set_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, const char * formula_term, int formula_term_size) 
     322  { 
     323    std::string formula_term_str; 
     324    if (!cstr2string(formula_term, formula_term_size, formula_term_str)) return; 
     325    CTimer::get("XIOS").resume(); 
     326    axisgroup_hdl->formula_term.setValue(formula_term_str); 
     327    CTimer::get("XIOS").suspend(); 
     328  } 
     329 
     330  void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size) 
     331  { 
     332    CTimer::get("XIOS").resume(); 
     333    if (!string_copy(axisgroup_hdl->formula_term.getInheritedValue(), formula_term, formula_term_size)) 
     334      ERROR("void cxios_get_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl, char * formula_term, int formula_term_size)", << "Input string is too short"); 
     335    CTimer::get("XIOS").suspend(); 
     336  } 
     337 
     338  bool cxios_is_defined_axisgroup_formula_term(axisgroup_Ptr axisgroup_hdl) 
     339  { 
     340     CTimer::get("XIOS").resume(); 
     341     bool isDefined = axisgroup_hdl->formula_term.hasInheritedValue(); 
     342     CTimer::get("XIOS").suspend(); 
     343     return isDefined; 
     344  } 
     345 
     346 
     347  void cxios_set_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, const char * formula_term_bounds, int formula_term_bounds_size) 
     348  { 
     349    std::string formula_term_bounds_str; 
     350    if (!cstr2string(formula_term_bounds, formula_term_bounds_size, formula_term_bounds_str)) return; 
     351    CTimer::get("XIOS").resume(); 
     352    axisgroup_hdl->formula_term_bounds.setValue(formula_term_bounds_str); 
     353    CTimer::get("XIOS").suspend(); 
     354  } 
     355 
     356  void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size) 
     357  { 
     358    CTimer::get("XIOS").resume(); 
     359    if (!string_copy(axisgroup_hdl->formula_term_bounds.getInheritedValue(), formula_term_bounds, formula_term_bounds_size)) 
     360      ERROR("void cxios_get_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl, char * formula_term_bounds, int formula_term_bounds_size)", << "Input string is too short"); 
     361    CTimer::get("XIOS").suspend(); 
     362  } 
     363 
     364  bool cxios_is_defined_axisgroup_formula_term_bounds(axisgroup_Ptr axisgroup_hdl) 
     365  { 
     366     CTimer::get("XIOS").resume(); 
     367     bool isDefined = axisgroup_hdl->formula_term_bounds.hasInheritedValue(); 
    160368     CTimer::get("XIOS").suspend(); 
    161369     return isDefined; 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/iccalendar_wrapper_attr.cpp

    r674 r1492  
    1818  typedef xios::CCalendarWrapper* calendar_wrapper_Ptr; 
    1919 
     20  void cxios_set_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    calendar_wrapper_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(calendar_wrapper_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_calendar_wrapper_comment(calendar_wrapper_Ptr calendar_wrapper_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = calendar_wrapper_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    2046  void cxios_set_calendar_wrapper_day_length(calendar_wrapper_Ptr calendar_wrapper_hdl, int day_length) 
    2147  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icdomain_attr.cpp

    r1158 r1492  
    9393 
    9494 
     95  void cxios_set_domain_bounds_lat_name(domain_Ptr domain_hdl, const char * bounds_lat_name, int bounds_lat_name_size) 
     96  { 
     97    std::string bounds_lat_name_str; 
     98    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return; 
     99    CTimer::get("XIOS").resume(); 
     100    domain_hdl->bounds_lat_name.setValue(bounds_lat_name_str); 
     101    CTimer::get("XIOS").suspend(); 
     102  } 
     103 
     104  void cxios_get_domain_bounds_lat_name(domain_Ptr domain_hdl, char * bounds_lat_name, int bounds_lat_name_size) 
     105  { 
     106    CTimer::get("XIOS").resume(); 
     107    if (!string_copy(domain_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size)) 
     108      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"); 
     109    CTimer::get("XIOS").suspend(); 
     110  } 
     111 
     112  bool cxios_is_defined_domain_bounds_lat_name(domain_Ptr domain_hdl) 
     113  { 
     114     CTimer::get("XIOS").resume(); 
     115     bool isDefined = domain_hdl->bounds_lat_name.hasInheritedValue(); 
     116     CTimer::get("XIOS").suspend(); 
     117     return isDefined; 
     118  } 
     119 
     120 
    95121  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int* extent) 
    96122  { 
     
    143169 
    144170 
     171  void cxios_set_domain_bounds_lon_name(domain_Ptr domain_hdl, const char * bounds_lon_name, int bounds_lon_name_size) 
     172  { 
     173    std::string bounds_lon_name_str; 
     174    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return; 
     175    CTimer::get("XIOS").resume(); 
     176    domain_hdl->bounds_lon_name.setValue(bounds_lon_name_str); 
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  void cxios_get_domain_bounds_lon_name(domain_Ptr domain_hdl, char * bounds_lon_name, int bounds_lon_name_size) 
     181  { 
     182    CTimer::get("XIOS").resume(); 
     183    if (!string_copy(domain_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size)) 
     184      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"); 
     185    CTimer::get("XIOS").suspend(); 
     186  } 
     187 
     188  bool cxios_is_defined_domain_bounds_lon_name(domain_Ptr domain_hdl) 
     189  { 
     190     CTimer::get("XIOS").resume(); 
     191     bool isDefined = domain_hdl->bounds_lon_name.hasInheritedValue(); 
     192     CTimer::get("XIOS").suspend(); 
     193     return isDefined; 
     194  } 
     195 
     196 
     197  void cxios_set_domain_comment(domain_Ptr domain_hdl, const char * comment, int comment_size) 
     198  { 
     199    std::string comment_str; 
     200    if (!cstr2string(comment, comment_size, comment_str)) return; 
     201    CTimer::get("XIOS").resume(); 
     202    domain_hdl->comment.setValue(comment_str); 
     203    CTimer::get("XIOS").suspend(); 
     204  } 
     205 
     206  void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size) 
     207  { 
     208    CTimer::get("XIOS").resume(); 
     209    if (!string_copy(domain_hdl->comment.getInheritedValue(), comment, comment_size)) 
     210      ERROR("void cxios_get_domain_comment(domain_Ptr domain_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     211    CTimer::get("XIOS").suspend(); 
     212  } 
     213 
     214  bool cxios_is_defined_domain_comment(domain_Ptr domain_hdl) 
     215  { 
     216     CTimer::get("XIOS").resume(); 
     217     bool isDefined = domain_hdl->comment.hasInheritedValue(); 
     218     CTimer::get("XIOS").suspend(); 
     219     return isDefined; 
     220  } 
     221 
     222 
    145223  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim) 
    146224  { 
     
    308386 
    309387 
     388  void cxios_set_domain_dim_i_name(domain_Ptr domain_hdl, const char * dim_i_name, int dim_i_name_size) 
     389  { 
     390    std::string dim_i_name_str; 
     391    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return; 
     392    CTimer::get("XIOS").resume(); 
     393    domain_hdl->dim_i_name.setValue(dim_i_name_str); 
     394    CTimer::get("XIOS").suspend(); 
     395  } 
     396 
     397  void cxios_get_domain_dim_i_name(domain_Ptr domain_hdl, char * dim_i_name, int dim_i_name_size) 
     398  { 
     399    CTimer::get("XIOS").resume(); 
     400    if (!string_copy(domain_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size)) 
     401      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"); 
     402    CTimer::get("XIOS").suspend(); 
     403  } 
     404 
     405  bool cxios_is_defined_domain_dim_i_name(domain_Ptr domain_hdl) 
     406  { 
     407     CTimer::get("XIOS").resume(); 
     408     bool isDefined = domain_hdl->dim_i_name.hasInheritedValue(); 
     409     CTimer::get("XIOS").suspend(); 
     410     return isDefined; 
     411  } 
     412 
     413 
     414  void cxios_set_domain_dim_j_name(domain_Ptr domain_hdl, const char * dim_j_name, int dim_j_name_size) 
     415  { 
     416    std::string dim_j_name_str; 
     417    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return; 
     418    CTimer::get("XIOS").resume(); 
     419    domain_hdl->dim_j_name.setValue(dim_j_name_str); 
     420    CTimer::get("XIOS").suspend(); 
     421  } 
     422 
     423  void cxios_get_domain_dim_j_name(domain_Ptr domain_hdl, char * dim_j_name, int dim_j_name_size) 
     424  { 
     425    CTimer::get("XIOS").resume(); 
     426    if (!string_copy(domain_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size)) 
     427      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"); 
     428    CTimer::get("XIOS").suspend(); 
     429  } 
     430 
     431  bool cxios_is_defined_domain_dim_j_name(domain_Ptr domain_hdl) 
     432  { 
     433     CTimer::get("XIOS").resume(); 
     434     bool isDefined = domain_hdl->dim_j_name.hasInheritedValue(); 
     435     CTimer::get("XIOS").suspend(); 
     436     return isDefined; 
     437  } 
     438 
     439 
    310440  void cxios_set_domain_domain_ref(domain_Ptr domain_hdl, const char * domain_ref, int domain_ref_size) 
    311441  { 
     
    430560 
    431561 
     562  void cxios_set_domain_lat_name(domain_Ptr domain_hdl, const char * lat_name, int lat_name_size) 
     563  { 
     564    std::string lat_name_str; 
     565    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return; 
     566    CTimer::get("XIOS").resume(); 
     567    domain_hdl->lat_name.setValue(lat_name_str); 
     568    CTimer::get("XIOS").suspend(); 
     569  } 
     570 
     571  void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size) 
     572  { 
     573    CTimer::get("XIOS").resume(); 
     574    if (!string_copy(domain_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size)) 
     575      ERROR("void cxios_get_domain_lat_name(domain_Ptr domain_hdl, char * lat_name, int lat_name_size)", << "Input string is too short"); 
     576    CTimer::get("XIOS").suspend(); 
     577  } 
     578 
     579  bool cxios_is_defined_domain_lat_name(domain_Ptr domain_hdl) 
     580  { 
     581     CTimer::get("XIOS").resume(); 
     582     bool isDefined = domain_hdl->lat_name.hasInheritedValue(); 
     583     CTimer::get("XIOS").suspend(); 
     584     return isDefined; 
     585  } 
     586 
     587 
    432588  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int* extent) 
    433589  { 
     
    480636 
    481637 
     638  void cxios_set_domain_lon_name(domain_Ptr domain_hdl, const char * lon_name, int lon_name_size) 
     639  { 
     640    std::string lon_name_str; 
     641    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return; 
     642    CTimer::get("XIOS").resume(); 
     643    domain_hdl->lon_name.setValue(lon_name_str); 
     644    CTimer::get("XIOS").suspend(); 
     645  } 
     646 
     647  void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size) 
     648  { 
     649    CTimer::get("XIOS").resume(); 
     650    if (!string_copy(domain_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size)) 
     651      ERROR("void cxios_get_domain_lon_name(domain_Ptr domain_hdl, char * lon_name, int lon_name_size)", << "Input string is too short"); 
     652    CTimer::get("XIOS").suspend(); 
     653  } 
     654 
     655  bool cxios_is_defined_domain_lon_name(domain_Ptr domain_hdl) 
     656  { 
     657     CTimer::get("XIOS").resume(); 
     658     bool isDefined = domain_hdl->lon_name.hasInheritedValue(); 
     659     CTimer::get("XIOS").suspend(); 
     660     return isDefined; 
     661  } 
     662 
     663 
    482664  void cxios_set_domain_long_name(domain_Ptr domain_hdl, const char * long_name, int long_name_size) 
    483665  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icdomaingroup_attr.cpp

    r1158 r1492  
    9393 
    9494 
     95  void cxios_set_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lat_name, int bounds_lat_name_size) 
     96  { 
     97    std::string bounds_lat_name_str; 
     98    if (!cstr2string(bounds_lat_name, bounds_lat_name_size, bounds_lat_name_str)) return; 
     99    CTimer::get("XIOS").resume(); 
     100    domaingroup_hdl->bounds_lat_name.setValue(bounds_lat_name_str); 
     101    CTimer::get("XIOS").suspend(); 
     102  } 
     103 
     104  void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size) 
     105  { 
     106    CTimer::get("XIOS").resume(); 
     107    if (!string_copy(domaingroup_hdl->bounds_lat_name.getInheritedValue(), bounds_lat_name, bounds_lat_name_size)) 
     108      ERROR("void cxios_get_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lat_name, int bounds_lat_name_size)", << "Input string is too short"); 
     109    CTimer::get("XIOS").suspend(); 
     110  } 
     111 
     112  bool cxios_is_defined_domaingroup_bounds_lat_name(domaingroup_Ptr domaingroup_hdl) 
     113  { 
     114     CTimer::get("XIOS").resume(); 
     115     bool isDefined = domaingroup_hdl->bounds_lat_name.hasInheritedValue(); 
     116     CTimer::get("XIOS").suspend(); 
     117     return isDefined; 
     118  } 
     119 
     120 
    95121  void cxios_set_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int* extent) 
    96122  { 
     
    143169 
    144170 
     171  void cxios_set_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, const char * bounds_lon_name, int bounds_lon_name_size) 
     172  { 
     173    std::string bounds_lon_name_str; 
     174    if (!cstr2string(bounds_lon_name, bounds_lon_name_size, bounds_lon_name_str)) return; 
     175    CTimer::get("XIOS").resume(); 
     176    domaingroup_hdl->bounds_lon_name.setValue(bounds_lon_name_str); 
     177    CTimer::get("XIOS").suspend(); 
     178  } 
     179 
     180  void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size) 
     181  { 
     182    CTimer::get("XIOS").resume(); 
     183    if (!string_copy(domaingroup_hdl->bounds_lon_name.getInheritedValue(), bounds_lon_name, bounds_lon_name_size)) 
     184      ERROR("void cxios_get_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl, char * bounds_lon_name, int bounds_lon_name_size)", << "Input string is too short"); 
     185    CTimer::get("XIOS").suspend(); 
     186  } 
     187 
     188  bool cxios_is_defined_domaingroup_bounds_lon_name(domaingroup_Ptr domaingroup_hdl) 
     189  { 
     190     CTimer::get("XIOS").resume(); 
     191     bool isDefined = domaingroup_hdl->bounds_lon_name.hasInheritedValue(); 
     192     CTimer::get("XIOS").suspend(); 
     193     return isDefined; 
     194  } 
     195 
     196 
     197  void cxios_set_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, const char * comment, int comment_size) 
     198  { 
     199    std::string comment_str; 
     200    if (!cstr2string(comment, comment_size, comment_str)) return; 
     201    CTimer::get("XIOS").resume(); 
     202    domaingroup_hdl->comment.setValue(comment_str); 
     203    CTimer::get("XIOS").suspend(); 
     204  } 
     205 
     206  void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size) 
     207  { 
     208    CTimer::get("XIOS").resume(); 
     209    if (!string_copy(domaingroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     210      ERROR("void cxios_get_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     211    CTimer::get("XIOS").suspend(); 
     212  } 
     213 
     214  bool cxios_is_defined_domaingroup_comment(domaingroup_Ptr domaingroup_hdl) 
     215  { 
     216     CTimer::get("XIOS").resume(); 
     217     bool isDefined = domaingroup_hdl->comment.hasInheritedValue(); 
     218     CTimer::get("XIOS").suspend(); 
     219     return isDefined; 
     220  } 
     221 
     222 
    145223  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim) 
    146224  { 
     
    308386 
    309387 
     388  void cxios_set_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, const char * dim_i_name, int dim_i_name_size) 
     389  { 
     390    std::string dim_i_name_str; 
     391    if (!cstr2string(dim_i_name, dim_i_name_size, dim_i_name_str)) return; 
     392    CTimer::get("XIOS").resume(); 
     393    domaingroup_hdl->dim_i_name.setValue(dim_i_name_str); 
     394    CTimer::get("XIOS").suspend(); 
     395  } 
     396 
     397  void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size) 
     398  { 
     399    CTimer::get("XIOS").resume(); 
     400    if (!string_copy(domaingroup_hdl->dim_i_name.getInheritedValue(), dim_i_name, dim_i_name_size)) 
     401      ERROR("void cxios_get_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl, char * dim_i_name, int dim_i_name_size)", << "Input string is too short"); 
     402    CTimer::get("XIOS").suspend(); 
     403  } 
     404 
     405  bool cxios_is_defined_domaingroup_dim_i_name(domaingroup_Ptr domaingroup_hdl) 
     406  { 
     407     CTimer::get("XIOS").resume(); 
     408     bool isDefined = domaingroup_hdl->dim_i_name.hasInheritedValue(); 
     409     CTimer::get("XIOS").suspend(); 
     410     return isDefined; 
     411  } 
     412 
     413 
     414  void cxios_set_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, const char * dim_j_name, int dim_j_name_size) 
     415  { 
     416    std::string dim_j_name_str; 
     417    if (!cstr2string(dim_j_name, dim_j_name_size, dim_j_name_str)) return; 
     418    CTimer::get("XIOS").resume(); 
     419    domaingroup_hdl->dim_j_name.setValue(dim_j_name_str); 
     420    CTimer::get("XIOS").suspend(); 
     421  } 
     422 
     423  void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size) 
     424  { 
     425    CTimer::get("XIOS").resume(); 
     426    if (!string_copy(domaingroup_hdl->dim_j_name.getInheritedValue(), dim_j_name, dim_j_name_size)) 
     427      ERROR("void cxios_get_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl, char * dim_j_name, int dim_j_name_size)", << "Input string is too short"); 
     428    CTimer::get("XIOS").suspend(); 
     429  } 
     430 
     431  bool cxios_is_defined_domaingroup_dim_j_name(domaingroup_Ptr domaingroup_hdl) 
     432  { 
     433     CTimer::get("XIOS").resume(); 
     434     bool isDefined = domaingroup_hdl->dim_j_name.hasInheritedValue(); 
     435     CTimer::get("XIOS").suspend(); 
     436     return isDefined; 
     437  } 
     438 
     439 
    310440  void cxios_set_domaingroup_domain_ref(domaingroup_Ptr domaingroup_hdl, const char * domain_ref, int domain_ref_size) 
    311441  { 
     
    456586 
    457587 
     588  void cxios_set_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, const char * lat_name, int lat_name_size) 
     589  { 
     590    std::string lat_name_str; 
     591    if (!cstr2string(lat_name, lat_name_size, lat_name_str)) return; 
     592    CTimer::get("XIOS").resume(); 
     593    domaingroup_hdl->lat_name.setValue(lat_name_str); 
     594    CTimer::get("XIOS").suspend(); 
     595  } 
     596 
     597  void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size) 
     598  { 
     599    CTimer::get("XIOS").resume(); 
     600    if (!string_copy(domaingroup_hdl->lat_name.getInheritedValue(), lat_name, lat_name_size)) 
     601      ERROR("void cxios_get_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl, char * lat_name, int lat_name_size)", << "Input string is too short"); 
     602    CTimer::get("XIOS").suspend(); 
     603  } 
     604 
     605  bool cxios_is_defined_domaingroup_lat_name(domaingroup_Ptr domaingroup_hdl) 
     606  { 
     607     CTimer::get("XIOS").resume(); 
     608     bool isDefined = domaingroup_hdl->lat_name.hasInheritedValue(); 
     609     CTimer::get("XIOS").suspend(); 
     610     return isDefined; 
     611  } 
     612 
     613 
    458614  void cxios_set_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int* extent) 
    459615  { 
     
    506662 
    507663 
     664  void cxios_set_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, const char * lon_name, int lon_name_size) 
     665  { 
     666    std::string lon_name_str; 
     667    if (!cstr2string(lon_name, lon_name_size, lon_name_str)) return; 
     668    CTimer::get("XIOS").resume(); 
     669    domaingroup_hdl->lon_name.setValue(lon_name_str); 
     670    CTimer::get("XIOS").suspend(); 
     671  } 
     672 
     673  void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size) 
     674  { 
     675    CTimer::get("XIOS").resume(); 
     676    if (!string_copy(domaingroup_hdl->lon_name.getInheritedValue(), lon_name, lon_name_size)) 
     677      ERROR("void cxios_get_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl, char * lon_name, int lon_name_size)", << "Input string is too short"); 
     678    CTimer::get("XIOS").suspend(); 
     679  } 
     680 
     681  bool cxios_is_defined_domaingroup_lon_name(domaingroup_Ptr domaingroup_hdl) 
     682  { 
     683     CTimer::get("XIOS").resume(); 
     684     bool isDefined = domaingroup_hdl->lon_name.hasInheritedValue(); 
     685     CTimer::get("XIOS").suspend(); 
     686     return isDefined; 
     687  } 
     688 
     689 
    508690  void cxios_set_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, const char * long_name, int long_name_size) 
    509691  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icfield_attr.cpp

    r1201 r1492  
    142142 
    143143 
     144  void cxios_set_field_comment(field_Ptr field_hdl, const char * comment, int comment_size) 
     145  { 
     146    std::string comment_str; 
     147    if (!cstr2string(comment, comment_size, comment_str)) return; 
     148    CTimer::get("XIOS").resume(); 
     149    field_hdl->comment.setValue(comment_str); 
     150    CTimer::get("XIOS").suspend(); 
     151  } 
     152 
     153  void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size) 
     154  { 
     155    CTimer::get("XIOS").resume(); 
     156    if (!string_copy(field_hdl->comment.getInheritedValue(), comment, comment_size)) 
     157      ERROR("void cxios_get_field_comment(field_Ptr field_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     158    CTimer::get("XIOS").suspend(); 
     159  } 
     160 
     161  bool cxios_is_defined_field_comment(field_Ptr field_hdl) 
     162  { 
     163     CTimer::get("XIOS").resume(); 
     164     bool isDefined = field_hdl->comment.hasInheritedValue(); 
     165     CTimer::get("XIOS").suspend(); 
     166     return isDefined; 
     167  } 
     168 
     169 
    144170  void cxios_set_field_compression_level(field_Ptr field_hdl, int compression_level) 
    145171  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icfieldgroup_attr.cpp

    r1201 r1492  
    142142 
    143143 
     144  void cxios_set_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, const char * comment, int comment_size) 
     145  { 
     146    std::string comment_str; 
     147    if (!cstr2string(comment, comment_size, comment_str)) return; 
     148    CTimer::get("XIOS").resume(); 
     149    fieldgroup_hdl->comment.setValue(comment_str); 
     150    CTimer::get("XIOS").suspend(); 
     151  } 
     152 
     153  void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size) 
     154  { 
     155    CTimer::get("XIOS").resume(); 
     156    if (!string_copy(fieldgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     157      ERROR("void cxios_get_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     158    CTimer::get("XIOS").suspend(); 
     159  } 
     160 
     161  bool cxios_is_defined_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl) 
     162  { 
     163     CTimer::get("XIOS").resume(); 
     164     bool isDefined = fieldgroup_hdl->comment.hasInheritedValue(); 
     165     CTimer::get("XIOS").suspend(); 
     166     return isDefined; 
     167  } 
     168 
     169 
    144170  void cxios_set_fieldgroup_compression_level(fieldgroup_Ptr fieldgroup_hdl, int compression_level) 
    145171  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icfile_attr.cpp

    r1201 r1492  
    4141 
    4242 
     43  void cxios_set_file_comment(file_Ptr file_hdl, const char * comment, int comment_size) 
     44  { 
     45    std::string comment_str; 
     46    if (!cstr2string(comment, comment_size, comment_str)) return; 
     47    CTimer::get("XIOS").resume(); 
     48    file_hdl->comment.setValue(comment_str); 
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
     52  void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size) 
     53  { 
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(file_hdl->comment.getInheritedValue(), comment, comment_size)) 
     56      ERROR("void cxios_get_file_comment(file_Ptr file_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_file_comment(file_Ptr file_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = file_hdl->comment.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4369  void cxios_set_file_compression_level(file_Ptr file_hdl, int compression_level) 
    4470  { 
     
    402428 
    403429 
     430  void cxios_set_file_read_metadata_par(file_Ptr file_hdl, bool read_metadata_par) 
     431  { 
     432    CTimer::get("XIOS").resume(); 
     433    file_hdl->read_metadata_par.setValue(read_metadata_par); 
     434    CTimer::get("XIOS").suspend(); 
     435  } 
     436 
     437  void cxios_get_file_read_metadata_par(file_Ptr file_hdl, bool* read_metadata_par) 
     438  { 
     439    CTimer::get("XIOS").resume(); 
     440    *read_metadata_par = file_hdl->read_metadata_par.getInheritedValue(); 
     441    CTimer::get("XIOS").suspend(); 
     442  } 
     443 
     444  bool cxios_is_defined_file_read_metadata_par(file_Ptr file_hdl) 
     445  { 
     446     CTimer::get("XIOS").resume(); 
     447     bool isDefined = file_hdl->read_metadata_par.hasInheritedValue(); 
     448     CTimer::get("XIOS").suspend(); 
     449     return isDefined; 
     450  } 
     451 
     452 
    404453  void cxios_set_file_record_offset(file_Ptr file_hdl, int record_offset) 
    405454  { 
     
    420469     CTimer::get("XIOS").resume(); 
    421470     bool isDefined = file_hdl->record_offset.hasInheritedValue(); 
     471     CTimer::get("XIOS").suspend(); 
     472     return isDefined; 
     473  } 
     474 
     475 
     476  void cxios_set_file_split_end_offset(file_Ptr file_hdl, cxios_duration split_end_offset_c) 
     477  { 
     478    CTimer::get("XIOS").resume(); 
     479    file_hdl->split_end_offset.allocate(); 
     480    CDuration& split_end_offset = file_hdl->split_end_offset.get(); 
     481    split_end_offset.year = split_end_offset_c.year; 
     482    split_end_offset.month = split_end_offset_c.month; 
     483    split_end_offset.day = split_end_offset_c.day; 
     484    split_end_offset.hour = split_end_offset_c.hour; 
     485    split_end_offset.minute = split_end_offset_c.minute; 
     486    split_end_offset.second = split_end_offset_c.second; 
     487    split_end_offset.timestep = split_end_offset_c.timestep; 
     488    CTimer::get("XIOS").suspend(); 
     489  } 
     490 
     491  void cxios_get_file_split_end_offset(file_Ptr file_hdl, cxios_duration* split_end_offset_c) 
     492  { 
     493    CTimer::get("XIOS").resume(); 
     494    CDuration split_end_offset = file_hdl->split_end_offset.getInheritedValue(); 
     495    split_end_offset_c->year = split_end_offset.year; 
     496    split_end_offset_c->month = split_end_offset.month; 
     497    split_end_offset_c->day = split_end_offset.day; 
     498    split_end_offset_c->hour = split_end_offset.hour; 
     499    split_end_offset_c->minute = split_end_offset.minute; 
     500    split_end_offset_c->second = split_end_offset.second; 
     501    split_end_offset_c->timestep = split_end_offset.timestep; 
     502    CTimer::get("XIOS").suspend(); 
     503  } 
     504 
     505  bool cxios_is_defined_file_split_end_offset(file_Ptr file_hdl) 
     506  { 
     507     CTimer::get("XIOS").resume(); 
     508     bool isDefined = file_hdl->split_end_offset.hasInheritedValue(); 
    422509     CTimer::get("XIOS").suspend(); 
    423510     return isDefined; 
     
    489576 
    490577 
     578  void cxios_set_file_split_last_date(file_Ptr file_hdl, const char * split_last_date, int split_last_date_size) 
     579  { 
     580    std::string split_last_date_str; 
     581    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return; 
     582    CTimer::get("XIOS").resume(); 
     583    file_hdl->split_last_date.setValue(split_last_date_str); 
     584    CTimer::get("XIOS").suspend(); 
     585  } 
     586 
     587  void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size) 
     588  { 
     589    CTimer::get("XIOS").resume(); 
     590    if (!string_copy(file_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size)) 
     591      ERROR("void cxios_get_file_split_last_date(file_Ptr file_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short"); 
     592    CTimer::get("XIOS").suspend(); 
     593  } 
     594 
     595  bool cxios_is_defined_file_split_last_date(file_Ptr file_hdl) 
     596  { 
     597     CTimer::get("XIOS").resume(); 
     598     bool isDefined = file_hdl->split_last_date.hasInheritedValue(); 
     599     CTimer::get("XIOS").suspend(); 
     600     return isDefined; 
     601  } 
     602 
     603 
     604  void cxios_set_file_split_start_offset(file_Ptr file_hdl, cxios_duration split_start_offset_c) 
     605  { 
     606    CTimer::get("XIOS").resume(); 
     607    file_hdl->split_start_offset.allocate(); 
     608    CDuration& split_start_offset = file_hdl->split_start_offset.get(); 
     609    split_start_offset.year = split_start_offset_c.year; 
     610    split_start_offset.month = split_start_offset_c.month; 
     611    split_start_offset.day = split_start_offset_c.day; 
     612    split_start_offset.hour = split_start_offset_c.hour; 
     613    split_start_offset.minute = split_start_offset_c.minute; 
     614    split_start_offset.second = split_start_offset_c.second; 
     615    split_start_offset.timestep = split_start_offset_c.timestep; 
     616    CTimer::get("XIOS").suspend(); 
     617  } 
     618 
     619  void cxios_get_file_split_start_offset(file_Ptr file_hdl, cxios_duration* split_start_offset_c) 
     620  { 
     621    CTimer::get("XIOS").resume(); 
     622    CDuration split_start_offset = file_hdl->split_start_offset.getInheritedValue(); 
     623    split_start_offset_c->year = split_start_offset.year; 
     624    split_start_offset_c->month = split_start_offset.month; 
     625    split_start_offset_c->day = split_start_offset.day; 
     626    split_start_offset_c->hour = split_start_offset.hour; 
     627    split_start_offset_c->minute = split_start_offset.minute; 
     628    split_start_offset_c->second = split_start_offset.second; 
     629    split_start_offset_c->timestep = split_start_offset.timestep; 
     630    CTimer::get("XIOS").suspend(); 
     631  } 
     632 
     633  bool cxios_is_defined_file_split_start_offset(file_Ptr file_hdl) 
     634  { 
     635     CTimer::get("XIOS").resume(); 
     636     bool isDefined = file_hdl->split_start_offset.hasInheritedValue(); 
     637     CTimer::get("XIOS").suspend(); 
     638     return isDefined; 
     639  } 
     640 
     641 
    491642  void cxios_set_file_sync_freq(file_Ptr file_hdl, cxios_duration sync_freq_c) 
    492643  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icfilegroup_attr.cpp

    r1201 r1492  
    4141 
    4242 
     43  void cxios_set_filegroup_comment(filegroup_Ptr filegroup_hdl, const char * comment, int comment_size) 
     44  { 
     45    std::string comment_str; 
     46    if (!cstr2string(comment, comment_size, comment_str)) return; 
     47    CTimer::get("XIOS").resume(); 
     48    filegroup_hdl->comment.setValue(comment_str); 
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
     52  void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size) 
     53  { 
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(filegroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     56      ERROR("void cxios_get_filegroup_comment(filegroup_Ptr filegroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_filegroup_comment(filegroup_Ptr filegroup_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = filegroup_hdl->comment.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4369  void cxios_set_filegroup_compression_level(filegroup_Ptr filegroup_hdl, int compression_level) 
    4470  { 
     
    428454 
    429455 
     456  void cxios_set_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool read_metadata_par) 
     457  { 
     458    CTimer::get("XIOS").resume(); 
     459    filegroup_hdl->read_metadata_par.setValue(read_metadata_par); 
     460    CTimer::get("XIOS").suspend(); 
     461  } 
     462 
     463  void cxios_get_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool* read_metadata_par) 
     464  { 
     465    CTimer::get("XIOS").resume(); 
     466    *read_metadata_par = filegroup_hdl->read_metadata_par.getInheritedValue(); 
     467    CTimer::get("XIOS").suspend(); 
     468  } 
     469 
     470  bool cxios_is_defined_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl) 
     471  { 
     472     CTimer::get("XIOS").resume(); 
     473     bool isDefined = filegroup_hdl->read_metadata_par.hasInheritedValue(); 
     474     CTimer::get("XIOS").suspend(); 
     475     return isDefined; 
     476  } 
     477 
     478 
    430479  void cxios_set_filegroup_record_offset(filegroup_Ptr filegroup_hdl, int record_offset) 
    431480  { 
     
    446495     CTimer::get("XIOS").resume(); 
    447496     bool isDefined = filegroup_hdl->record_offset.hasInheritedValue(); 
     497     CTimer::get("XIOS").suspend(); 
     498     return isDefined; 
     499  } 
     500 
     501 
     502  void cxios_set_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_end_offset_c) 
     503  { 
     504    CTimer::get("XIOS").resume(); 
     505    filegroup_hdl->split_end_offset.allocate(); 
     506    CDuration& split_end_offset = filegroup_hdl->split_end_offset.get(); 
     507    split_end_offset.year = split_end_offset_c.year; 
     508    split_end_offset.month = split_end_offset_c.month; 
     509    split_end_offset.day = split_end_offset_c.day; 
     510    split_end_offset.hour = split_end_offset_c.hour; 
     511    split_end_offset.minute = split_end_offset_c.minute; 
     512    split_end_offset.second = split_end_offset_c.second; 
     513    split_end_offset.timestep = split_end_offset_c.timestep; 
     514    CTimer::get("XIOS").suspend(); 
     515  } 
     516 
     517  void cxios_get_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_end_offset_c) 
     518  { 
     519    CTimer::get("XIOS").resume(); 
     520    CDuration split_end_offset = filegroup_hdl->split_end_offset.getInheritedValue(); 
     521    split_end_offset_c->year = split_end_offset.year; 
     522    split_end_offset_c->month = split_end_offset.month; 
     523    split_end_offset_c->day = split_end_offset.day; 
     524    split_end_offset_c->hour = split_end_offset.hour; 
     525    split_end_offset_c->minute = split_end_offset.minute; 
     526    split_end_offset_c->second = split_end_offset.second; 
     527    split_end_offset_c->timestep = split_end_offset.timestep; 
     528    CTimer::get("XIOS").suspend(); 
     529  } 
     530 
     531  bool cxios_is_defined_filegroup_split_end_offset(filegroup_Ptr filegroup_hdl) 
     532  { 
     533     CTimer::get("XIOS").resume(); 
     534     bool isDefined = filegroup_hdl->split_end_offset.hasInheritedValue(); 
    448535     CTimer::get("XIOS").suspend(); 
    449536     return isDefined; 
     
    515602 
    516603 
     604  void cxios_set_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, const char * split_last_date, int split_last_date_size) 
     605  { 
     606    std::string split_last_date_str; 
     607    if (!cstr2string(split_last_date, split_last_date_size, split_last_date_str)) return; 
     608    CTimer::get("XIOS").resume(); 
     609    filegroup_hdl->split_last_date.setValue(split_last_date_str); 
     610    CTimer::get("XIOS").suspend(); 
     611  } 
     612 
     613  void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size) 
     614  { 
     615    CTimer::get("XIOS").resume(); 
     616    if (!string_copy(filegroup_hdl->split_last_date.getInheritedValue(), split_last_date, split_last_date_size)) 
     617      ERROR("void cxios_get_filegroup_split_last_date(filegroup_Ptr filegroup_hdl, char * split_last_date, int split_last_date_size)", << "Input string is too short"); 
     618    CTimer::get("XIOS").suspend(); 
     619  } 
     620 
     621  bool cxios_is_defined_filegroup_split_last_date(filegroup_Ptr filegroup_hdl) 
     622  { 
     623     CTimer::get("XIOS").resume(); 
     624     bool isDefined = filegroup_hdl->split_last_date.hasInheritedValue(); 
     625     CTimer::get("XIOS").suspend(); 
     626     return isDefined; 
     627  } 
     628 
     629 
     630  void cxios_set_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration split_start_offset_c) 
     631  { 
     632    CTimer::get("XIOS").resume(); 
     633    filegroup_hdl->split_start_offset.allocate(); 
     634    CDuration& split_start_offset = filegroup_hdl->split_start_offset.get(); 
     635    split_start_offset.year = split_start_offset_c.year; 
     636    split_start_offset.month = split_start_offset_c.month; 
     637    split_start_offset.day = split_start_offset_c.day; 
     638    split_start_offset.hour = split_start_offset_c.hour; 
     639    split_start_offset.minute = split_start_offset_c.minute; 
     640    split_start_offset.second = split_start_offset_c.second; 
     641    split_start_offset.timestep = split_start_offset_c.timestep; 
     642    CTimer::get("XIOS").suspend(); 
     643  } 
     644 
     645  void cxios_get_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl, cxios_duration* split_start_offset_c) 
     646  { 
     647    CTimer::get("XIOS").resume(); 
     648    CDuration split_start_offset = filegroup_hdl->split_start_offset.getInheritedValue(); 
     649    split_start_offset_c->year = split_start_offset.year; 
     650    split_start_offset_c->month = split_start_offset.month; 
     651    split_start_offset_c->day = split_start_offset.day; 
     652    split_start_offset_c->hour = split_start_offset.hour; 
     653    split_start_offset_c->minute = split_start_offset.minute; 
     654    split_start_offset_c->second = split_start_offset.second; 
     655    split_start_offset_c->timestep = split_start_offset.timestep; 
     656    CTimer::get("XIOS").suspend(); 
     657  } 
     658 
     659  bool cxios_is_defined_filegroup_split_start_offset(filegroup_Ptr filegroup_hdl) 
     660  { 
     661     CTimer::get("XIOS").resume(); 
     662     bool isDefined = filegroup_hdl->split_start_offset.hasInheritedValue(); 
     663     CTimer::get("XIOS").suspend(); 
     664     return isDefined; 
     665  } 
     666 
     667 
    517668  void cxios_set_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, cxios_duration sync_freq_c) 
    518669  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icgrid_attr.cpp

    r932 r1492  
    1818  typedef xios::CGrid* grid_Ptr; 
    1919 
     20  void cxios_set_grid_comment(grid_Ptr grid_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    grid_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(grid_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_grid_comment(grid_Ptr grid_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_grid_comment(grid_Ptr grid_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = grid_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    2046  void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size) 
    2147  { 
     
    4470 
    4571 
     72  void cxios_set_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent) 
     73  { 
     74    CTimer::get("XIOS").resume(); 
     75    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     76    grid_hdl->mask_0d.reference(tmp.copy()); 
     77     CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_grid_mask_0d(grid_Ptr grid_hdl, bool* mask_0d, int* extent) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     84    tmp=grid_hdl->mask_0d.getInheritedValue(); 
     85     CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_grid_mask_0d(grid_Ptr grid_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = grid_hdl->mask_0d.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
    4697  void cxios_set_grid_mask_1d(grid_Ptr grid_hdl, bool* mask_1d, int* extent) 
    4798  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icgridgroup_attr.cpp

    r932 r1492  
    1818  typedef xios::CGridGroup* gridgroup_Ptr; 
    1919 
     20  void cxios_set_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, const char * comment, int comment_size) 
     21  { 
     22    std::string comment_str; 
     23    if (!cstr2string(comment, comment_size, comment_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    gridgroup_hdl->comment.setValue(comment_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(gridgroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     33      ERROR("void cxios_get_gridgroup_comment(gridgroup_Ptr gridgroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_gridgroup_comment(gridgroup_Ptr gridgroup_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = gridgroup_hdl->comment.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
    2046  void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size) 
    2147  { 
     
    7096 
    7197 
     98  void cxios_set_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent) 
     99  { 
     100    CTimer::get("XIOS").resume(); 
     101    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     102    gridgroup_hdl->mask_0d.reference(tmp.copy()); 
     103     CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl, bool* mask_0d, int* extent) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    CArray<bool,1> tmp(mask_0d, shape(extent[0]), neverDeleteData); 
     110    tmp=gridgroup_hdl->mask_0d.getInheritedValue(); 
     111     CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_gridgroup_mask_0d(gridgroup_Ptr gridgroup_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = gridgroup_hdl->mask_0d.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
    72123  void cxios_set_gridgroup_mask_1d(gridgroup_Ptr gridgroup_hdl, bool* mask_1d, int* extent) 
    73124  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icinterpolate_domain_attr.cpp

    r1201 r1492  
    1818  typedef xios::CInterpolateDomain* interpolate_domain_Ptr; 
    1919 
     20  void cxios_set_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool detect_missing_value) 
     21  { 
     22    CTimer::get("XIOS").resume(); 
     23    interpolate_domain_hdl->detect_missing_value.setValue(detect_missing_value); 
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
     27  void cxios_get_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl, bool* detect_missing_value) 
     28  { 
     29    CTimer::get("XIOS").resume(); 
     30    *detect_missing_value = interpolate_domain_hdl->detect_missing_value.getInheritedValue(); 
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_interpolate_domain_detect_missing_value(interpolate_domain_Ptr interpolate_domain_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = interpolate_domain_hdl->detect_missing_value.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    2043  void cxios_set_interpolate_domain_mode(interpolate_domain_Ptr interpolate_domain_hdl, const char * mode, int mode_size) 
    2144  { 
     
    90113 
    91114 
     115  void cxios_set_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, const char * read_write_convention, int read_write_convention_size) 
     116  { 
     117    std::string read_write_convention_str; 
     118    if (!cstr2string(read_write_convention, read_write_convention_size, read_write_convention_str)) return; 
     119    CTimer::get("XIOS").resume(); 
     120    interpolate_domain_hdl->read_write_convention.fromString(read_write_convention_str); 
     121    CTimer::get("XIOS").suspend(); 
     122  } 
     123 
     124  void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size) 
     125  { 
     126    CTimer::get("XIOS").resume(); 
     127    if (!string_copy(interpolate_domain_hdl->read_write_convention.getInheritedStringValue(), read_write_convention, read_write_convention_size)) 
     128      ERROR("void cxios_get_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl, char * read_write_convention, int read_write_convention_size)", << "Input string is too short"); 
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_interpolate_domain_read_write_convention(interpolate_domain_Ptr interpolate_domain_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = interpolate_domain_hdl->read_write_convention.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    92141  void cxios_set_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool renormalize) 
    93142  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icreduce_domain_to_axis_attr.cpp

    r981 r1492  
    4444 
    4545 
     46  void cxios_set_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool local) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    reduce_domain_to_axis_hdl->local.setValue(local); 
     50    CTimer::get("XIOS").suspend(); 
     51  } 
     52 
     53  void cxios_get_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, bool* local) 
     54  { 
     55    CTimer::get("XIOS").resume(); 
     56    *local = reduce_domain_to_axis_hdl->local.getInheritedValue(); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_reduce_domain_to_axis_local(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = reduce_domain_to_axis_hdl->local.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    4669  void cxios_set_reduce_domain_to_axis_operation(reduce_domain_to_axis_Ptr reduce_domain_to_axis_hdl, const char * operation, int operation_size) 
    4770  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icreduce_domain_to_scalar_attr.cpp

    r981 r1492  
    1717{ 
    1818  typedef xios::CReduceDomainToScalar* reduce_domain_to_scalar_Ptr; 
     19 
     20  void cxios_set_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool local) 
     21  { 
     22    CTimer::get("XIOS").resume(); 
     23    reduce_domain_to_scalar_hdl->local.setValue(local); 
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
     27  void cxios_get_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, bool* local) 
     28  { 
     29    CTimer::get("XIOS").resume(); 
     30    *local = reduce_domain_to_scalar_hdl->local.getInheritedValue(); 
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_reduce_domain_to_scalar_local(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = reduce_domain_to_scalar_hdl->local.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
    1942 
    2043  void cxios_set_reduce_domain_to_scalar_operation(reduce_domain_to_scalar_Ptr reduce_domain_to_scalar_hdl, const char * operation, int operation_size) 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icscalar_attr.cpp

    r1158 r1492  
    1818  typedef xios::CScalar* scalar_Ptr; 
    1919 
     20  void cxios_set_scalar_axis_type(scalar_Ptr scalar_hdl, const char * axis_type, int axis_type_size) 
     21  { 
     22    std::string axis_type_str; 
     23    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    scalar_hdl->axis_type.fromString(axis_type_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(scalar_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     33      ERROR("void cxios_get_scalar_axis_type(scalar_Ptr scalar_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_scalar_axis_type(scalar_Ptr scalar_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = scalar_hdl->axis_type.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
     46  void cxios_set_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     50    scalar_hdl->bounds.reference(tmp.copy()); 
     51     CTimer::get("XIOS").suspend(); 
     52  } 
     53 
     54  void cxios_get_scalar_bounds(scalar_Ptr scalar_hdl, double* bounds, int* extent) 
     55  { 
     56    CTimer::get("XIOS").resume(); 
     57    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     58    tmp=scalar_hdl->bounds.getInheritedValue(); 
     59     CTimer::get("XIOS").suspend(); 
     60  } 
     61 
     62  bool cxios_is_defined_scalar_bounds(scalar_Ptr scalar_hdl) 
     63  { 
     64     CTimer::get("XIOS").resume(); 
     65     bool isDefined = scalar_hdl->bounds.hasInheritedValue(); 
     66     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
     68  } 
     69 
     70 
     71  void cxios_set_scalar_bounds_name(scalar_Ptr scalar_hdl, const char * bounds_name, int bounds_name_size) 
     72  { 
     73    std::string bounds_name_str; 
     74    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     75    CTimer::get("XIOS").resume(); 
     76    scalar_hdl->bounds_name.setValue(bounds_name_str); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    if (!string_copy(scalar_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     84      ERROR("void cxios_get_scalar_bounds_name(scalar_Ptr scalar_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     85    CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_scalar_bounds_name(scalar_Ptr scalar_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = scalar_hdl->bounds_name.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
     97  void cxios_set_scalar_comment(scalar_Ptr scalar_hdl, const char * comment, int comment_size) 
     98  { 
     99    std::string comment_str; 
     100    if (!cstr2string(comment, comment_size, comment_str)) return; 
     101    CTimer::get("XIOS").resume(); 
     102    scalar_hdl->comment.setValue(comment_str); 
     103    CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    if (!string_copy(scalar_hdl->comment.getInheritedValue(), comment, comment_size)) 
     110      ERROR("void cxios_get_scalar_comment(scalar_Ptr scalar_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     111    CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_scalar_comment(scalar_Ptr scalar_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = scalar_hdl->comment.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
     123  void cxios_set_scalar_label(scalar_Ptr scalar_hdl, const char * label, int label_size) 
     124  { 
     125    std::string label_str; 
     126    if (!cstr2string(label, label_size, label_str)) return; 
     127    CTimer::get("XIOS").resume(); 
     128    scalar_hdl->label.setValue(label_str); 
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size) 
     133  { 
     134    CTimer::get("XIOS").resume(); 
     135    if (!string_copy(scalar_hdl->label.getInheritedValue(), label, label_size)) 
     136      ERROR("void cxios_get_scalar_label(scalar_Ptr scalar_hdl, char * label, int label_size)", << "Input string is too short"); 
     137    CTimer::get("XIOS").suspend(); 
     138  } 
     139 
     140  bool cxios_is_defined_scalar_label(scalar_Ptr scalar_hdl) 
     141  { 
     142     CTimer::get("XIOS").resume(); 
     143     bool isDefined = scalar_hdl->label.hasInheritedValue(); 
     144     CTimer::get("XIOS").suspend(); 
     145     return isDefined; 
     146  } 
     147 
     148 
    20149  void cxios_set_scalar_long_name(scalar_Ptr scalar_hdl, const char * long_name, int long_name_size) 
    21150  { 
     
    70199 
    71200 
     201  void cxios_set_scalar_positive(scalar_Ptr scalar_hdl, const char * positive, int positive_size) 
     202  { 
     203    std::string positive_str; 
     204    if (!cstr2string(positive, positive_size, positive_str)) return; 
     205    CTimer::get("XIOS").resume(); 
     206    scalar_hdl->positive.fromString(positive_str); 
     207    CTimer::get("XIOS").suspend(); 
     208  } 
     209 
     210  void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size) 
     211  { 
     212    CTimer::get("XIOS").resume(); 
     213    if (!string_copy(scalar_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     214      ERROR("void cxios_get_scalar_positive(scalar_Ptr scalar_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     215    CTimer::get("XIOS").suspend(); 
     216  } 
     217 
     218  bool cxios_is_defined_scalar_positive(scalar_Ptr scalar_hdl) 
     219  { 
     220     CTimer::get("XIOS").resume(); 
     221     bool isDefined = scalar_hdl->positive.hasInheritedValue(); 
     222     CTimer::get("XIOS").suspend(); 
     223     return isDefined; 
     224  } 
     225 
     226 
    72227  void cxios_set_scalar_prec(scalar_Ptr scalar_hdl, int prec) 
    73228  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/c_attr/icscalargroup_attr.cpp

    r1158 r1492  
    1818  typedef xios::CScalarGroup* scalargroup_Ptr; 
    1919 
     20  void cxios_set_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, const char * axis_type, int axis_type_size) 
     21  { 
     22    std::string axis_type_str; 
     23    if (!cstr2string(axis_type, axis_type_size, axis_type_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    scalargroup_hdl->axis_type.fromString(axis_type_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(scalargroup_hdl->axis_type.getInheritedStringValue(), axis_type, axis_type_size)) 
     33      ERROR("void cxios_get_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl, char * axis_type, int axis_type_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_scalargroup_axis_type(scalargroup_Ptr scalargroup_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = scalargroup_hdl->axis_type.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
     45 
     46  void cxios_set_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent) 
     47  { 
     48    CTimer::get("XIOS").resume(); 
     49    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     50    scalargroup_hdl->bounds.reference(tmp.copy()); 
     51     CTimer::get("XIOS").suspend(); 
     52  } 
     53 
     54  void cxios_get_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl, double* bounds, int* extent) 
     55  { 
     56    CTimer::get("XIOS").resume(); 
     57    CArray<double,1> tmp(bounds, shape(extent[0]), neverDeleteData); 
     58    tmp=scalargroup_hdl->bounds.getInheritedValue(); 
     59     CTimer::get("XIOS").suspend(); 
     60  } 
     61 
     62  bool cxios_is_defined_scalargroup_bounds(scalargroup_Ptr scalargroup_hdl) 
     63  { 
     64     CTimer::get("XIOS").resume(); 
     65     bool isDefined = scalargroup_hdl->bounds.hasInheritedValue(); 
     66     CTimer::get("XIOS").suspend(); 
     67     return isDefined; 
     68  } 
     69 
     70 
     71  void cxios_set_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, const char * bounds_name, int bounds_name_size) 
     72  { 
     73    std::string bounds_name_str; 
     74    if (!cstr2string(bounds_name, bounds_name_size, bounds_name_str)) return; 
     75    CTimer::get("XIOS").resume(); 
     76    scalargroup_hdl->bounds_name.setValue(bounds_name_str); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size) 
     81  { 
     82    CTimer::get("XIOS").resume(); 
     83    if (!string_copy(scalargroup_hdl->bounds_name.getInheritedValue(), bounds_name, bounds_name_size)) 
     84      ERROR("void cxios_get_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl, char * bounds_name, int bounds_name_size)", << "Input string is too short"); 
     85    CTimer::get("XIOS").suspend(); 
     86  } 
     87 
     88  bool cxios_is_defined_scalargroup_bounds_name(scalargroup_Ptr scalargroup_hdl) 
     89  { 
     90     CTimer::get("XIOS").resume(); 
     91     bool isDefined = scalargroup_hdl->bounds_name.hasInheritedValue(); 
     92     CTimer::get("XIOS").suspend(); 
     93     return isDefined; 
     94  } 
     95 
     96 
     97  void cxios_set_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, const char * comment, int comment_size) 
     98  { 
     99    std::string comment_str; 
     100    if (!cstr2string(comment, comment_size, comment_str)) return; 
     101    CTimer::get("XIOS").resume(); 
     102    scalargroup_hdl->comment.setValue(comment_str); 
     103    CTimer::get("XIOS").suspend(); 
     104  } 
     105 
     106  void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size) 
     107  { 
     108    CTimer::get("XIOS").resume(); 
     109    if (!string_copy(scalargroup_hdl->comment.getInheritedValue(), comment, comment_size)) 
     110      ERROR("void cxios_get_scalargroup_comment(scalargroup_Ptr scalargroup_hdl, char * comment, int comment_size)", << "Input string is too short"); 
     111    CTimer::get("XIOS").suspend(); 
     112  } 
     113 
     114  bool cxios_is_defined_scalargroup_comment(scalargroup_Ptr scalargroup_hdl) 
     115  { 
     116     CTimer::get("XIOS").resume(); 
     117     bool isDefined = scalargroup_hdl->comment.hasInheritedValue(); 
     118     CTimer::get("XIOS").suspend(); 
     119     return isDefined; 
     120  } 
     121 
     122 
    20123  void cxios_set_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, const char * group_ref, int group_ref_size) 
    21124  { 
     
    44147 
    45148 
     149  void cxios_set_scalargroup_label(scalargroup_Ptr scalargroup_hdl, const char * label, int label_size) 
     150  { 
     151    std::string label_str; 
     152    if (!cstr2string(label, label_size, label_str)) return; 
     153    CTimer::get("XIOS").resume(); 
     154    scalargroup_hdl->label.setValue(label_str); 
     155    CTimer::get("XIOS").suspend(); 
     156  } 
     157 
     158  void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size) 
     159  { 
     160    CTimer::get("XIOS").resume(); 
     161    if (!string_copy(scalargroup_hdl->label.getInheritedValue(), label, label_size)) 
     162      ERROR("void cxios_get_scalargroup_label(scalargroup_Ptr scalargroup_hdl, char * label, int label_size)", << "Input string is too short"); 
     163    CTimer::get("XIOS").suspend(); 
     164  } 
     165 
     166  bool cxios_is_defined_scalargroup_label(scalargroup_Ptr scalargroup_hdl) 
     167  { 
     168     CTimer::get("XIOS").resume(); 
     169     bool isDefined = scalargroup_hdl->label.hasInheritedValue(); 
     170     CTimer::get("XIOS").suspend(); 
     171     return isDefined; 
     172  } 
     173 
     174 
    46175  void cxios_set_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, const char * long_name, int long_name_size) 
    47176  { 
     
    96225 
    97226 
     227  void cxios_set_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, const char * positive, int positive_size) 
     228  { 
     229    std::string positive_str; 
     230    if (!cstr2string(positive, positive_size, positive_str)) return; 
     231    CTimer::get("XIOS").resume(); 
     232    scalargroup_hdl->positive.fromString(positive_str); 
     233    CTimer::get("XIOS").suspend(); 
     234  } 
     235 
     236  void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size) 
     237  { 
     238    CTimer::get("XIOS").resume(); 
     239    if (!string_copy(scalargroup_hdl->positive.getInheritedStringValue(), positive, positive_size)) 
     240      ERROR("void cxios_get_scalargroup_positive(scalargroup_Ptr scalargroup_hdl, char * positive, int positive_size)", << "Input string is too short"); 
     241    CTimer::get("XIOS").suspend(); 
     242  } 
     243 
     244  bool cxios_is_defined_scalargroup_positive(scalargroup_Ptr scalargroup_hdl) 
     245  { 
     246     CTimer::get("XIOS").resume(); 
     247     bool isDefined = scalargroup_hdl->positive.hasInheritedValue(); 
     248     CTimer::get("XIOS").suspend(); 
     249     return isDefined; 
     250  } 
     251 
     252 
    98253  void cxios_set_scalargroup_prec(scalargroup_Ptr scalargroup_hdl, int prec) 
    99254  { 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/axis_interface_attr.F90

    r1158 r1492  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axis_axis_type(axis_hdl, axis_type, axis_type_size) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     36      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     37      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     38    END SUBROUTINE cxios_set_axis_axis_type 
     39 
     40    SUBROUTINE cxios_get_axis_axis_type(axis_hdl, axis_type, axis_type_size) BIND(C) 
     41      USE ISO_C_BINDING 
     42      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     43      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     44      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     45    END SUBROUTINE cxios_get_axis_axis_type 
     46 
     47    FUNCTION cxios_is_defined_axis_axis_type(axis_hdl) BIND(C) 
     48      USE ISO_C_BINDING 
     49      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_axis_type 
     50      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     51    END FUNCTION cxios_is_defined_axis_axis_type 
     52 
     53 
    3354    SUBROUTINE cxios_set_axis_begin(axis_hdl, begin) BIND(C) 
    3455      USE ISO_C_BINDING 
     
    7192 
    7293 
     94    SUBROUTINE cxios_set_axis_bounds_name(axis_hdl, bounds_name, bounds_name_size) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     97      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     98      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     99    END SUBROUTINE cxios_set_axis_bounds_name 
     100 
     101    SUBROUTINE cxios_get_axis_bounds_name(axis_hdl, bounds_name, bounds_name_size) BIND(C) 
     102      USE ISO_C_BINDING 
     103      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     104      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     105      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     106    END SUBROUTINE cxios_get_axis_bounds_name 
     107 
     108    FUNCTION cxios_is_defined_axis_bounds_name(axis_hdl) BIND(C) 
     109      USE ISO_C_BINDING 
     110      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_bounds_name 
     111      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     112    END FUNCTION cxios_is_defined_axis_bounds_name 
     113 
     114 
     115    SUBROUTINE cxios_set_axis_comment(axis_hdl, comment, comment_size) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     118      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     119      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     120    END SUBROUTINE cxios_set_axis_comment 
     121 
     122    SUBROUTINE cxios_get_axis_comment(axis_hdl, comment, comment_size) BIND(C) 
     123      USE ISO_C_BINDING 
     124      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     125      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     126      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     127    END SUBROUTINE cxios_get_axis_comment 
     128 
     129    FUNCTION cxios_is_defined_axis_comment(axis_hdl) BIND(C) 
     130      USE ISO_C_BINDING 
     131      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_comment 
     132      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     133    END FUNCTION cxios_is_defined_axis_comment 
     134 
     135 
    73136    SUBROUTINE cxios_set_axis_data_begin(axis_hdl, data_begin) BIND(C) 
    74137      USE ISO_C_BINDING 
     
    128191      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
    129192    END FUNCTION cxios_is_defined_axis_data_n 
     193 
     194 
     195    SUBROUTINE cxios_set_axis_dim_name(axis_hdl, dim_name, dim_name_size) BIND(C) 
     196      USE ISO_C_BINDING 
     197      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     198      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     199      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     200    END SUBROUTINE cxios_set_axis_dim_name 
     201 
     202    SUBROUTINE cxios_get_axis_dim_name(axis_hdl, dim_name, dim_name_size) BIND(C) 
     203      USE ISO_C_BINDING 
     204      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     205      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     206      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     207    END SUBROUTINE cxios_get_axis_dim_name 
     208 
     209    FUNCTION cxios_is_defined_axis_dim_name(axis_hdl) BIND(C) 
     210      USE ISO_C_BINDING 
     211      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_dim_name 
     212      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     213    END FUNCTION cxios_is_defined_axis_dim_name 
     214 
     215 
     216    SUBROUTINE cxios_set_axis_formula(axis_hdl, formula, formula_size) BIND(C) 
     217      USE ISO_C_BINDING 
     218      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     219      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     220      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     221    END SUBROUTINE cxios_set_axis_formula 
     222 
     223    SUBROUTINE cxios_get_axis_formula(axis_hdl, formula, formula_size) BIND(C) 
     224      USE ISO_C_BINDING 
     225      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     226      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     227      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     228    END SUBROUTINE cxios_get_axis_formula 
     229 
     230    FUNCTION cxios_is_defined_axis_formula(axis_hdl) BIND(C) 
     231      USE ISO_C_BINDING 
     232      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula 
     233      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     234    END FUNCTION cxios_is_defined_axis_formula 
     235 
     236 
     237    SUBROUTINE cxios_set_axis_formula_bounds(axis_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     238      USE ISO_C_BINDING 
     239      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     240      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     241      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     242    END SUBROUTINE cxios_set_axis_formula_bounds 
     243 
     244    SUBROUTINE cxios_get_axis_formula_bounds(axis_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     245      USE ISO_C_BINDING 
     246      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     247      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     248      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     249    END SUBROUTINE cxios_get_axis_formula_bounds 
     250 
     251    FUNCTION cxios_is_defined_axis_formula_bounds(axis_hdl) BIND(C) 
     252      USE ISO_C_BINDING 
     253      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_bounds 
     254      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     255    END FUNCTION cxios_is_defined_axis_formula_bounds 
     256 
     257 
     258    SUBROUTINE cxios_set_axis_formula_term(axis_hdl, formula_term, formula_term_size) BIND(C) 
     259      USE ISO_C_BINDING 
     260      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     261      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     262      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     263    END SUBROUTINE cxios_set_axis_formula_term 
     264 
     265    SUBROUTINE cxios_get_axis_formula_term(axis_hdl, formula_term, formula_term_size) BIND(C) 
     266      USE ISO_C_BINDING 
     267      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     268      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     269      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     270    END SUBROUTINE cxios_get_axis_formula_term 
     271 
     272    FUNCTION cxios_is_defined_axis_formula_term(axis_hdl) BIND(C) 
     273      USE ISO_C_BINDING 
     274      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_term 
     275      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     276    END FUNCTION cxios_is_defined_axis_formula_term 
     277 
     278 
     279    SUBROUTINE cxios_set_axis_formula_term_bounds(axis_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     280      USE ISO_C_BINDING 
     281      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     282      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     283      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     284    END SUBROUTINE cxios_set_axis_formula_term_bounds 
     285 
     286    SUBROUTINE cxios_get_axis_formula_term_bounds(axis_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     287      USE ISO_C_BINDING 
     288      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     289      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     290      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     291    END SUBROUTINE cxios_get_axis_formula_term_bounds 
     292 
     293    FUNCTION cxios_is_defined_axis_formula_term_bounds(axis_hdl) BIND(C) 
     294      USE ISO_C_BINDING 
     295      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_formula_term_bounds 
     296      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl 
     297    END FUNCTION cxios_is_defined_axis_formula_term_bounds 
    130298 
    131299 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/axisgroup_interface_attr.F90

    r1158 r1492  
    3131 
    3232 
     33    SUBROUTINE cxios_set_axisgroup_axis_type(axisgroup_hdl, axis_type, axis_type_size) BIND(C) 
     34      USE ISO_C_BINDING 
     35      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     36      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     37      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     38    END SUBROUTINE cxios_set_axisgroup_axis_type 
     39 
     40    SUBROUTINE cxios_get_axisgroup_axis_type(axisgroup_hdl, axis_type, axis_type_size) BIND(C) 
     41      USE ISO_C_BINDING 
     42      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     43      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: axis_type 
     44      INTEGER  (kind = C_INT)     , VALUE        :: axis_type_size 
     45    END SUBROUTINE cxios_get_axisgroup_axis_type 
     46 
     47    FUNCTION cxios_is_defined_axisgroup_axis_type(axisgroup_hdl) BIND(C) 
     48      USE ISO_C_BINDING 
     49      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_axis_type 
     50      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     51    END FUNCTION cxios_is_defined_axisgroup_axis_type 
     52 
     53 
    3354    SUBROUTINE cxios_set_axisgroup_begin(axisgroup_hdl, begin) BIND(C) 
    3455      USE ISO_C_BINDING 
     
    7192 
    7293 
     94    SUBROUTINE cxios_set_axisgroup_bounds_name(axisgroup_hdl, bounds_name, bounds_name_size) BIND(C) 
     95      USE ISO_C_BINDING 
     96      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     97      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     98      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     99    END SUBROUTINE cxios_set_axisgroup_bounds_name 
     100 
     101    SUBROUTINE cxios_get_axisgroup_bounds_name(axisgroup_hdl, bounds_name, bounds_name_size) BIND(C) 
     102      USE ISO_C_BINDING 
     103      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     104      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_name 
     105      INTEGER  (kind = C_INT)     , VALUE        :: bounds_name_size 
     106    END SUBROUTINE cxios_get_axisgroup_bounds_name 
     107 
     108    FUNCTION cxios_is_defined_axisgroup_bounds_name(axisgroup_hdl) BIND(C) 
     109      USE ISO_C_BINDING 
     110      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_bounds_name 
     111      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     112    END FUNCTION cxios_is_defined_axisgroup_bounds_name 
     113 
     114 
     115    SUBROUTINE cxios_set_axisgroup_comment(axisgroup_hdl, comment, comment_size) BIND(C) 
     116      USE ISO_C_BINDING 
     117      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     118      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     119      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     120    END SUBROUTINE cxios_set_axisgroup_comment 
     121 
     122    SUBROUTINE cxios_get_axisgroup_comment(axisgroup_hdl, comment, comment_size) BIND(C) 
     123      USE ISO_C_BINDING 
     124      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     125      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     126      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     127    END SUBROUTINE cxios_get_axisgroup_comment 
     128 
     129    FUNCTION cxios_is_defined_axisgroup_comment(axisgroup_hdl) BIND(C) 
     130      USE ISO_C_BINDING 
     131      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_comment 
     132      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     133    END FUNCTION cxios_is_defined_axisgroup_comment 
     134 
     135 
    73136    SUBROUTINE cxios_set_axisgroup_data_begin(axisgroup_hdl, data_begin) BIND(C) 
    74137      USE ISO_C_BINDING 
     
    128191      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
    129192    END FUNCTION cxios_is_defined_axisgroup_data_n 
     193 
     194 
     195    SUBROUTINE cxios_set_axisgroup_dim_name(axisgroup_hdl, dim_name, dim_name_size) BIND(C) 
     196      USE ISO_C_BINDING 
     197      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     198      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     199      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     200    END SUBROUTINE cxios_set_axisgroup_dim_name 
     201 
     202    SUBROUTINE cxios_get_axisgroup_dim_name(axisgroup_hdl, dim_name, dim_name_size) BIND(C) 
     203      USE ISO_C_BINDING 
     204      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     205      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_name 
     206      INTEGER  (kind = C_INT)     , VALUE        :: dim_name_size 
     207    END SUBROUTINE cxios_get_axisgroup_dim_name 
     208 
     209    FUNCTION cxios_is_defined_axisgroup_dim_name(axisgroup_hdl) BIND(C) 
     210      USE ISO_C_BINDING 
     211      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_dim_name 
     212      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     213    END FUNCTION cxios_is_defined_axisgroup_dim_name 
     214 
     215 
     216    SUBROUTINE cxios_set_axisgroup_formula(axisgroup_hdl, formula, formula_size) BIND(C) 
     217      USE ISO_C_BINDING 
     218      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     219      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     220      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     221    END SUBROUTINE cxios_set_axisgroup_formula 
     222 
     223    SUBROUTINE cxios_get_axisgroup_formula(axisgroup_hdl, formula, formula_size) BIND(C) 
     224      USE ISO_C_BINDING 
     225      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     226      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula 
     227      INTEGER  (kind = C_INT)     , VALUE        :: formula_size 
     228    END SUBROUTINE cxios_get_axisgroup_formula 
     229 
     230    FUNCTION cxios_is_defined_axisgroup_formula(axisgroup_hdl) BIND(C) 
     231      USE ISO_C_BINDING 
     232      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula 
     233      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     234    END FUNCTION cxios_is_defined_axisgroup_formula 
     235 
     236 
     237    SUBROUTINE cxios_set_axisgroup_formula_bounds(axisgroup_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     238      USE ISO_C_BINDING 
     239      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     240      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     241      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     242    END SUBROUTINE cxios_set_axisgroup_formula_bounds 
     243 
     244    SUBROUTINE cxios_get_axisgroup_formula_bounds(axisgroup_hdl, formula_bounds, formula_bounds_size) BIND(C) 
     245      USE ISO_C_BINDING 
     246      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     247      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_bounds 
     248      INTEGER  (kind = C_INT)     , VALUE        :: formula_bounds_size 
     249    END SUBROUTINE cxios_get_axisgroup_formula_bounds 
     250 
     251    FUNCTION cxios_is_defined_axisgroup_formula_bounds(axisgroup_hdl) BIND(C) 
     252      USE ISO_C_BINDING 
     253      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_bounds 
     254      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     255    END FUNCTION cxios_is_defined_axisgroup_formula_bounds 
     256 
     257 
     258    SUBROUTINE cxios_set_axisgroup_formula_term(axisgroup_hdl, formula_term, formula_term_size) BIND(C) 
     259      USE ISO_C_BINDING 
     260      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     261      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     262      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     263    END SUBROUTINE cxios_set_axisgroup_formula_term 
     264 
     265    SUBROUTINE cxios_get_axisgroup_formula_term(axisgroup_hdl, formula_term, formula_term_size) BIND(C) 
     266      USE ISO_C_BINDING 
     267      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     268      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term 
     269      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_size 
     270    END SUBROUTINE cxios_get_axisgroup_formula_term 
     271 
     272    FUNCTION cxios_is_defined_axisgroup_formula_term(axisgroup_hdl) BIND(C) 
     273      USE ISO_C_BINDING 
     274      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_term 
     275      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     276    END FUNCTION cxios_is_defined_axisgroup_formula_term 
     277 
     278 
     279    SUBROUTINE cxios_set_axisgroup_formula_term_bounds(axisgroup_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     280      USE ISO_C_BINDING 
     281      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     282      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     283      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     284    END SUBROUTINE cxios_set_axisgroup_formula_term_bounds 
     285 
     286    SUBROUTINE cxios_get_axisgroup_formula_term_bounds(axisgroup_hdl, formula_term_bounds, formula_term_bounds_size) BIND(C) 
     287      USE ISO_C_BINDING 
     288      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     289      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: formula_term_bounds 
     290      INTEGER  (kind = C_INT)     , VALUE        :: formula_term_bounds_size 
     291    END SUBROUTINE cxios_get_axisgroup_formula_term_bounds 
     292 
     293    FUNCTION cxios_is_defined_axisgroup_formula_term_bounds(axisgroup_hdl) BIND(C) 
     294      USE ISO_C_BINDING 
     295      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_formula_term_bounds 
     296      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl 
     297    END FUNCTION cxios_is_defined_axisgroup_formula_term_bounds 
    130298 
    131299 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/calendar_wrapper_interface_attr.F90

    r674 r1492  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_calendar_wrapper_comment(calendar_wrapper_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_calendar_wrapper_comment 
     18 
     19    SUBROUTINE cxios_get_calendar_wrapper_comment(calendar_wrapper_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_calendar_wrapper_comment 
     25 
     26    FUNCTION cxios_is_defined_calendar_wrapper_comment(calendar_wrapper_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_calendar_wrapper_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: calendar_wrapper_hdl 
     30    END FUNCTION cxios_is_defined_calendar_wrapper_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_calendar_wrapper_day_length(calendar_wrapper_hdl, day_length) BIND(C) 
    1334      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/domain_interface_attr.F90

    r1158 r1492  
    7373 
    7474 
     75    SUBROUTINE cxios_set_domain_bounds_lat_name(domain_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     78      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     79      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     80    END SUBROUTINE cxios_set_domain_bounds_lat_name 
     81 
     82    SUBROUTINE cxios_get_domain_bounds_lat_name(domain_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     85      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     86      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     87    END SUBROUTINE cxios_get_domain_bounds_lat_name 
     88 
     89    FUNCTION cxios_is_defined_domain_bounds_lat_name(domain_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_name 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     93    END FUNCTION cxios_is_defined_domain_bounds_lat_name 
     94 
     95 
    7596    SUBROUTINE cxios_set_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent) BIND(C) 
    7697      USE ISO_C_BINDING 
     
    113134      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    114135    END FUNCTION cxios_is_defined_domain_bounds_lon_2d 
     136 
     137 
     138    SUBROUTINE cxios_set_domain_bounds_lon_name(domain_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     139      USE ISO_C_BINDING 
     140      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     141      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     142      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     143    END SUBROUTINE cxios_set_domain_bounds_lon_name 
     144 
     145    SUBROUTINE cxios_get_domain_bounds_lon_name(domain_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     146      USE ISO_C_BINDING 
     147      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     148      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     149      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     150    END SUBROUTINE cxios_get_domain_bounds_lon_name 
     151 
     152    FUNCTION cxios_is_defined_domain_bounds_lon_name(domain_hdl) BIND(C) 
     153      USE ISO_C_BINDING 
     154      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_name 
     155      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     156    END FUNCTION cxios_is_defined_domain_bounds_lon_name 
     157 
     158 
     159    SUBROUTINE cxios_set_domain_comment(domain_hdl, comment, comment_size) BIND(C) 
     160      USE ISO_C_BINDING 
     161      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     162      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     163      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     164    END SUBROUTINE cxios_set_domain_comment 
     165 
     166    SUBROUTINE cxios_get_domain_comment(domain_hdl, comment, comment_size) BIND(C) 
     167      USE ISO_C_BINDING 
     168      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     169      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     170      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     171    END SUBROUTINE cxios_get_domain_comment 
     172 
     173    FUNCTION cxios_is_defined_domain_comment(domain_hdl) BIND(C) 
     174      USE ISO_C_BINDING 
     175      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_comment 
     176      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     177    END FUNCTION cxios_is_defined_domain_comment 
    115178 
    116179 
     
    250313      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    251314    END FUNCTION cxios_is_defined_domain_data_nj 
     315 
     316 
     317    SUBROUTINE cxios_set_domain_dim_i_name(domain_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     318      USE ISO_C_BINDING 
     319      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     320      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     321      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     322    END SUBROUTINE cxios_set_domain_dim_i_name 
     323 
     324    SUBROUTINE cxios_get_domain_dim_i_name(domain_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     325      USE ISO_C_BINDING 
     326      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     327      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     328      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     329    END SUBROUTINE cxios_get_domain_dim_i_name 
     330 
     331    FUNCTION cxios_is_defined_domain_dim_i_name(domain_hdl) BIND(C) 
     332      USE ISO_C_BINDING 
     333      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_dim_i_name 
     334      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     335    END FUNCTION cxios_is_defined_domain_dim_i_name 
     336 
     337 
     338    SUBROUTINE cxios_set_domain_dim_j_name(domain_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     339      USE ISO_C_BINDING 
     340      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     341      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     342      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     343    END SUBROUTINE cxios_set_domain_dim_j_name 
     344 
     345    SUBROUTINE cxios_get_domain_dim_j_name(domain_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     346      USE ISO_C_BINDING 
     347      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     348      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     349      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     350    END SUBROUTINE cxios_get_domain_dim_j_name 
     351 
     352    FUNCTION cxios_is_defined_domain_dim_j_name(domain_hdl) BIND(C) 
     353      USE ISO_C_BINDING 
     354      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_dim_j_name 
     355      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     356    END FUNCTION cxios_is_defined_domain_dim_j_name 
    252357 
    253358 
     
    353458 
    354459 
     460    SUBROUTINE cxios_set_domain_lat_name(domain_hdl, lat_name, lat_name_size) BIND(C) 
     461      USE ISO_C_BINDING 
     462      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     463      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     464      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     465    END SUBROUTINE cxios_set_domain_lat_name 
     466 
     467    SUBROUTINE cxios_get_domain_lat_name(domain_hdl, lat_name, lat_name_size) BIND(C) 
     468      USE ISO_C_BINDING 
     469      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     470      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     471      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     472    END SUBROUTINE cxios_get_domain_lat_name 
     473 
     474    FUNCTION cxios_is_defined_domain_lat_name(domain_hdl) BIND(C) 
     475      USE ISO_C_BINDING 
     476      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lat_name 
     477      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     478    END FUNCTION cxios_is_defined_domain_lat_name 
     479 
     480 
    355481    SUBROUTINE cxios_set_domain_latvalue_1d(domain_hdl, latvalue_1d, extent) BIND(C) 
    356482      USE ISO_C_BINDING 
     
    393519      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
    394520    END FUNCTION cxios_is_defined_domain_latvalue_2d 
     521 
     522 
     523    SUBROUTINE cxios_set_domain_lon_name(domain_hdl, lon_name, lon_name_size) BIND(C) 
     524      USE ISO_C_BINDING 
     525      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     526      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     527      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     528    END SUBROUTINE cxios_set_domain_lon_name 
     529 
     530    SUBROUTINE cxios_get_domain_lon_name(domain_hdl, lon_name, lon_name_size) BIND(C) 
     531      USE ISO_C_BINDING 
     532      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     533      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     534      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     535    END SUBROUTINE cxios_get_domain_lon_name 
     536 
     537    FUNCTION cxios_is_defined_domain_lon_name(domain_hdl) BIND(C) 
     538      USE ISO_C_BINDING 
     539      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lon_name 
     540      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl 
     541    END FUNCTION cxios_is_defined_domain_lon_name 
    395542 
    396543 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/domaingroup_interface_attr.F90

    r1158 r1492  
    7373 
    7474 
     75    SUBROUTINE cxios_set_domaingroup_bounds_lat_name(domaingroup_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     78      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     79      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     80    END SUBROUTINE cxios_set_domaingroup_bounds_lat_name 
     81 
     82    SUBROUTINE cxios_get_domaingroup_bounds_lat_name(domaingroup_hdl, bounds_lat_name, bounds_lat_name_size) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     85      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lat_name 
     86      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lat_name_size 
     87    END SUBROUTINE cxios_get_domaingroup_bounds_lat_name 
     88 
     89    FUNCTION cxios_is_defined_domaingroup_bounds_lat_name(domaingroup_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_name 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     93    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_name 
     94 
     95 
    7596    SUBROUTINE cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent) BIND(C) 
    7697      USE ISO_C_BINDING 
     
    113134      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    114135    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d 
     136 
     137 
     138    SUBROUTINE cxios_set_domaingroup_bounds_lon_name(domaingroup_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     139      USE ISO_C_BINDING 
     140      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     141      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     142      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     143    END SUBROUTINE cxios_set_domaingroup_bounds_lon_name 
     144 
     145    SUBROUTINE cxios_get_domaingroup_bounds_lon_name(domaingroup_hdl, bounds_lon_name, bounds_lon_name_size) BIND(C) 
     146      USE ISO_C_BINDING 
     147      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     148      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: bounds_lon_name 
     149      INTEGER  (kind = C_INT)     , VALUE        :: bounds_lon_name_size 
     150    END SUBROUTINE cxios_get_domaingroup_bounds_lon_name 
     151 
     152    FUNCTION cxios_is_defined_domaingroup_bounds_lon_name(domaingroup_hdl) BIND(C) 
     153      USE ISO_C_BINDING 
     154      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_name 
     155      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     156    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_name 
     157 
     158 
     159    SUBROUTINE cxios_set_domaingroup_comment(domaingroup_hdl, comment, comment_size) BIND(C) 
     160      USE ISO_C_BINDING 
     161      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     162      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     163      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     164    END SUBROUTINE cxios_set_domaingroup_comment 
     165 
     166    SUBROUTINE cxios_get_domaingroup_comment(domaingroup_hdl, comment, comment_size) BIND(C) 
     167      USE ISO_C_BINDING 
     168      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     169      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     170      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     171    END SUBROUTINE cxios_get_domaingroup_comment 
     172 
     173    FUNCTION cxios_is_defined_domaingroup_comment(domaingroup_hdl) BIND(C) 
     174      USE ISO_C_BINDING 
     175      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_comment 
     176      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     177    END FUNCTION cxios_is_defined_domaingroup_comment 
    115178 
    116179 
     
    250313      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    251314    END FUNCTION cxios_is_defined_domaingroup_data_nj 
     315 
     316 
     317    SUBROUTINE cxios_set_domaingroup_dim_i_name(domaingroup_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     318      USE ISO_C_BINDING 
     319      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     320      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     321      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     322    END SUBROUTINE cxios_set_domaingroup_dim_i_name 
     323 
     324    SUBROUTINE cxios_get_domaingroup_dim_i_name(domaingroup_hdl, dim_i_name, dim_i_name_size) BIND(C) 
     325      USE ISO_C_BINDING 
     326      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     327      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_i_name 
     328      INTEGER  (kind = C_INT)     , VALUE        :: dim_i_name_size 
     329    END SUBROUTINE cxios_get_domaingroup_dim_i_name 
     330 
     331    FUNCTION cxios_is_defined_domaingroup_dim_i_name(domaingroup_hdl) BIND(C) 
     332      USE ISO_C_BINDING 
     333      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_dim_i_name 
     334      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     335    END FUNCTION cxios_is_defined_domaingroup_dim_i_name 
     336 
     337 
     338    SUBROUTINE cxios_set_domaingroup_dim_j_name(domaingroup_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     339      USE ISO_C_BINDING 
     340      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     341      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     342      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     343    END SUBROUTINE cxios_set_domaingroup_dim_j_name 
     344 
     345    SUBROUTINE cxios_get_domaingroup_dim_j_name(domaingroup_hdl, dim_j_name, dim_j_name_size) BIND(C) 
     346      USE ISO_C_BINDING 
     347      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     348      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: dim_j_name 
     349      INTEGER  (kind = C_INT)     , VALUE        :: dim_j_name_size 
     350    END SUBROUTINE cxios_get_domaingroup_dim_j_name 
     351 
     352    FUNCTION cxios_is_defined_domaingroup_dim_j_name(domaingroup_hdl) BIND(C) 
     353      USE ISO_C_BINDING 
     354      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_dim_j_name 
     355      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     356    END FUNCTION cxios_is_defined_domaingroup_dim_j_name 
    252357 
    253358 
     
    374479 
    375480 
     481    SUBROUTINE cxios_set_domaingroup_lat_name(domaingroup_hdl, lat_name, lat_name_size) BIND(C) 
     482      USE ISO_C_BINDING 
     483      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     484      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     485      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     486    END SUBROUTINE cxios_set_domaingroup_lat_name 
     487 
     488    SUBROUTINE cxios_get_domaingroup_lat_name(domaingroup_hdl, lat_name, lat_name_size) BIND(C) 
     489      USE ISO_C_BINDING 
     490      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     491      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lat_name 
     492      INTEGER  (kind = C_INT)     , VALUE        :: lat_name_size 
     493    END SUBROUTINE cxios_get_domaingroup_lat_name 
     494 
     495    FUNCTION cxios_is_defined_domaingroup_lat_name(domaingroup_hdl) BIND(C) 
     496      USE ISO_C_BINDING 
     497      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lat_name 
     498      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     499    END FUNCTION cxios_is_defined_domaingroup_lat_name 
     500 
     501 
    376502    SUBROUTINE cxios_set_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent) BIND(C) 
    377503      USE ISO_C_BINDING 
     
    414540      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
    415541    END FUNCTION cxios_is_defined_domaingroup_latvalue_2d 
     542 
     543 
     544    SUBROUTINE cxios_set_domaingroup_lon_name(domaingroup_hdl, lon_name, lon_name_size) BIND(C) 
     545      USE ISO_C_BINDING 
     546      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     547      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     548      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     549    END SUBROUTINE cxios_set_domaingroup_lon_name 
     550 
     551    SUBROUTINE cxios_get_domaingroup_lon_name(domaingroup_hdl, lon_name, lon_name_size) BIND(C) 
     552      USE ISO_C_BINDING 
     553      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     554      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: lon_name 
     555      INTEGER  (kind = C_INT)     , VALUE        :: lon_name_size 
     556    END SUBROUTINE cxios_get_domaingroup_lon_name 
     557 
     558    FUNCTION cxios_is_defined_domaingroup_lon_name(domaingroup_hdl) BIND(C) 
     559      USE ISO_C_BINDING 
     560      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lon_name 
     561      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl 
     562    END FUNCTION cxios_is_defined_domaingroup_lon_name 
    416563 
    417564 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/field_interface_attr.F90

    r1201 r1492  
    111111 
    112112 
     113    SUBROUTINE cxios_set_field_comment(field_hdl, comment, comment_size) BIND(C) 
     114      USE ISO_C_BINDING 
     115      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     116      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     117      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     118    END SUBROUTINE cxios_set_field_comment 
     119 
     120    SUBROUTINE cxios_get_field_comment(field_hdl, comment, comment_size) BIND(C) 
     121      USE ISO_C_BINDING 
     122      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     123      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     124      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     125    END SUBROUTINE cxios_get_field_comment 
     126 
     127    FUNCTION cxios_is_defined_field_comment(field_hdl) BIND(C) 
     128      USE ISO_C_BINDING 
     129      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_comment 
     130      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     131    END FUNCTION cxios_is_defined_field_comment 
     132 
     133 
    113134    SUBROUTINE cxios_set_field_compression_level(field_hdl, compression_level) BIND(C) 
    114135      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/fieldgroup_interface_attr.F90

    r1201 r1492  
    111111 
    112112 
     113    SUBROUTINE cxios_set_fieldgroup_comment(fieldgroup_hdl, comment, comment_size) BIND(C) 
     114      USE ISO_C_BINDING 
     115      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     116      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     117      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     118    END SUBROUTINE cxios_set_fieldgroup_comment 
     119 
     120    SUBROUTINE cxios_get_fieldgroup_comment(fieldgroup_hdl, comment, comment_size) BIND(C) 
     121      USE ISO_C_BINDING 
     122      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     123      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     124      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     125    END SUBROUTINE cxios_get_fieldgroup_comment 
     126 
     127    FUNCTION cxios_is_defined_fieldgroup_comment(fieldgroup_hdl) BIND(C) 
     128      USE ISO_C_BINDING 
     129      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_comment 
     130      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     131    END FUNCTION cxios_is_defined_fieldgroup_comment 
     132 
     133 
    113134    SUBROUTINE cxios_set_fieldgroup_compression_level(fieldgroup_hdl, compression_level) BIND(C) 
    114135      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/file_interface_attr.F90

    r1201 r1492  
    2929 
    3030 
     31    SUBROUTINE cxios_set_file_comment(file_hdl, comment, comment_size) BIND(C) 
     32      USE ISO_C_BINDING 
     33      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     34      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     35      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     36    END SUBROUTINE cxios_set_file_comment 
     37 
     38    SUBROUTINE cxios_get_file_comment(file_hdl, comment, comment_size) BIND(C) 
     39      USE ISO_C_BINDING 
     40      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     41      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     42      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     43    END SUBROUTINE cxios_get_file_comment 
     44 
     45    FUNCTION cxios_is_defined_file_comment(file_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_comment 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     49    END FUNCTION cxios_is_defined_file_comment 
     50 
     51 
    3152    SUBROUTINE cxios_set_file_compression_level(file_hdl, compression_level) BIND(C) 
    3253      USE ISO_C_BINDING 
     
    313334 
    314335 
     336    SUBROUTINE cxios_set_file_read_metadata_par(file_hdl, read_metadata_par) BIND(C) 
     337      USE ISO_C_BINDING 
     338      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     339      LOGICAL (KIND=C_BOOL)      , VALUE :: read_metadata_par 
     340    END SUBROUTINE cxios_set_file_read_metadata_par 
     341 
     342    SUBROUTINE cxios_get_file_read_metadata_par(file_hdl, read_metadata_par) BIND(C) 
     343      USE ISO_C_BINDING 
     344      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     345      LOGICAL (KIND=C_BOOL)             :: read_metadata_par 
     346    END SUBROUTINE cxios_get_file_read_metadata_par 
     347 
     348    FUNCTION cxios_is_defined_file_read_metadata_par(file_hdl) BIND(C) 
     349      USE ISO_C_BINDING 
     350      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_read_metadata_par 
     351      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     352    END FUNCTION cxios_is_defined_file_read_metadata_par 
     353 
     354 
    315355    SUBROUTINE cxios_set_file_record_offset(file_hdl, record_offset) BIND(C) 
    316356      USE ISO_C_BINDING 
     
    330370      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
    331371    END FUNCTION cxios_is_defined_file_record_offset 
     372 
     373 
     374    SUBROUTINE cxios_set_file_split_end_offset(file_hdl, split_end_offset) BIND(C) 
     375      USE ISO_C_BINDING 
     376      USE IDURATION 
     377      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     378      TYPE(txios(duration)), VALUE :: split_end_offset 
     379    END SUBROUTINE cxios_set_file_split_end_offset 
     380 
     381    SUBROUTINE cxios_get_file_split_end_offset(file_hdl, split_end_offset) BIND(C) 
     382      USE ISO_C_BINDING 
     383      USE IDURATION 
     384      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     385      TYPE(txios(duration)) :: split_end_offset 
     386    END SUBROUTINE cxios_get_file_split_end_offset 
     387 
     388    FUNCTION cxios_is_defined_file_split_end_offset(file_hdl) BIND(C) 
     389      USE ISO_C_BINDING 
     390      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_end_offset 
     391      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     392    END FUNCTION cxios_is_defined_file_split_end_offset 
    332393 
    333394 
     
    374435 
    375436 
     437    SUBROUTINE cxios_set_file_split_last_date(file_hdl, split_last_date, split_last_date_size) BIND(C) 
     438      USE ISO_C_BINDING 
     439      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     440      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     441      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     442    END SUBROUTINE cxios_set_file_split_last_date 
     443 
     444    SUBROUTINE cxios_get_file_split_last_date(file_hdl, split_last_date, split_last_date_size) BIND(C) 
     445      USE ISO_C_BINDING 
     446      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     447      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     448      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     449    END SUBROUTINE cxios_get_file_split_last_date 
     450 
     451    FUNCTION cxios_is_defined_file_split_last_date(file_hdl) BIND(C) 
     452      USE ISO_C_BINDING 
     453      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_last_date 
     454      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     455    END FUNCTION cxios_is_defined_file_split_last_date 
     456 
     457 
     458    SUBROUTINE cxios_set_file_split_start_offset(file_hdl, split_start_offset) BIND(C) 
     459      USE ISO_C_BINDING 
     460      USE IDURATION 
     461      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     462      TYPE(txios(duration)), VALUE :: split_start_offset 
     463    END SUBROUTINE cxios_set_file_split_start_offset 
     464 
     465    SUBROUTINE cxios_get_file_split_start_offset(file_hdl, split_start_offset) BIND(C) 
     466      USE ISO_C_BINDING 
     467      USE IDURATION 
     468      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     469      TYPE(txios(duration)) :: split_start_offset 
     470    END SUBROUTINE cxios_get_file_split_start_offset 
     471 
     472    FUNCTION cxios_is_defined_file_split_start_offset(file_hdl) BIND(C) 
     473      USE ISO_C_BINDING 
     474      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_split_start_offset 
     475      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     476    END FUNCTION cxios_is_defined_file_split_start_offset 
     477 
     478 
    376479    SUBROUTINE cxios_set_file_sync_freq(file_hdl, sync_freq) BIND(C) 
    377480      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/filegroup_interface_attr.F90

    r1201 r1492  
    2929 
    3030 
     31    SUBROUTINE cxios_set_filegroup_comment(filegroup_hdl, comment, comment_size) BIND(C) 
     32      USE ISO_C_BINDING 
     33      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     34      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     35      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     36    END SUBROUTINE cxios_set_filegroup_comment 
     37 
     38    SUBROUTINE cxios_get_filegroup_comment(filegroup_hdl, comment, comment_size) BIND(C) 
     39      USE ISO_C_BINDING 
     40      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     41      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     42      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     43    END SUBROUTINE cxios_get_filegroup_comment 
     44 
     45    FUNCTION cxios_is_defined_filegroup_comment(filegroup_hdl) BIND(C) 
     46      USE ISO_C_BINDING 
     47      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_comment 
     48      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     49    END FUNCTION cxios_is_defined_filegroup_comment 
     50 
     51 
    3152    SUBROUTINE cxios_set_filegroup_compression_level(filegroup_hdl, compression_level) BIND(C) 
    3253      USE ISO_C_BINDING 
     
    334355 
    335356 
     357    SUBROUTINE cxios_set_filegroup_read_metadata_par(filegroup_hdl, read_metadata_par) BIND(C) 
     358      USE ISO_C_BINDING 
     359      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     360      LOGICAL (KIND=C_BOOL)      , VALUE :: read_metadata_par 
     361    END SUBROUTINE cxios_set_filegroup_read_metadata_par 
     362 
     363    SUBROUTINE cxios_get_filegroup_read_metadata_par(filegroup_hdl, read_metadata_par) BIND(C) 
     364      USE ISO_C_BINDING 
     365      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     366      LOGICAL (KIND=C_BOOL)             :: read_metadata_par 
     367    END SUBROUTINE cxios_get_filegroup_read_metadata_par 
     368 
     369    FUNCTION cxios_is_defined_filegroup_read_metadata_par(filegroup_hdl) BIND(C) 
     370      USE ISO_C_BINDING 
     371      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_read_metadata_par 
     372      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     373    END FUNCTION cxios_is_defined_filegroup_read_metadata_par 
     374 
     375 
    336376    SUBROUTINE cxios_set_filegroup_record_offset(filegroup_hdl, record_offset) BIND(C) 
    337377      USE ISO_C_BINDING 
     
    351391      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
    352392    END FUNCTION cxios_is_defined_filegroup_record_offset 
     393 
     394 
     395    SUBROUTINE cxios_set_filegroup_split_end_offset(filegroup_hdl, split_end_offset) BIND(C) 
     396      USE ISO_C_BINDING 
     397      USE IDURATION 
     398      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     399      TYPE(txios(duration)), VALUE :: split_end_offset 
     400    END SUBROUTINE cxios_set_filegroup_split_end_offset 
     401 
     402    SUBROUTINE cxios_get_filegroup_split_end_offset(filegroup_hdl, split_end_offset) BIND(C) 
     403      USE ISO_C_BINDING 
     404      USE IDURATION 
     405      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     406      TYPE(txios(duration)) :: split_end_offset 
     407    END SUBROUTINE cxios_get_filegroup_split_end_offset 
     408 
     409    FUNCTION cxios_is_defined_filegroup_split_end_offset(filegroup_hdl) BIND(C) 
     410      USE ISO_C_BINDING 
     411      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_end_offset 
     412      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     413    END FUNCTION cxios_is_defined_filegroup_split_end_offset 
    353414 
    354415 
     
    395456 
    396457 
     458    SUBROUTINE cxios_set_filegroup_split_last_date(filegroup_hdl, split_last_date, split_last_date_size) BIND(C) 
     459      USE ISO_C_BINDING 
     460      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     461      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     462      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     463    END SUBROUTINE cxios_set_filegroup_split_last_date 
     464 
     465    SUBROUTINE cxios_get_filegroup_split_last_date(filegroup_hdl, split_last_date, split_last_date_size) BIND(C) 
     466      USE ISO_C_BINDING 
     467      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     468      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: split_last_date 
     469      INTEGER  (kind = C_INT)     , VALUE        :: split_last_date_size 
     470    END SUBROUTINE cxios_get_filegroup_split_last_date 
     471 
     472    FUNCTION cxios_is_defined_filegroup_split_last_date(filegroup_hdl) BIND(C) 
     473      USE ISO_C_BINDING 
     474      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_last_date 
     475      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     476    END FUNCTION cxios_is_defined_filegroup_split_last_date 
     477 
     478 
     479    SUBROUTINE cxios_set_filegroup_split_start_offset(filegroup_hdl, split_start_offset) BIND(C) 
     480      USE ISO_C_BINDING 
     481      USE IDURATION 
     482      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     483      TYPE(txios(duration)), VALUE :: split_start_offset 
     484    END SUBROUTINE cxios_set_filegroup_split_start_offset 
     485 
     486    SUBROUTINE cxios_get_filegroup_split_start_offset(filegroup_hdl, split_start_offset) BIND(C) 
     487      USE ISO_C_BINDING 
     488      USE IDURATION 
     489      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     490      TYPE(txios(duration)) :: split_start_offset 
     491    END SUBROUTINE cxios_get_filegroup_split_start_offset 
     492 
     493    FUNCTION cxios_is_defined_filegroup_split_start_offset(filegroup_hdl) BIND(C) 
     494      USE ISO_C_BINDING 
     495      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_split_start_offset 
     496      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     497    END FUNCTION cxios_is_defined_filegroup_split_start_offset 
     498 
     499 
    397500    SUBROUTINE cxios_set_filegroup_sync_freq(filegroup_hdl, sync_freq) BIND(C) 
    398501      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/grid_interface_attr.F90

    r932 r1492  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_grid_comment(grid_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_grid_comment 
     18 
     19    SUBROUTINE cxios_get_grid_comment(grid_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_grid_comment 
     25 
     26    FUNCTION cxios_is_defined_grid_comment(grid_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     30    END FUNCTION cxios_is_defined_grid_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_grid_description(grid_hdl, description, description_size) BIND(C) 
    1334      USE ISO_C_BINDING 
     
    3152 
    3253 
     54    SUBROUTINE cxios_set_grid_mask_0d(grid_hdl, mask_0d, extent) BIND(C) 
     55      USE ISO_C_BINDING 
     56      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl 
     57      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     58      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     59    END SUBROUTINE cxios_set_grid_mask_0d 
     60 
     61    SUBROUTINE cxios_get_grid_mask_0d(grid_hdl, mask_0d, extent) BIND(C) 
     62      USE ISO_C_BINDING 
     63      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl 
     64      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     65      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     66    END SUBROUTINE cxios_get_grid_mask_0d 
     67 
     68    FUNCTION cxios_is_defined_grid_mask_0d(grid_hdl) BIND(C) 
     69      USE ISO_C_BINDING 
     70      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask_0d 
     71      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl 
     72    END FUNCTION cxios_is_defined_grid_mask_0d 
     73 
     74 
    3375    SUBROUTINE cxios_set_grid_mask_1d(grid_hdl, mask_1d, extent) BIND(C) 
    3476      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/gridgroup_interface_attr.F90

    r932 r1492  
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
    1111 
     12    SUBROUTINE cxios_set_gridgroup_comment(gridgroup_hdl, comment, comment_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     16      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     17    END SUBROUTINE cxios_set_gridgroup_comment 
     18 
     19    SUBROUTINE cxios_get_gridgroup_comment(gridgroup_hdl, comment, comment_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: comment 
     23      INTEGER  (kind = C_INT)     , VALUE        :: comment_size 
     24    END SUBROUTINE cxios_get_gridgroup_comment 
     25 
     26    FUNCTION cxios_is_defined_gridgroup_comment(gridgroup_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_comment 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     30    END FUNCTION cxios_is_defined_gridgroup_comment 
     31 
     32 
    1233    SUBROUTINE cxios_set_gridgroup_description(gridgroup_hdl, description, description_size) BIND(C) 
    1334      USE ISO_C_BINDING 
     
    5273 
    5374 
     75    SUBROUTINE cxios_set_gridgroup_mask_0d(gridgroup_hdl, mask_0d, extent) BIND(C) 
     76      USE ISO_C_BINDING 
     77      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl 
     78      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     79      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     80    END SUBROUTINE cxios_set_gridgroup_mask_0d 
     81 
     82    SUBROUTINE cxios_get_gridgroup_mask_0d(gridgroup_hdl, mask_0d, extent) BIND(C) 
     83      USE ISO_C_BINDING 
     84      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl 
     85      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_0d 
     86      INTEGER (kind = C_INT), DIMENSION(*)     :: extent 
     87    END SUBROUTINE cxios_get_gridgroup_mask_0d 
     88 
     89    FUNCTION cxios_is_defined_gridgroup_mask_0d(gridgroup_hdl) BIND(C) 
     90      USE ISO_C_BINDING 
     91      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask_0d 
     92      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl 
     93    END FUNCTION cxios_is_defined_gridgroup_mask_0d 
     94 
     95 
    5496    SUBROUTINE cxios_set_gridgroup_mask_1d(gridgroup_hdl, mask_1d, extent) BIND(C) 
    5597      USE ISO_C_BINDING 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/iaxis_attr.F90

    r1158 r1492  
    1212 
    1313  SUBROUTINE xios(set_axis_attr)  & 
    14     ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    15     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    16      ) 
     14    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     15    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     16    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     17    , value ) 
    1718 
    1819    IMPLICIT NONE 
     
    2021      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    2122      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     23      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    2224      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    2325      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     27      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2428      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    2529      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    2630      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     31      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     32      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     33      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     34      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     35      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    2736      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    2837      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label(:) 
     
    4352      (axis_id,axis_hdl) 
    4453      CALL xios(set_axis_attr_hdl_)   & 
    45       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    46       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    47        ) 
     54      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     55      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     56      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     57      , value ) 
    4858 
    4959  END SUBROUTINE xios(set_axis_attr) 
    5060 
    5161  SUBROUTINE xios(set_axis_attr_hdl)  & 
    52     ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    53     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    54      ) 
     62    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     63    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     64    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     65    , value ) 
    5566 
    5667    IMPLICIT NONE 
    5768      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    5869      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     70      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    5971      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    6072      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     73      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     74      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    6175      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    6276      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    6377      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     78      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     79      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     80      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     81      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     82      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    6483      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
    6584      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label(:) 
     
    7897 
    7998      CALL xios(set_axis_attr_hdl_)  & 
    80       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    81       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    82        ) 
     99      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     100      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     101      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     102      , value ) 
    83103 
    84104  END SUBROUTINE xios(set_axis_attr_hdl) 
    85105 
    86106  SUBROUTINE xios(set_axis_attr_hdl_)   & 
    87     ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, index_, label_, long_name_  & 
    88     , mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_, unit_  & 
    89     , value_ ) 
     107    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  & 
     108    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  & 
     109    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
     110    , unit_, value_ ) 
    90111 
    91112    IMPLICIT NONE 
    92113      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    93114      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_ 
     115      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type_ 
    94116      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
    95117      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:) 
     118      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name_ 
     119      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    96120      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_ 
    97121      INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:) 
    98122      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_ 
     123      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name_ 
     124      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_ 
     125      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds_ 
     126      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_ 
     127      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds_ 
    99128      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:) 
    100129      CHARACTER(len=*) , OPTIONAL, INTENT(IN) :: label_(:) 
     
    117146      ENDIF 
    118147 
     148      IF (PRESENT(axis_type_)) THEN 
     149        CALL cxios_set_axis_axis_type & 
     150      (axis_hdl%daddr, axis_type_, len(axis_type_)) 
     151      ENDIF 
     152 
    119153      IF (PRESENT(begin_)) THEN 
    120154        CALL cxios_set_axis_begin & 
     
    127161      ENDIF 
    128162 
     163      IF (PRESENT(bounds_name_)) THEN 
     164        CALL cxios_set_axis_bounds_name & 
     165      (axis_hdl%daddr, bounds_name_, len(bounds_name_)) 
     166      ENDIF 
     167 
     168      IF (PRESENT(comment_)) THEN 
     169        CALL cxios_set_axis_comment & 
     170      (axis_hdl%daddr, comment_, len(comment_)) 
     171      ENDIF 
     172 
    129173      IF (PRESENT(data_begin_)) THEN 
    130174        CALL cxios_set_axis_data_begin & 
     
    140184        CALL cxios_set_axis_data_n & 
    141185      (axis_hdl%daddr, data_n_) 
     186      ENDIF 
     187 
     188      IF (PRESENT(dim_name_)) THEN 
     189        CALL cxios_set_axis_dim_name & 
     190      (axis_hdl%daddr, dim_name_, len(dim_name_)) 
     191      ENDIF 
     192 
     193      IF (PRESENT(formula_)) THEN 
     194        CALL cxios_set_axis_formula & 
     195      (axis_hdl%daddr, formula_, len(formula_)) 
     196      ENDIF 
     197 
     198      IF (PRESENT(formula_bounds_)) THEN 
     199        CALL cxios_set_axis_formula_bounds & 
     200      (axis_hdl%daddr, formula_bounds_, len(formula_bounds_)) 
     201      ENDIF 
     202 
     203      IF (PRESENT(formula_term_)) THEN 
     204        CALL cxios_set_axis_formula_term & 
     205      (axis_hdl%daddr, formula_term_, len(formula_term_)) 
     206      ENDIF 
     207 
     208      IF (PRESENT(formula_term_bounds_)) THEN 
     209        CALL cxios_set_axis_formula_term_bounds & 
     210      (axis_hdl%daddr, formula_term_bounds_, len(formula_term_bounds_)) 
    142211      ENDIF 
    143212 
     
    212281 
    213282  SUBROUTINE xios(get_axis_attr)  & 
    214     ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    215     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    216      ) 
     283    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     284    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     285    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     286    , value ) 
    217287 
    218288    IMPLICIT NONE 
     
    220290      CHARACTER(LEN=*), INTENT(IN) ::axis_id 
    221291      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     292      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    222293      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    223294      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     295      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     296      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    224297      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    225298      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    226299      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     300      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     301      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     302      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     303      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     304      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    227305      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    228306      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label(:) 
     
    243321      (axis_id,axis_hdl) 
    244322      CALL xios(get_axis_attr_hdl_)   & 
    245       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    246       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    247        ) 
     323      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     324      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     325      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     326      , value ) 
    248327 
    249328  END SUBROUTINE xios(get_axis_attr) 
    250329 
    251330  SUBROUTINE xios(get_axis_attr_hdl)  & 
    252     ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    253     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    254      ) 
     331    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     332    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     333    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     334    , value ) 
    255335 
    256336    IMPLICIT NONE 
    257337      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    258338      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     339      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    259340      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    260341      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     342      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     343      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    261344      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    262345      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    263346      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     347      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     348      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     349      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     350      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     351      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    264352      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
    265353      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label(:) 
     
    278366 
    279367      CALL xios(get_axis_attr_hdl_)  & 
    280       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    281       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    282        ) 
     368      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     369      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     370      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     371      , value ) 
    283372 
    284373  END SUBROUTINE xios(get_axis_attr_hdl) 
    285374 
    286375  SUBROUTINE xios(get_axis_attr_hdl_)   & 
    287     ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, index_, label_, long_name_  & 
    288     , mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_, unit_  & 
    289     , value_ ) 
     376    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  & 
     377    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  & 
     378    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
     379    , unit_, value_ ) 
    290380 
    291381    IMPLICIT NONE 
    292382      TYPE(txios(axis)) , INTENT(IN) :: axis_hdl 
    293383      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_ 
     384      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type_ 
    294385      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
    295386      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:) 
     387      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name_ 
     388      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_ 
    296389      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_ 
    297390      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:) 
    298391      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_ 
     392      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name_ 
     393      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_ 
     394      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds_ 
     395      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_ 
     396      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds_ 
    299397      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:) 
    300398      CHARACTER(len=*) , OPTIONAL, INTENT(OUT) :: label_(:) 
     
    317415      ENDIF 
    318416 
     417      IF (PRESENT(axis_type_)) THEN 
     418        CALL cxios_get_axis_axis_type & 
     419      (axis_hdl%daddr, axis_type_, len(axis_type_)) 
     420      ENDIF 
     421 
    319422      IF (PRESENT(begin_)) THEN 
    320423        CALL cxios_get_axis_begin & 
     
    327430      ENDIF 
    328431 
     432      IF (PRESENT(bounds_name_)) THEN 
     433        CALL cxios_get_axis_bounds_name & 
     434      (axis_hdl%daddr, bounds_name_, len(bounds_name_)) 
     435      ENDIF 
     436 
     437      IF (PRESENT(comment_)) THEN 
     438        CALL cxios_get_axis_comment & 
     439      (axis_hdl%daddr, comment_, len(comment_)) 
     440      ENDIF 
     441 
    329442      IF (PRESENT(data_begin_)) THEN 
    330443        CALL cxios_get_axis_data_begin & 
     
    340453        CALL cxios_get_axis_data_n & 
    341454      (axis_hdl%daddr, data_n_) 
     455      ENDIF 
     456 
     457      IF (PRESENT(dim_name_)) THEN 
     458        CALL cxios_get_axis_dim_name & 
     459      (axis_hdl%daddr, dim_name_, len(dim_name_)) 
     460      ENDIF 
     461 
     462      IF (PRESENT(formula_)) THEN 
     463        CALL cxios_get_axis_formula & 
     464      (axis_hdl%daddr, formula_, len(formula_)) 
     465      ENDIF 
     466 
     467      IF (PRESENT(formula_bounds_)) THEN 
     468        CALL cxios_get_axis_formula_bounds & 
     469      (axis_hdl%daddr, formula_bounds_, len(formula_bounds_)) 
     470      ENDIF 
     471 
     472      IF (PRESENT(formula_term_)) THEN 
     473        CALL cxios_get_axis_formula_term & 
     474      (axis_hdl%daddr, formula_term_, len(formula_term_)) 
     475      ENDIF 
     476 
     477      IF (PRESENT(formula_term_bounds_)) THEN 
     478        CALL cxios_get_axis_formula_term_bounds & 
     479      (axis_hdl%daddr, formula_term_bounds_, len(formula_term_bounds_)) 
    342480      ENDIF 
    343481 
     
    412550 
    413551  SUBROUTINE xios(is_defined_axis_attr)  & 
    414     ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    415     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    416      ) 
     552    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     553    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     554    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     555    , value ) 
    417556 
    418557    IMPLICIT NONE 
     
    421560      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    422561      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     562      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type 
     563      LOGICAL(KIND=C_BOOL) :: axis_type_tmp 
    423564      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    424565      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    425566      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    426567      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     568      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name 
     569      LOGICAL(KIND=C_BOOL) :: bounds_name_tmp 
     570      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     571      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    427572      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin 
    428573      LOGICAL(KIND=C_BOOL) :: data_begin_tmp 
     
    431576      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    432577      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
     578      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name 
     579      LOGICAL(KIND=C_BOOL) :: dim_name_tmp 
     580      LOGICAL, OPTIONAL, INTENT(OUT) :: formula 
     581      LOGICAL(KIND=C_BOOL) :: formula_tmp 
     582      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds 
     583      LOGICAL(KIND=C_BOOL) :: formula_bounds_tmp 
     584      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term 
     585      LOGICAL(KIND=C_BOOL) :: formula_term_tmp 
     586      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds 
     587      LOGICAL(KIND=C_BOOL) :: formula_term_bounds_tmp 
    433588      LOGICAL, OPTIONAL, INTENT(OUT) :: index 
    434589      LOGICAL(KIND=C_BOOL) :: index_tmp 
     
    461616      (axis_id,axis_hdl) 
    462617      CALL xios(is_defined_axis_attr_hdl_)   & 
    463       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    464       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    465        ) 
     618      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     619      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     620      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     621      , value ) 
    466622 
    467623  END SUBROUTINE xios(is_defined_axis_attr) 
    468624 
    469625  SUBROUTINE xios(is_defined_axis_attr_hdl)  & 
    470     ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    471     , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    472      ) 
     626    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     627    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     628    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     629    , value ) 
    473630 
    474631    IMPLICIT NONE 
     
    476633      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    477634      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     635      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type 
     636      LOGICAL(KIND=C_BOOL) :: axis_type_tmp 
    478637      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    479638      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    480639      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    481640      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     641      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name 
     642      LOGICAL(KIND=C_BOOL) :: bounds_name_tmp 
     643      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     644      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    482645      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin 
    483646      LOGICAL(KIND=C_BOOL) :: data_begin_tmp 
     
    486649      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    487650      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
     651      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name 
     652      LOGICAL(KIND=C_BOOL) :: dim_name_tmp 
     653      LOGICAL, OPTIONAL, INTENT(OUT) :: formula 
     654      LOGICAL(KIND=C_BOOL) :: formula_tmp 
     655      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds 
     656      LOGICAL(KIND=C_BOOL) :: formula_bounds_tmp 
     657      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term 
     658      LOGICAL(KIND=C_BOOL) :: formula_term_tmp 
     659      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds 
     660      LOGICAL(KIND=C_BOOL) :: formula_term_bounds_tmp 
    488661      LOGICAL, OPTIONAL, INTENT(OUT) :: index 
    489662      LOGICAL(KIND=C_BOOL) :: index_tmp 
     
    514687 
    515688      CALL xios(is_defined_axis_attr_hdl_)  & 
    516       ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, index, label, long_name  & 
    517       , mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit, value  & 
    518        ) 
     689      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     690      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  & 
     691      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
     692      , value ) 
    519693 
    520694  END SUBROUTINE xios(is_defined_axis_attr_hdl) 
    521695 
    522696  SUBROUTINE xios(is_defined_axis_attr_hdl_)   & 
    523     ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, index_, label_, long_name_  & 
    524     , mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_, unit_  & 
    525     , value_ ) 
     697    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  & 
     698    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  & 
     699    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
     700    , unit_, value_ ) 
    526701 
    527702    IMPLICIT NONE 
     
    529704      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_ 
    530705      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp 
     706      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type_ 
     707      LOGICAL(KIND=C_BOOL) :: axis_type__tmp 
    531708      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_ 
    532709      LOGICAL(KIND=C_BOOL) :: begin__tmp 
    533710      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_ 
    534711      LOGICAL(KIND=C_BOOL) :: bounds__tmp 
     712      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name_ 
     713      LOGICAL(KIND=C_BOOL) :: bounds_name__tmp 
     714      LOGICAL, OPTIONAL, INTENT(OUT) :: comment_ 
     715      LOGICAL(KIND=C_BOOL) :: comment__tmp 
    535716      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin_ 
    536717      LOGICAL(KIND=C_BOOL) :: data_begin__tmp 
     
    539720      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_ 
    540721      LOGICAL(KIND=C_BOOL) :: data_n__tmp 
     722      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name_ 
     723      LOGICAL(KIND=C_BOOL) :: dim_name__tmp 
     724      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_ 
     725      LOGICAL(KIND=C_BOOL) :: formula__tmp 
     726      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds_ 
     727      LOGICAL(KIND=C_BOOL) :: formula_bounds__tmp 
     728      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_ 
     729      LOGICAL(KIND=C_BOOL) :: formula_term__tmp 
     730      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds_ 
     731      LOGICAL(KIND=C_BOOL) :: formula_term_bounds__tmp 
    541732      LOGICAL, OPTIONAL, INTENT(OUT) :: index_ 
    542733      LOGICAL(KIND=C_BOOL) :: index__tmp 
     
    572763      ENDIF 
    573764 
     765      IF (PRESENT(axis_type_)) THEN 
     766        axis_type__tmp = cxios_is_defined_axis_axis_type & 
     767      (axis_hdl%daddr) 
     768        axis_type_ = axis_type__tmp 
     769      ENDIF 
     770 
    574771      IF (PRESENT(begin_)) THEN 
    575772        begin__tmp = cxios_is_defined_axis_begin & 
     
    584781      ENDIF 
    585782 
     783      IF (PRESENT(bounds_name_)) THEN 
     784        bounds_name__tmp = cxios_is_defined_axis_bounds_name & 
     785      (axis_hdl%daddr) 
     786        bounds_name_ = bounds_name__tmp 
     787      ENDIF 
     788 
     789      IF (PRESENT(comment_)) THEN 
     790        comment__tmp = cxios_is_defined_axis_comment & 
     791      (axis_hdl%daddr) 
     792        comment_ = comment__tmp 
     793      ENDIF 
     794 
    586795      IF (PRESENT(data_begin_)) THEN 
    587796        data_begin__tmp = cxios_is_defined_axis_data_begin & 
     
    602811      ENDIF 
    603812 
     813      IF (PRESENT(dim_name_)) THEN 
     814        dim_name__tmp = cxios_is_defined_axis_dim_name & 
     815      (axis_hdl%daddr) 
     816        dim_name_ = dim_name__tmp 
     817      ENDIF 
     818 
     819      IF (PRESENT(formula_)) THEN 
     820        formula__tmp = cxios_is_defined_axis_formula & 
     821      (axis_hdl%daddr) 
     822        formula_ = formula__tmp 
     823      ENDIF 
     824 
     825      IF (PRESENT(formula_bounds_)) THEN 
     826        formula_bounds__tmp = cxios_is_defined_axis_formula_bounds & 
     827      (axis_hdl%daddr) 
     828        formula_bounds_ = formula_bounds__tmp 
     829      ENDIF 
     830 
     831      IF (PRESENT(formula_term_)) THEN 
     832        formula_term__tmp = cxios_is_defined_axis_formula_term & 
     833      (axis_hdl%daddr) 
     834        formula_term_ = formula_term__tmp 
     835      ENDIF 
     836 
     837      IF (PRESENT(formula_term_bounds_)) THEN 
     838        formula_term_bounds__tmp = cxios_is_defined_axis_formula_term_bounds & 
     839      (axis_hdl%daddr) 
     840        formula_term_bounds_ = formula_term_bounds__tmp 
     841      ENDIF 
     842 
    604843      IF (PRESENT(index_)) THEN 
    605844        index__tmp = cxios_is_defined_axis_index & 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/iaxisgroup_attr.F90

    r1158 r1492  
    1212 
    1313  SUBROUTINE xios(set_axisgroup_attr)  & 
    14     ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    15     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    16     , value ) 
     14    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     15    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     16    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     17    , unit, value ) 
    1718 
    1819    IMPLICIT NONE 
     
    2021      CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id 
    2122      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     23      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    2224      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    2325      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     27      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2428      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    2529      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    2630      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     31      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     32      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     33      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     34      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     35      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    2736      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
    2837      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
     
    4453      (axisgroup_id,axisgroup_hdl) 
    4554      CALL xios(set_axisgroup_attr_hdl_)   & 
    46       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    47       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    48       , value ) 
     55      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     56      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     57      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     58      , unit, value ) 
    4959 
    5060  END SUBROUTINE xios(set_axisgroup_attr) 
    5161 
    5262  SUBROUTINE xios(set_axisgroup_attr_hdl)  & 
    53     ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    54     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    55     , value ) 
     63    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     64    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     65    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     66    , unit, value ) 
    5667 
    5768    IMPLICIT NONE 
    5869      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    5970      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref 
     71      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type 
    6072      INTEGER  , OPTIONAL, INTENT(IN) :: begin 
    6173      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:) 
     74      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name 
     75      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    6276      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin 
    6377      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:) 
    6478      INTEGER  , OPTIONAL, INTENT(IN) :: data_n 
     79      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name 
     80      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula 
     81      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds 
     82      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term 
     83      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds 
    6584      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
    6685      INTEGER  , OPTIONAL, INTENT(IN) :: index(:) 
     
    8099 
    81100      CALL xios(set_axisgroup_attr_hdl_)  & 
    82       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    83       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    84       , value ) 
     101      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     102      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     103      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     104      , unit, value ) 
    85105 
    86106  END SUBROUTINE xios(set_axisgroup_attr_hdl) 
    87107 
    88108  SUBROUTINE xios(set_axisgroup_attr_hdl_)   & 
    89     ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, index_  & 
    90     , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
    91     , unit_, value_ ) 
     109    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  & 
     110    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  & 
     111    , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  & 
     112    , positive_, prec_, standard_name_, unit_, value_ ) 
    92113 
    93114    IMPLICIT NONE 
    94115      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    95116      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_ 
     117      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_type_ 
    96118      INTEGER  , OPTIONAL, INTENT(IN) :: begin_ 
    97119      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:) 
     120      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name_ 
     121      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    98122      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_ 
    99123      INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:) 
    100124      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_ 
     125      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_name_ 
     126      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_ 
     127      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_bounds_ 
     128      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_ 
     129      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: formula_term_bounds_ 
    101130      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_ 
    102131      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:) 
     
    120149      ENDIF 
    121150 
     151      IF (PRESENT(axis_type_)) THEN 
     152        CALL cxios_set_axisgroup_axis_type & 
     153      (axisgroup_hdl%daddr, axis_type_, len(axis_type_)) 
     154      ENDIF 
     155 
    122156      IF (PRESENT(begin_)) THEN 
    123157        CALL cxios_set_axisgroup_begin & 
     
    130164      ENDIF 
    131165 
     166      IF (PRESENT(bounds_name_)) THEN 
     167        CALL cxios_set_axisgroup_bounds_name & 
     168      (axisgroup_hdl%daddr, bounds_name_, len(bounds_name_)) 
     169      ENDIF 
     170 
     171      IF (PRESENT(comment_)) THEN 
     172        CALL cxios_set_axisgroup_comment & 
     173      (axisgroup_hdl%daddr, comment_, len(comment_)) 
     174      ENDIF 
     175 
    132176      IF (PRESENT(data_begin_)) THEN 
    133177        CALL cxios_set_axisgroup_data_begin & 
     
    143187        CALL cxios_set_axisgroup_data_n & 
    144188      (axisgroup_hdl%daddr, data_n_) 
     189      ENDIF 
     190 
     191      IF (PRESENT(dim_name_)) THEN 
     192        CALL cxios_set_axisgroup_dim_name & 
     193      (axisgroup_hdl%daddr, dim_name_, len(dim_name_)) 
     194      ENDIF 
     195 
     196      IF (PRESENT(formula_)) THEN 
     197        CALL cxios_set_axisgroup_formula & 
     198      (axisgroup_hdl%daddr, formula_, len(formula_)) 
     199      ENDIF 
     200 
     201      IF (PRESENT(formula_bounds_)) THEN 
     202        CALL cxios_set_axisgroup_formula_bounds & 
     203      (axisgroup_hdl%daddr, formula_bounds_, len(formula_bounds_)) 
     204      ENDIF 
     205 
     206      IF (PRESENT(formula_term_)) THEN 
     207        CALL cxios_set_axisgroup_formula_term & 
     208      (axisgroup_hdl%daddr, formula_term_, len(formula_term_)) 
     209      ENDIF 
     210 
     211      IF (PRESENT(formula_term_bounds_)) THEN 
     212        CALL cxios_set_axisgroup_formula_term_bounds & 
     213      (axisgroup_hdl%daddr, formula_term_bounds_, len(formula_term_bounds_)) 
    145214      ENDIF 
    146215 
     
    220289 
    221290  SUBROUTINE xios(get_axisgroup_attr)  & 
    222     ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    223     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    224     , value ) 
     291    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     292    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     293    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     294    , unit, value ) 
    225295 
    226296    IMPLICIT NONE 
     
    228298      CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id 
    229299      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     300      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    230301      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    231302      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     303      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     304      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    232305      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    233306      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    234307      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     308      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     309      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     310      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     311      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     312      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    235313      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref 
    236314      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
     
    252330      (axisgroup_id,axisgroup_hdl) 
    253331      CALL xios(get_axisgroup_attr_hdl_)   & 
    254       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    255       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    256       , value ) 
     332      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     333      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     334      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     335      , unit, value ) 
    257336 
    258337  END SUBROUTINE xios(get_axisgroup_attr) 
    259338 
    260339  SUBROUTINE xios(get_axisgroup_attr_hdl)  & 
    261     ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    262     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    263     , value ) 
     340    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     341    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     342    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     343    , unit, value ) 
    264344 
    265345    IMPLICIT NONE 
    266346      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    267347      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref 
     348      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type 
    268349      INTEGER  , OPTIONAL, INTENT(OUT) :: begin 
    269350      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:) 
     351      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name 
     352      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    270353      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin 
    271354      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:) 
    272355      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n 
     356      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name 
     357      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula 
     358      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds 
     359      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term 
     360      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds 
    273361      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref 
    274362      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:) 
     
    288376 
    289377      CALL xios(get_axisgroup_attr_hdl_)  & 
    290       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    291       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    292       , value ) 
     378      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     379      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     380      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     381      , unit, value ) 
    293382 
    294383  END SUBROUTINE xios(get_axisgroup_attr_hdl) 
    295384 
    296385  SUBROUTINE xios(get_axisgroup_attr_hdl_)   & 
    297     ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, index_  & 
    298     , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
    299     , unit_, value_ ) 
     386    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  & 
     387    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  & 
     388    , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  & 
     389    , positive_, prec_, standard_name_, unit_, value_ ) 
    300390 
    301391    IMPLICIT NONE 
    302392      TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl 
    303393      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_ 
     394      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_type_ 
    304395      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_ 
    305396      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:) 
     397      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name_ 
     398      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_ 
    306399      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_ 
    307400      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:) 
    308401      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_ 
     402      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_name_ 
     403      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_ 
     404      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_bounds_ 
     405      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_ 
     406      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: formula_term_bounds_ 
    309407      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_ 
    310408      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:) 
     
    328426      ENDIF 
    329427 
     428      IF (PRESENT(axis_type_)) THEN 
     429        CALL cxios_get_axisgroup_axis_type & 
     430      (axisgroup_hdl%daddr, axis_type_, len(axis_type_)) 
     431      ENDIF 
     432 
    330433      IF (PRESENT(begin_)) THEN 
    331434        CALL cxios_get_axisgroup_begin & 
     
    338441      ENDIF 
    339442 
     443      IF (PRESENT(bounds_name_)) THEN 
     444        CALL cxios_get_axisgroup_bounds_name & 
     445      (axisgroup_hdl%daddr, bounds_name_, len(bounds_name_)) 
     446      ENDIF 
     447 
     448      IF (PRESENT(comment_)) THEN 
     449        CALL cxios_get_axisgroup_comment & 
     450      (axisgroup_hdl%daddr, comment_, len(comment_)) 
     451      ENDIF 
     452 
    340453      IF (PRESENT(data_begin_)) THEN 
    341454        CALL cxios_get_axisgroup_data_begin & 
     
    351464        CALL cxios_get_axisgroup_data_n & 
    352465      (axisgroup_hdl%daddr, data_n_) 
     466      ENDIF 
     467 
     468      IF (PRESENT(dim_name_)) THEN 
     469        CALL cxios_get_axisgroup_dim_name & 
     470      (axisgroup_hdl%daddr, dim_name_, len(dim_name_)) 
     471      ENDIF 
     472 
     473      IF (PRESENT(formula_)) THEN 
     474        CALL cxios_get_axisgroup_formula & 
     475      (axisgroup_hdl%daddr, formula_, len(formula_)) 
     476      ENDIF 
     477 
     478      IF (PRESENT(formula_bounds_)) THEN 
     479        CALL cxios_get_axisgroup_formula_bounds & 
     480      (axisgroup_hdl%daddr, formula_bounds_, len(formula_bounds_)) 
     481      ENDIF 
     482 
     483      IF (PRESENT(formula_term_)) THEN 
     484        CALL cxios_get_axisgroup_formula_term & 
     485      (axisgroup_hdl%daddr, formula_term_, len(formula_term_)) 
     486      ENDIF 
     487 
     488      IF (PRESENT(formula_term_bounds_)) THEN 
     489        CALL cxios_get_axisgroup_formula_term_bounds & 
     490      (axisgroup_hdl%daddr, formula_term_bounds_, len(formula_term_bounds_)) 
    353491      ENDIF 
    354492 
     
    428566 
    429567  SUBROUTINE xios(is_defined_axisgroup_attr)  & 
    430     ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    431     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    432     , value ) 
     568    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     569    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     570    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     571    , unit, value ) 
    433572 
    434573    IMPLICIT NONE 
     
    437576      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    438577      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     578      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type 
     579      LOGICAL(KIND=C_BOOL) :: axis_type_tmp 
    439580      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    440581      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    441582      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    442583      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     584      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name 
     585      LOGICAL(KIND=C_BOOL) :: bounds_name_tmp 
     586      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     587      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    443588      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin 
    444589      LOGICAL(KIND=C_BOOL) :: data_begin_tmp 
     
    447592      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    448593      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
     594      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name 
     595      LOGICAL(KIND=C_BOOL) :: dim_name_tmp 
     596      LOGICAL, OPTIONAL, INTENT(OUT) :: formula 
     597      LOGICAL(KIND=C_BOOL) :: formula_tmp 
     598      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds 
     599      LOGICAL(KIND=C_BOOL) :: formula_bounds_tmp 
     600      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term 
     601      LOGICAL(KIND=C_BOOL) :: formula_term_tmp 
     602      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds 
     603      LOGICAL(KIND=C_BOOL) :: formula_term_bounds_tmp 
    449604      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref 
    450605      LOGICAL(KIND=C_BOOL) :: group_ref_tmp 
     
    479634      (axisgroup_id,axisgroup_hdl) 
    480635      CALL xios(is_defined_axisgroup_attr_hdl_)   & 
    481       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    482       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    483       , value ) 
     636      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     637      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     638      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     639      , unit, value ) 
    484640 
    485641  END SUBROUTINE xios(is_defined_axisgroup_attr) 
    486642 
    487643  SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  & 
    488     ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    489     , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    490     , value ) 
     644    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     645    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     646    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     647    , unit, value ) 
    491648 
    492649    IMPLICIT NONE 
     
    494651      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref 
    495652      LOGICAL(KIND=C_BOOL) :: axis_ref_tmp 
     653      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type 
     654      LOGICAL(KIND=C_BOOL) :: axis_type_tmp 
    496655      LOGICAL, OPTIONAL, INTENT(OUT) :: begin 
    497656      LOGICAL(KIND=C_BOOL) :: begin_tmp 
    498657      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds 
    499658      LOGICAL(KIND=C_BOOL) :: bounds_tmp 
     659      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name 
     660      LOGICAL(KIND=C_BOOL) :: bounds_name_tmp 
     661      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     662      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    500663      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin 
    501664      LOGICAL(KIND=C_BOOL) :: data_begin_tmp 
     
    504667      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n 
    505668      LOGICAL(KIND=C_BOOL) :: data_n_tmp 
     669      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name 
     670      LOGICAL(KIND=C_BOOL) :: dim_name_tmp 
     671      LOGICAL, OPTIONAL, INTENT(OUT) :: formula 
     672      LOGICAL(KIND=C_BOOL) :: formula_tmp 
     673      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds 
     674      LOGICAL(KIND=C_BOOL) :: formula_bounds_tmp 
     675      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term 
     676      LOGICAL(KIND=C_BOOL) :: formula_term_tmp 
     677      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds 
     678      LOGICAL(KIND=C_BOOL) :: formula_term_bounds_tmp 
    506679      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref 
    507680      LOGICAL(KIND=C_BOOL) :: group_ref_tmp 
     
    534707 
    535708      CALL xios(is_defined_axisgroup_attr_hdl_)  & 
    536       ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, index, label  & 
    537       , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  & 
    538       , value ) 
     709      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  & 
     710      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  & 
     711      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  & 
     712      , unit, value ) 
    539713 
    540714  END SUBROUTINE xios(is_defined_axisgroup_attr_hdl) 
    541715 
    542716  SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   & 
    543     ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, index_  & 
    544     , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  & 
    545     , unit_, value_ ) 
     717    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  & 
     718    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  & 
     719    , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  & 
     720    , positive_, prec_, standard_name_, unit_, value_ ) 
    546721 
    547722    IMPLICIT NONE 
     
    549724      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_ 
    550725      LOGICAL(KIND=C_BOOL) :: axis_ref__tmp 
     726      LOGICAL, OPTIONAL, INTENT(OUT) :: axis_type_ 
     727      LOGICAL(KIND=C_BOOL) :: axis_type__tmp 
    551728      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_ 
    552729      LOGICAL(KIND=C_BOOL) :: begin__tmp 
    553730      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_ 
    554731      LOGICAL(KIND=C_BOOL) :: bounds__tmp 
     732      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name_ 
     733      LOGICAL(KIND=C_BOOL) :: bounds_name__tmp 
     734      LOGICAL, OPTIONAL, INTENT(OUT) :: comment_ 
     735      LOGICAL(KIND=C_BOOL) :: comment__tmp 
    555736      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin_ 
    556737      LOGICAL(KIND=C_BOOL) :: data_begin__tmp 
     
    559740      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_ 
    560741      LOGICAL(KIND=C_BOOL) :: data_n__tmp 
     742      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_name_ 
     743      LOGICAL(KIND=C_BOOL) :: dim_name__tmp 
     744      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_ 
     745      LOGICAL(KIND=C_BOOL) :: formula__tmp 
     746      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_bounds_ 
     747      LOGICAL(KIND=C_BOOL) :: formula_bounds__tmp 
     748      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_ 
     749      LOGICAL(KIND=C_BOOL) :: formula_term__tmp 
     750      LOGICAL, OPTIONAL, INTENT(OUT) :: formula_term_bounds_ 
     751      LOGICAL(KIND=C_BOOL) :: formula_term_bounds__tmp 
    561752      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_ 
    562753      LOGICAL(KIND=C_BOOL) :: group_ref__tmp 
     
    594785      ENDIF 
    595786 
     787      IF (PRESENT(axis_type_)) THEN 
     788        axis_type__tmp = cxios_is_defined_axisgroup_axis_type & 
     789      (axisgroup_hdl%daddr) 
     790        axis_type_ = axis_type__tmp 
     791      ENDIF 
     792 
    596793      IF (PRESENT(begin_)) THEN 
    597794        begin__tmp = cxios_is_defined_axisgroup_begin & 
     
    606803      ENDIF 
    607804 
     805      IF (PRESENT(bounds_name_)) THEN 
     806        bounds_name__tmp = cxios_is_defined_axisgroup_bounds_name & 
     807      (axisgroup_hdl%daddr) 
     808        bounds_name_ = bounds_name__tmp 
     809      ENDIF 
     810 
     811      IF (PRESENT(comment_)) THEN 
     812        comment__tmp = cxios_is_defined_axisgroup_comment & 
     813      (axisgroup_hdl%daddr) 
     814        comment_ = comment__tmp 
     815      ENDIF 
     816 
    608817      IF (PRESENT(data_begin_)) THEN 
    609818        data_begin__tmp = cxios_is_defined_axisgroup_data_begin & 
     
    624833      ENDIF 
    625834 
     835      IF (PRESENT(dim_name_)) THEN 
     836        dim_name__tmp = cxios_is_defined_axisgroup_dim_name & 
     837      (axisgroup_hdl%daddr) 
     838        dim_name_ = dim_name__tmp 
     839      ENDIF 
     840 
     841      IF (PRESENT(formula_)) THEN 
     842        formula__tmp = cxios_is_defined_axisgroup_formula & 
     843      (axisgroup_hdl%daddr) 
     844        formula_ = formula__tmp 
     845      ENDIF 
     846 
     847      IF (PRESENT(formula_bounds_)) THEN 
     848        formula_bounds__tmp = cxios_is_defined_axisgroup_formula_bounds & 
     849      (axisgroup_hdl%daddr) 
     850        formula_bounds_ = formula_bounds__tmp 
     851      ENDIF 
     852 
     853      IF (PRESENT(formula_term_)) THEN 
     854        formula_term__tmp = cxios_is_defined_axisgroup_formula_term & 
     855      (axisgroup_hdl%daddr) 
     856        formula_term_ = formula_term__tmp 
     857      ENDIF 
     858 
     859      IF (PRESENT(formula_term_bounds_)) THEN 
     860        formula_term_bounds__tmp = cxios_is_defined_axisgroup_formula_term_bounds & 
     861      (axisgroup_hdl%daddr) 
     862        formula_term_bounds_ = formula_term_bounds__tmp 
     863      ENDIF 
     864 
    626865      IF (PRESENT(group_ref_)) THEN 
    627866        group_ref__tmp = cxios_is_defined_axisgroup_group_ref & 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/icalendar_wrapper_attr.F90

    r966 r1492  
    1212 
    1313  SUBROUTINE xios(set_calendar_wrapper_attr)  & 
    14     ( calendar_wrapper_id, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     14    ( calendar_wrapper_id, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    1515    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    1616 
     
    1818      TYPE(txios(calendar_wrapper))  :: calendar_wrapper_hdl 
    1919      CHARACTER(LEN=*), INTENT(IN) ::calendar_wrapper_id 
     20      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2021      INTEGER  , OPTIONAL, INTENT(IN) :: day_length 
    2122      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: leap_year_drift 
     
    3233      (calendar_wrapper_id,calendar_wrapper_hdl) 
    3334      CALL xios(set_calendar_wrapper_attr_hdl_)   & 
    34       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     35      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    3536      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    3637 
     
    3839 
    3940  SUBROUTINE xios(set_calendar_wrapper_attr_hdl)  & 
    40     ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    41     , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    42  
    43     IMPLICIT NONE 
    44       TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     41    ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     42    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
     43 
     44    IMPLICIT NONE 
     45      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     46      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    4547      INTEGER  , OPTIONAL, INTENT(IN) :: day_length 
    4648      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: leap_year_drift 
     
    5557 
    5658      CALL xios(set_calendar_wrapper_attr_hdl_)  & 
    57       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     59      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    5860      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    5961 
     
    6163 
    6264  SUBROUTINE xios(set_calendar_wrapper_attr_hdl_)   & 
    63     ( calendar_wrapper_hdl, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
     65    ( calendar_wrapper_hdl, comment_, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
    6466    , month_lengths_, start_date_, time_origin_, timestep_, type_, year_length_ ) 
    6567 
    6668    IMPLICIT NONE 
    6769      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     70      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    6871      INTEGER  , OPTIONAL, INTENT(IN) :: day_length_ 
    6972      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: leap_year_drift_ 
     
    7780      INTEGER  , OPTIONAL, INTENT(IN) :: year_length_ 
    7881 
     82      IF (PRESENT(comment_)) THEN 
     83        CALL cxios_set_calendar_wrapper_comment & 
     84      (calendar_wrapper_hdl%daddr, comment_, len(comment_)) 
     85      ENDIF 
     86 
    7987      IF (PRESENT(day_length_)) THEN 
    8088        CALL cxios_set_calendar_wrapper_day_length & 
     
    130138 
    131139  SUBROUTINE xios(get_calendar_wrapper_attr)  & 
    132     ( calendar_wrapper_id, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     140    ( calendar_wrapper_id, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    133141    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    134142 
     
    136144      TYPE(txios(calendar_wrapper))  :: calendar_wrapper_hdl 
    137145      CHARACTER(LEN=*), INTENT(IN) ::calendar_wrapper_id 
     146      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    138147      INTEGER  , OPTIONAL, INTENT(OUT) :: day_length 
    139148      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: leap_year_drift 
     
    150159      (calendar_wrapper_id,calendar_wrapper_hdl) 
    151160      CALL xios(get_calendar_wrapper_attr_hdl_)   & 
    152       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     161      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    153162      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    154163 
     
    156165 
    157166  SUBROUTINE xios(get_calendar_wrapper_attr_hdl)  & 
    158     ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    159     , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    160  
    161     IMPLICIT NONE 
    162       TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     167    ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     168    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
     169 
     170    IMPLICIT NONE 
     171      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     172      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    163173      INTEGER  , OPTIONAL, INTENT(OUT) :: day_length 
    164174      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: leap_year_drift 
     
    173183 
    174184      CALL xios(get_calendar_wrapper_attr_hdl_)  & 
    175       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     185      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    176186      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    177187 
     
    179189 
    180190  SUBROUTINE xios(get_calendar_wrapper_attr_hdl_)   & 
    181     ( calendar_wrapper_hdl, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
     191    ( calendar_wrapper_hdl, comment_, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
    182192    , month_lengths_, start_date_, time_origin_, timestep_, type_, year_length_ ) 
    183193 
    184194    IMPLICIT NONE 
    185195      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     196      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_ 
    186197      INTEGER  , OPTIONAL, INTENT(OUT) :: day_length_ 
    187198      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: leap_year_drift_ 
     
    195206      INTEGER  , OPTIONAL, INTENT(OUT) :: year_length_ 
    196207 
     208      IF (PRESENT(comment_)) THEN 
     209        CALL cxios_get_calendar_wrapper_comment & 
     210      (calendar_wrapper_hdl%daddr, comment_, len(comment_)) 
     211      ENDIF 
     212 
    197213      IF (PRESENT(day_length_)) THEN 
    198214        CALL cxios_get_calendar_wrapper_day_length & 
     
    248264 
    249265  SUBROUTINE xios(is_defined_calendar_wrapper_attr)  & 
    250     ( calendar_wrapper_id, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     266    ( calendar_wrapper_id, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    251267    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    252268 
     
    254270      TYPE(txios(calendar_wrapper))  :: calendar_wrapper_hdl 
    255271      CHARACTER(LEN=*), INTENT(IN) ::calendar_wrapper_id 
     272      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     273      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    256274      LOGICAL, OPTIONAL, INTENT(OUT) :: day_length 
    257275      LOGICAL(KIND=C_BOOL) :: day_length_tmp 
     
    278296      (calendar_wrapper_id,calendar_wrapper_hdl) 
    279297      CALL xios(is_defined_calendar_wrapper_attr_hdl_)   & 
    280       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     298      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    281299      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    282300 
     
    284302 
    285303  SUBROUTINE xios(is_defined_calendar_wrapper_attr_hdl)  & 
    286     ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    287     , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    288  
    289     IMPLICIT NONE 
    290       TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     304    ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     305    , month_lengths, start_date, time_origin, timestep, type, year_length ) 
     306 
     307    IMPLICIT NONE 
     308      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     309      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     310      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    291311      LOGICAL, OPTIONAL, INTENT(OUT) :: day_length 
    292312      LOGICAL(KIND=C_BOOL) :: day_length_tmp 
     
    311331 
    312332      CALL xios(is_defined_calendar_wrapper_attr_hdl_)  & 
    313       ( calendar_wrapper_hdl, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
     333      ( calendar_wrapper_hdl, comment, day_length, leap_year_drift, leap_year_drift_offset, leap_year_month  & 
    314334      , month_lengths, start_date, time_origin, timestep, type, year_length ) 
    315335 
     
    317337 
    318338  SUBROUTINE xios(is_defined_calendar_wrapper_attr_hdl_)   & 
    319     ( calendar_wrapper_hdl, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
     339    ( calendar_wrapper_hdl, comment_, day_length_, leap_year_drift_, leap_year_drift_offset_, leap_year_month_  & 
    320340    , month_lengths_, start_date_, time_origin_, timestep_, type_, year_length_ ) 
    321341 
    322342    IMPLICIT NONE 
    323343      TYPE(txios(calendar_wrapper)) , INTENT(IN) :: calendar_wrapper_hdl 
     344      LOGICAL, OPTIONAL, INTENT(OUT) :: comment_ 
     345      LOGICAL(KIND=C_BOOL) :: comment__tmp 
    324346      LOGICAL, OPTIONAL, INTENT(OUT) :: day_length_ 
    325347      LOGICAL(KIND=C_BOOL) :: day_length__tmp 
     
    343365      LOGICAL(KIND=C_BOOL) :: year_length__tmp 
    344366 
     367      IF (PRESENT(comment_)) THEN 
     368        comment__tmp = cxios_is_defined_calendar_wrapper_comment & 
     369      (calendar_wrapper_hdl%daddr) 
     370        comment_ = comment__tmp 
     371      ENDIF 
     372 
    345373      IF (PRESENT(day_length_)) THEN 
    346374        day_length__tmp = cxios_is_defined_calendar_wrapper_day_length & 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/idomain_attr.F90

    r1158 r1492  
    1212 
    1313  SUBROUTINE xios(set_domain_attr)  & 
    14     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    15     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    16     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    17     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     14    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     15    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     16    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     17    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     18    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    1819 
    1920    IMPLICIT NONE 
     
    2324      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
    2425      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name 
    2527      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
    2628      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
     29      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name 
     30      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2731      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    2832      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    3236      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    3337      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     38      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name 
     39      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name 
    3440      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref 
    3541      INTEGER  , OPTIONAL, INTENT(IN) :: i_index(:) 
     
    3743      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    3844      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
     45      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name 
    3946      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
    4047      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
     48      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name 
    4149      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    4250      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     
    5967      (domain_id,domain_hdl) 
    6068      CALL xios(set_domain_attr_hdl_)   & 
    61       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    62       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    63       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    64       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     69      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     70      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     71      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     72      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     73      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    6574 
    6675  END SUBROUTINE xios(set_domain_attr) 
    6776 
    6877  SUBROUTINE xios(set_domain_attr_hdl)  & 
    69     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    70     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    71     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    72     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     78    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     79    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     80    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     81    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     82    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    7383 
    7484    IMPLICIT NONE 
     
    7787      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
    7888      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     89      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name 
    7990      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
    8091      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
     92      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name 
     93      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    8194      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    8295      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    8699      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    87100      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     101      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name 
     102      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name 
    88103      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref 
    89104      INTEGER  , OPTIONAL, INTENT(IN) :: i_index(:) 
     
    91106      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    92107      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
     108      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name 
    93109      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
    94110      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
     111      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name 
    95112      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    96113      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     
    111128 
    112129      CALL xios(set_domain_attr_hdl_)  & 
    113       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    114       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    115       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    116       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     130      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     131      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     132      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     133      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     134      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    117135 
    118136  END SUBROUTINE xios(set_domain_attr_hdl) 
    119137 
    120138  SUBROUTINE xios(set_domain_attr_hdl_)   & 
    121     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    122     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_ref_  & 
    123     , i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_, lonvalue_1d_  & 
    124     , lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_  & 
    125     , type_ ) 
     139    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  & 
     140    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  & 
     141    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  & 
     142    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  & 
     143    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_, type_ ) 
    126144 
    127145    IMPLICIT NONE 
     
    130148      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:) 
    131149      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:) 
     150      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name_ 
    132151      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:) 
    133152      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:) 
     153      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name_ 
     154      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    134155      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_ 
    135156      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
     
    139160      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_ 
    140161      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_ 
     162      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name_ 
     163      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name_ 
    141164      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref_ 
    142165      INTEGER  , OPTIONAL, INTENT(IN) :: i_index_(:) 
     
    144167      INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:) 
    145168      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_ 
     169      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name_ 
    146170      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:) 
    147171      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:) 
     172      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name_ 
    148173      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    149174      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:) 
     
    178203      ENDIF 
    179204 
     205      IF (PRESENT(bounds_lat_name_)) THEN 
     206        CALL cxios_set_domain_bounds_lat_name & 
     207      (domain_hdl%daddr, bounds_lat_name_, len(bounds_lat_name_)) 
     208      ENDIF 
     209 
    180210      IF (PRESENT(bounds_lon_1d_)) THEN 
    181211        CALL cxios_set_domain_bounds_lon_1d & 
     
    188218      ENDIF 
    189219 
     220      IF (PRESENT(bounds_lon_name_)) THEN 
     221        CALL cxios_set_domain_bounds_lon_name & 
     222      (domain_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_)) 
     223      ENDIF 
     224 
     225      IF (PRESENT(comment_)) THEN 
     226        CALL cxios_set_domain_comment & 
     227      (domain_hdl%daddr, comment_, len(comment_)) 
     228      ENDIF 
     229 
    190230      IF (PRESENT(data_dim_)) THEN 
    191231        CALL cxios_set_domain_data_dim & 
     
    223263      ENDIF 
    224264 
     265      IF (PRESENT(dim_i_name_)) THEN 
     266        CALL cxios_set_domain_dim_i_name & 
     267      (domain_hdl%daddr, dim_i_name_, len(dim_i_name_)) 
     268      ENDIF 
     269 
     270      IF (PRESENT(dim_j_name_)) THEN 
     271        CALL cxios_set_domain_dim_j_name & 
     272      (domain_hdl%daddr, dim_j_name_, len(dim_j_name_)) 
     273      ENDIF 
     274 
    225275      IF (PRESENT(domain_ref_)) THEN 
    226276        CALL cxios_set_domain_domain_ref & 
     
    248298      ENDIF 
    249299 
     300      IF (PRESENT(lat_name_)) THEN 
     301        CALL cxios_set_domain_lat_name & 
     302      (domain_hdl%daddr, lat_name_, len(lat_name_)) 
     303      ENDIF 
     304 
    250305      IF (PRESENT(latvalue_1d_)) THEN 
    251306        CALL cxios_set_domain_latvalue_1d & 
     
    256311        CALL cxios_set_domain_latvalue_2d & 
    257312      (domain_hdl%daddr, latvalue_2d_, SHAPE(latvalue_2d_)) 
     313      ENDIF 
     314 
     315      IF (PRESENT(lon_name_)) THEN 
     316        CALL cxios_set_domain_lon_name & 
     317      (domain_hdl%daddr, lon_name_, len(lon_name_)) 
    258318      ENDIF 
    259319 
     
    335395 
    336396  SUBROUTINE xios(get_domain_attr)  & 
    337     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    338     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    339     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    340     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     397    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     398    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     399    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     400    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     401    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    341402 
    342403    IMPLICIT NONE 
     
    346407      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
    347408      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     409      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lat_name 
    348410      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
    349411      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
     412      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name 
     413      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    350414      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    351415      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    355419      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    356420      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     421      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_i_name 
     422      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_j_name 
    357423      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: domain_ref 
    358424      INTEGER  , OPTIONAL, INTENT(OUT) :: i_index(:) 
     
    360426      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    361427      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
     428      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lat_name 
    362429      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
    363430      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
     431      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lon_name 
    364432      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    365433      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     
    382450      (domain_id,domain_hdl) 
    383451      CALL xios(get_domain_attr_hdl_)   & 
    384       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    385       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    386       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    387       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     452      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     453      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     454      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     455      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     456      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    388457 
    389458  END SUBROUTINE xios(get_domain_attr) 
    390459 
    391460  SUBROUTINE xios(get_domain_attr_hdl)  & 
    392     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    393     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    394     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    395     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     461    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     462    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     463    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     464    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     465    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    396466 
    397467    IMPLICIT NONE 
     
    400470      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
    401471      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     472      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lat_name 
    402473      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
    403474      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
     475      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name 
     476      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    404477      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    405478      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    409482      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    410483      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     484      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_i_name 
     485      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_j_name 
    411486      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: domain_ref 
    412487      INTEGER  , OPTIONAL, INTENT(OUT) :: i_index(:) 
     
    414489      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:) 
    415490      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin 
     491      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lat_name 
    416492      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:) 
    417493      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:) 
     494      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lon_name 
    418495      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name 
    419496      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:) 
     
    434511 
    435512      CALL xios(get_domain_attr_hdl_)  & 
    436       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    437       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    438       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    439       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     513      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     514      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     515      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     516      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     517      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    440518 
    441519  END SUBROUTINE xios(get_domain_attr_hdl) 
    442520 
    443521  SUBROUTINE xios(get_domain_attr_hdl_)   & 
    444     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    445     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_ref_  & 
    446     , i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_, lonvalue_1d_  & 
    447     , lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_  & 
    448     , type_ ) 
     522    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  & 
     523    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  & 
     524    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  & 
     525    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  & 
     526    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_, type_ ) 
    449527 
    450528    IMPLICIT NONE 
     
    453531      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:) 
    454532      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:) 
     533      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lat_name_ 
    455534      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d_(:,:) 
    456535      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:) 
     536      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name_ 
     537      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_ 
    457538      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_ 
    458539      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index_(:) 
     
    462543      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni_ 
    463544      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj_ 
     545      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_i_name_ 
     546      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_j_name_ 
    464547      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: domain_ref_ 
    465548      INTEGER  , OPTIONAL, INTENT(OUT) :: i_index_(:) 
     
    467550      INTEGER  , OPTIONAL, INTENT(OUT) :: j_index_(:) 
    468551      INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin_ 
     552      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lat_name_ 
    469553      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d_(:) 
    470554      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d_(:,:) 
     555      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: lon_name_ 
    471556      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_ 
    472557      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d_(:) 
     
    501586      ENDIF 
    502587 
     588      IF (PRESENT(bounds_lat_name_)) THEN 
     589        CALL cxios_get_domain_bounds_lat_name & 
     590      (domain_hdl%daddr, bounds_lat_name_, len(bounds_lat_name_)) 
     591      ENDIF 
     592 
    503593      IF (PRESENT(bounds_lon_1d_)) THEN 
    504594        CALL cxios_get_domain_bounds_lon_1d & 
     
    511601      ENDIF 
    512602 
     603      IF (PRESENT(bounds_lon_name_)) THEN 
     604        CALL cxios_get_domain_bounds_lon_name & 
     605      (domain_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_)) 
     606      ENDIF 
     607 
     608      IF (PRESENT(comment_)) THEN 
     609        CALL cxios_get_domain_comment & 
     610      (domain_hdl%daddr, comment_, len(comment_)) 
     611      ENDIF 
     612 
    513613      IF (PRESENT(data_dim_)) THEN 
    514614        CALL cxios_get_domain_data_dim & 
     
    546646      ENDIF 
    547647 
     648      IF (PRESENT(dim_i_name_)) THEN 
     649        CALL cxios_get_domain_dim_i_name & 
     650      (domain_hdl%daddr, dim_i_name_, len(dim_i_name_)) 
     651      ENDIF 
     652 
     653      IF (PRESENT(dim_j_name_)) THEN 
     654        CALL cxios_get_domain_dim_j_name & 
     655      (domain_hdl%daddr, dim_j_name_, len(dim_j_name_)) 
     656      ENDIF 
     657 
    548658      IF (PRESENT(domain_ref_)) THEN 
    549659        CALL cxios_get_domain_domain_ref & 
     
    571681      ENDIF 
    572682 
     683      IF (PRESENT(lat_name_)) THEN 
     684        CALL cxios_get_domain_lat_name & 
     685      (domain_hdl%daddr, lat_name_, len(lat_name_)) 
     686      ENDIF 
     687 
    573688      IF (PRESENT(latvalue_1d_)) THEN 
    574689        CALL cxios_get_domain_latvalue_1d & 
     
    579694        CALL cxios_get_domain_latvalue_2d & 
    580695      (domain_hdl%daddr, latvalue_2d_, SHAPE(latvalue_2d_)) 
     696      ENDIF 
     697 
     698      IF (PRESENT(lon_name_)) THEN 
     699        CALL cxios_get_domain_lon_name & 
     700      (domain_hdl%daddr, lon_name_, len(lon_name_)) 
    581701      ENDIF 
    582702 
     
    658778 
    659779  SUBROUTINE xios(is_defined_domain_attr)  & 
    660     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    661     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    662     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    663     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     780    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     781    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     782    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     783    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     784    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    664785 
    665786    IMPLICIT NONE 
     
    672793      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
    673794      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     795      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_name 
     796      LOGICAL(KIND=C_BOOL) :: bounds_lat_name_tmp 
    674797      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
    675798      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
    676799      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
    677800      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
     801      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name 
     802      LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp 
     803      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     804      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    678805      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    679806      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    690817      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj 
    691818      LOGICAL(KIND=C_BOOL) :: data_nj_tmp 
     819      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_i_name 
     820      LOGICAL(KIND=C_BOOL) :: dim_i_name_tmp 
     821      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_j_name 
     822      LOGICAL(KIND=C_BOOL) :: dim_j_name_tmp 
    692823      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref 
    693824      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp 
     
    700831      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    701832      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
     833      LOGICAL, OPTIONAL, INTENT(OUT) :: lat_name 
     834      LOGICAL(KIND=C_BOOL) :: lat_name_tmp 
    702835      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
    703836      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
    704837      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
    705838      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
     839      LOGICAL, OPTIONAL, INTENT(OUT) :: lon_name 
     840      LOGICAL(KIND=C_BOOL) :: lon_name_tmp 
    706841      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    707842      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
     
    736871      (domain_id,domain_hdl) 
    737872      CALL xios(is_defined_domain_attr_hdl_)   & 
    738       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    739       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    740       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    741       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     873      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     874      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     875      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     876      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     877      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    742878 
    743879  END SUBROUTINE xios(is_defined_domain_attr) 
    744880 
    745881  SUBROUTINE xios(is_defined_domain_attr_hdl)  & 
    746     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    747     , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    748     , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    749     , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     882    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     883    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     884    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     885    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     886    , nj, nj_glo, nvertex, prec, standard_name, type ) 
    750887 
    751888    IMPLICIT NONE 
     
    757894      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d 
    758895      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp 
     896      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_name 
     897      LOGICAL(KIND=C_BOOL) :: bounds_lat_name_tmp 
    759898      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d 
    760899      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp 
    761900      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d 
    762901      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp 
     902      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name 
     903      LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp 
     904      LOGICAL, OPTIONAL, INTENT(OUT) :: comment 
     905      LOGICAL(KIND=C_BOOL) :: comment_tmp 
    763906      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim 
    764907      LOGICAL(KIND=C_BOOL) :: data_dim_tmp 
     
    775918      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj 
    776919      LOGICAL(KIND=C_BOOL) :: data_nj_tmp 
     920      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_i_name 
     921      LOGICAL(KIND=C_BOOL) :: dim_i_name_tmp 
     922      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_j_name 
     923      LOGICAL(KIND=C_BOOL) :: dim_j_name_tmp 
    777924      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref 
    778925      LOGICAL(KIND=C_BOOL) :: domain_ref_tmp 
     
    785932      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin 
    786933      LOGICAL(KIND=C_BOOL) :: jbegin_tmp 
     934      LOGICAL, OPTIONAL, INTENT(OUT) :: lat_name 
     935      LOGICAL(KIND=C_BOOL) :: lat_name_tmp 
    787936      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d 
    788937      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp 
    789938      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d 
    790939      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp 
     940      LOGICAL, OPTIONAL, INTENT(OUT) :: lon_name 
     941      LOGICAL(KIND=C_BOOL) :: lon_name_tmp 
    791942      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name 
    792943      LOGICAL(KIND=C_BOOL) :: long_name_tmp 
     
    819970 
    820971      CALL xios(is_defined_domain_attr_hdl_)  & 
    821       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  & 
    822       , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, i_index, ibegin, j_index  & 
    823       , jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name  & 
    824       , ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     972      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     973      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     974      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  & 
     975      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  & 
     976      , nj, nj_glo, nvertex, prec, standard_name, type ) 
    825977 
    826978  END SUBROUTINE xios(is_defined_domain_attr_hdl) 
    827979 
    828980  SUBROUTINE xios(is_defined_domain_attr_hdl_)   & 
    829     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    830     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_ref_  & 
    831     , i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_, lonvalue_1d_  & 
    832     , lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_  & 
    833     , type_ ) 
     981    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  & 
     982    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  & 
     983    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  & 
     984    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  & 
     985    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_, type_ ) 
    834986 
    835987    IMPLICIT NONE 
     
    841993      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d_ 
    842994      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d__tmp 
     995      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_name_ 
     996      LOGICAL(KIND=C_BOOL) :: bounds_lat_name__tmp 
    843997      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d_ 
    844998      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d__tmp 
    845999      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d_ 
    8461000      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d__tmp 
     1001      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name_ 
     1002      LOGICAL(KIND=C_BOOL) :: bounds_lon_name__tmp 
     1003      LOGICAL, OPTIONAL, INTENT(OUT) :: comment_ 
     1004      LOGICAL(KIND=C_BOOL) :: comment__tmp 
    8471005      LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_ 
    8481006      LOGICAL(KIND=C_BOOL) :: data_dim__tmp 
     
    8591017      LOGICAL, OPTIONAL, INTENT(OUT) :: data_nj_ 
    8601018      LOGICAL(KIND=C_BOOL) :: data_nj__tmp 
     1019      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_i_name_ 
     1020      LOGICAL(KIND=C_BOOL) :: dim_i_name__tmp 
     1021      LOGICAL, OPTIONAL, INTENT(OUT) :: dim_j_name_ 
     1022      LOGICAL(KIND=C_BOOL) :: dim_j_name__tmp 
    8611023      LOGICAL, OPTIONAL, INTENT(OUT) :: domain_ref_ 
    8621024      LOGICAL(KIND=C_BOOL) :: domain_ref__tmp 
     
    8691031      LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_ 
    8701032      LOGICAL(KIND=C_BOOL) :: jbegin__tmp 
     1033      LOGICAL, OPTIONAL, INTENT(OUT) :: lat_name_ 
     1034      LOGICAL(KIND=C_BOOL) :: lat_name__tmp 
    8711035      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d_ 
    8721036      LOGICAL(KIND=C_BOOL) :: latvalue_1d__tmp 
    8731037      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d_ 
    8741038      LOGICAL(KIND=C_BOOL) :: latvalue_2d__tmp 
     1039      LOGICAL, OPTIONAL, INTENT(OUT) :: lon_name_ 
     1040      LOGICAL(KIND=C_BOOL) :: lon_name__tmp 
    8751041      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_ 
    8761042      LOGICAL(KIND=C_BOOL) :: long_name__tmp 
     
    9201086      ENDIF 
    9211087 
     1088      IF (PRESENT(bounds_lat_name_)) THEN 
     1089        bounds_lat_name__tmp = cxios_is_defined_domain_bounds_lat_name & 
     1090      (domain_hdl%daddr) 
     1091        bounds_lat_name_ = bounds_lat_name__tmp 
     1092      ENDIF 
     1093 
    9221094      IF (PRESENT(bounds_lon_1d_)) THEN 
    9231095        bounds_lon_1d__tmp = cxios_is_defined_domain_bounds_lon_1d & 
     
    9321104      ENDIF 
    9331105 
     1106      IF (PRESENT(bounds_lon_name_)) THEN 
     1107        bounds_lon_name__tmp = cxios_is_defined_domain_bounds_lon_name & 
     1108      (domain_hdl%daddr) 
     1109        bounds_lon_name_ = bounds_lon_name__tmp 
     1110      ENDIF 
     1111 
     1112      IF (PRESENT(comment_)) THEN 
     1113        comment__tmp = cxios_is_defined_domain_comment & 
     1114      (domain_hdl%daddr) 
     1115        comment_ = comment__tmp 
     1116      ENDIF 
     1117 
    9341118      IF (PRESENT(data_dim_)) THEN 
    9351119        data_dim__tmp = cxios_is_defined_domain_data_dim & 
     
    9741158      ENDIF 
    9751159 
     1160      IF (PRESENT(dim_i_name_)) THEN 
     1161        dim_i_name__tmp = cxios_is_defined_domain_dim_i_name & 
     1162      (domain_hdl%daddr) 
     1163        dim_i_name_ = dim_i_name__tmp 
     1164      ENDIF 
     1165 
     1166      IF (PRESENT(dim_j_name_)) THEN 
     1167        dim_j_name__tmp = cxios_is_defined_domain_dim_j_name & 
     1168      (domain_hdl%daddr) 
     1169        dim_j_name_ = dim_j_name__tmp 
     1170      ENDIF 
     1171 
    9761172      IF (PRESENT(domain_ref_)) THEN 
    9771173        domain_ref__tmp = cxios_is_defined_domain_domain_ref & 
     
    10041200      ENDIF 
    10051201 
     1202      IF (PRESENT(lat_name_)) THEN 
     1203        lat_name__tmp = cxios_is_defined_domain_lat_name & 
     1204      (domain_hdl%daddr) 
     1205        lat_name_ = lat_name__tmp 
     1206      ENDIF 
     1207 
    10061208      IF (PRESENT(latvalue_1d_)) THEN 
    10071209        latvalue_1d__tmp = cxios_is_defined_domain_latvalue_1d & 
     
    10161218      ENDIF 
    10171219 
     1220      IF (PRESENT(lon_name_)) THEN 
     1221        lon_name__tmp = cxios_is_defined_domain_lon_name & 
     1222      (domain_hdl%daddr) 
     1223        lon_name_ = lon_name__tmp 
     1224      ENDIF 
     1225 
    10181226      IF (PRESENT(long_name_)) THEN 
    10191227        long_name__tmp = cxios_is_defined_domain_long_name & 
  • XIOS/dev/XIOS_DEV_CMIP6/src/interface/fortran_attr/idomaingroup_attr.F90

    r1158 r1492  
    1212 
    1313  SUBROUTINE xios(set_domaingroup_attr)  & 
    14     ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    15     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, group_ref  & 
    16     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    17     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     14    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     15    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     16    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  & 
     17    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  & 
     18    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
    1819 
    1920    IMPLICIT NONE 
     
    2324      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
    2425      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     26      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name 
    2527      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
    2628      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
     29      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name 
     30      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    2731      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    2832      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    3236      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    3337      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     38      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name 
     39      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name 
    3440      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref 
    3541      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
     
    3844      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    3945      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
     46      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name 
    4047      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
    4148      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
     49      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name 
    4250      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    4351      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     
    6068      (domaingroup_id,domaingroup_hdl) 
    6169      CALL xios(set_domaingroup_attr_hdl_)   & 
    62       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    63       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, group_ref  & 
    64       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    65       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     70      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     71      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     72      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  & 
     73      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  & 
     74      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
    6675 
    6776  END SUBROUTINE xios(set_domaingroup_attr) 
    6877 
    6978  SUBROUTINE xios(set_domaingroup_attr_hdl)  & 
    70     ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    71     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, group_ref  & 
    72     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    73     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     79    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     80    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     81    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  & 
     82    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  & 
     83    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
    7484 
    7585    IMPLICIT NONE 
     
    7888      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:) 
    7989      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:) 
     90      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name 
    8091      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:) 
    8192      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:) 
     93      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name 
     94      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment 
    8295      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim 
    8396      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:) 
     
    87100      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni 
    88101      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj 
     102      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name 
     103      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name 
    89104      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref 
    90105      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref 
     
    93108      INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:) 
    94109      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin 
     110      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name 
    95111      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:) 
    96112      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:) 
     113      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name 
    97114      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name 
    98115      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:) 
     
    113130 
    114131      CALL xios(set_domaingroup_attr_hdl_)  & 
    115       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    116       , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, group_ref  & 
    117       , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    118       , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     132      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     133      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     134      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  & 
     135      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  & 
     136      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
    119137 
    120138  END SUBROUTINE xios(set_domaingroup_attr_hdl) 
    121139 
    122140  SUBROUTINE xios(set_domaingroup_attr_hdl_)   & 
    123     ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  & 
    124     , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_ref_  & 
    125     , group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_, lonvalue_1d_  & 
    126     , lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_  & 
    127     , type_ ) 
     141    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  & 
     142    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  & 
     143    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  & 
     144    , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  & 
     145    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, standard_name_, type_  & 
     146     ) 
    128147 
    129148    IMPLICIT NONE 
     
    132151      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:) 
    133152      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:) 
     153      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lat_name_ 
    134154      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:) 
    135155      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:) 
     156      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name_ 
     157      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_ 
    136158      INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_ 
    137159      INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:) 
     
    141163      INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_ 
    142164      INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_ 
     165      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_i_name_ 
     166      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: dim_j_name_ 
    143167      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: domain_ref_ 
    144168      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_ 
     
    147171      INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:) 
    148172      INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_ 
     173      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lat_name_ 
    149174      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:) 
    150175      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:) 
     176      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: lon_name_ 
    151177      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_ 
    152178      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:) 
     
    181207      ENDIF 
    182208 
     209      IF (PRESENT(bounds_lat_name_)) THEN 
     210        CALL cxios_set_domaingroup_bounds_lat_name & 
     211      (domaingroup_hdl%daddr, bounds_lat_name_, len(bounds_lat_name_)) 
     212      ENDIF 
     213 
    183214      IF (PRESENT(bounds_lon_1d_)) THEN 
    184215        CALL cxios_set_domaingroup_bounds_lon_1d & 
     
    191222      ENDIF 
    192223 
     224      IF (PRESENT(bounds_lon_name_)) THEN 
     225        CALL cxios_set_domaingroup_bounds_lon_name & 
     226      (domaingroup_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_)) 
     227      ENDIF 
     228 
     229      IF (PRESENT(comment_)) THEN 
     230        CALL cxios_set_domaingroup_comment & 
     231      (domaingroup_hdl%daddr, comment_, len(comment_)) 
     232      ENDIF 
     233 
    193234      IF (PRESENT(data_dim_)) THEN 
    194235        CALL cxios_set_domaingroup_data_dim & 
     
    226267      ENDIF 
    227268 
     269      IF (PRESENT(dim_i_name_)) THEN 
     270        CALL cxios_set_domaingroup_dim_i_name & 
     271      (domaingroup_hdl%daddr, dim_i_name_, len(dim_i_name_)) 
     272      ENDIF 
     273 
     274      IF (PRESENT(dim_j_name_)) THEN 
     275        CALL cxios_set_domaingroup_dim_j_name & 
     276      (domaingroup_hdl%daddr, dim_j_name_, len(dim_j_name_)) 
     277      ENDIF 
     278 
    228279      IF (PRESENT(domain_ref_)) THEN 
    229280        CALL cxios_set_domaingroup_domain_ref & 
     
    256307      ENDIF 
    257308 
     309      IF (PRESENT(lat_name_)) THEN 
     310        CALL cxios_set_domaingroup_lat_name & 
     311      (domaingroup_hdl%daddr, lat_name_, len(lat_name_)) 
     312      ENDIF 
     313 
    258314      IF (PRESENT(latvalue_1d_)) THEN 
    259315        CALL cxios_set_domaingroup_latvalue_1d & 
     
    264320        CALL cxios_set_domaingroup_latvalue_2d & 
    265321      (domaingroup_hdl%daddr, latvalue_2d_, SHAPE(latvalue_2d_)) 
     322      ENDIF 
     323 
     324      IF (PRESENT(lon_name_)) THEN 
     325        CALL cxios_set_domaingroup_lon_name & 
     326      (domaingroup_hdl%daddr, lon_name_, len(lon_name_)) 
    266327      ENDIF 
    267328 
     
    343404 
    344405  SUBROUTINE xios(get_domaingroup_attr)  & 
    345     ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  & 
    346     , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_ref, group_ref  & 
    347     , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  & 
    348     , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
     406    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  & 
     407    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  & 
     408    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  & 
     409    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  & 
     410    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, standard_name, type ) 
    349411 
    350412    IMPLICIT NONE 
     
    354416      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:) 
    355417      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:) 
     418      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lat_name 
    356419      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:) 
    357420      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:) 
     421      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name 
     422      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment 
    358423      INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim 
    359424      INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:) 
     
    363428      INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni 
    364429      INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj 
     430      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_i_name 
     431      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: dim_j_name 
    365432      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: domain_ref 
    366433      CHARAC