Changeset 891


Ignore:
Timestamp:
07/05/16 15:59:23 (5 years ago)
Author:
mhnguyen
Message:

Adding Fortran interface for reduce_axis_to_scalar

Test
+) On Curie
+) Only compilation

Location:
XIOS/trunk/src
Files:
16 added
24 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/generate_fortran_interface.cpp

    r786 r891  
    55#include "object_template.hpp" 
    66#include "group_template.hpp" 
    7 //#include "context.hpp" 
    8 //#include "file.hpp" 
    9 //#include "zoom_domain.hpp" 
    10 //#include "zoom_axis.hpp" 
    11 //#include "interpolate_axis.hpp" 
    12 //#include "interpolate_domain.hpp" 
    137#include "node_type.hpp" 
    148 
     
    2014  CContext* context=CContext::create("interface"); 
    2115  CCalendarWrapper calendarWrapper; 
     16  CScalar scalar; 
     17  CScalarGroup scalargroup; 
    2218  CAxis axis; 
    2319  CAxisGroup axisgroup; 
     
    3430  CFileGroup filegroup; 
    3531 
     32  CInterpolateDomain interpolateDomain; 
    3633  CZoomDomain zoomDomain; 
     34  CGenerateRectilinearDomain genDomain; 
     35 
     36  CInterpolateAxis interpolateAxis; 
    3737  CZoomAxis zoomAxis; 
    38  
    39   CInterpolateAxis interpolateAxis; 
    40   CInterpolateDomain interpolateDomain; 
    41  
    42   CGenerateRectilinearDomain genDomain; 
    4338  CInverseAxis inverseAxis; 
     39 
     40  CReduceAxisToScalar reduceAxisToScalar; 
    4441 
    4542  ostringstream oss; 
    4643  ofstream file; 
    4744 
     45  file.open((path+"scalar_interface_attr.F90").c_str()); 
     46  scalar.generateFortran2003Interface(file); 
     47  file.close(); 
     48 
     49  file.open((path+"icscalar_attr.cpp").c_str()); 
     50  scalar.generateCInterface(file); 
     51  file.close(); 
     52 
     53  file.open((path+"iscalar_attr.F90").c_str()); 
     54  scalar.generateFortranInterface(file); 
     55  file.close(); 
     56 
     57  file.open((path+"scalargroup_interface_attr.F90").c_str()); 
     58  scalargroup.generateFortran2003Interface(file); 
     59  file.close(); 
     60 
     61  file.open((path+"icscalargroup_attr.cpp").c_str()); 
     62  scalargroup.generateCInterface(file); 
     63  file.close(); 
     64 
     65  file.open((path+"iscalargroup_attr.F90").c_str()); 
     66  scalargroup.generateFortranInterface(file); 
     67  file.close(); 
     68 
    4869  file.open((path+"axis_interface_attr.F90").c_str()); 
    4970  axis.generateFortran2003Interface(file); 
     
    281302  file.close(); 
    282303 
     304  file.open((path+"reduce_axis_to_scalar_interface_attr.F90").c_str()); 
     305  reduceAxisToScalar.generateFortran2003Interface(file); 
     306  file.close(); 
     307 
     308  file.open((path+"icreduce_axis_to_scalar_attr.cpp").c_str()); 
     309  reduceAxisToScalar.generateCInterface(file); 
     310  file.close(); 
     311 
     312  file.open((path+"ireduce_axis_to_scalar_attr.F90").c_str()); 
     313  reduceAxisToScalar.generateFortranInterface(file); 
     314  file.close(); 
     315 
    283316  file.open((path+"context_interface_attr.F90").c_str()); 
    284317  context->generateFortran2003Interface(file); 
  • XIOS/trunk/src/interface/c/icxml_tree.cpp

    r836 r891  
    1515#include "timer.hpp" 
    1616#include "context.hpp" 
    17 #include "grid.hpp" 
    18 #include "file.hpp" 
    19 #include "field.hpp" 
    20 #include "axis.hpp" 
    21 #include "domain.hpp" 
    22 #include "variable.hpp" 
    23 #include "zoom_domain.hpp" 
    24 #include "interpolate_domain.hpp" 
    25 #include "generate_rectilinear_domain.hpp" 
    26 #include "zoom_axis.hpp" 
    27 #include "interpolate_axis.hpp" 
    28 #include "inverse_axis.hpp" 
     17#include "node_type.hpp" 
    2918 
    3019extern "C" 
     
    4736   typedef xios::CDomain      * XDomainPtr; 
    4837   typedef xios::CDomainGroup * XDomainGroupPtr; 
     38 
     39   typedef xios::CScalar      * XScalarPtr; 
     40   typedef xios::CScalarGroup * XScalarGroupPtr; 
    4941 
    5042   typedef xios::CAxis      * XAxisPtr; 
     
    6456   typedef xios::CInverseAxis             *  XInverseAxisPtr; 
    6557 
     58   typedef xios::CTransformation<CScalar>   *  XTransformationScalarPtr; 
     59   typedef xios::CReduceAxisToScalar        *  XReduceAxisToScalarPtr; 
     60 
    6661   // ----------------------- Ajout d'enfant à un parent ----------------------- 
    6762 
     
    130125   } 
    131126 
     127   void cxios_xml_tree_add_scalar 
     128      (XScalarGroupPtr parent_, XScalarPtr * child_, const char * child_id, int child_id_size) 
     129   { 
     130      std::string child_id_str; 
     131      CTimer::get("XIOS").resume() ; 
     132      if (cstr2string(child_id, child_id_size, child_id_str)) 
     133      { 
     134         *child_ = parent_->createChild(child_id_str) ; 
     135      } 
     136      else 
     137      { 
     138         *child_ = parent_->createChild() ; 
     139      } 
     140      CTimer::get("XIOS").suspend() ; 
     141   } 
     142 
    132143   void cxios_xml_tree_add_domain 
    133144      (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size) 
     
    246257   } 
    247258 
     259   void cxios_xml_tree_add_scalargroup 
     260      (XScalarGroupPtr parent_, XScalarGroupPtr * child_, const char * child_id, int child_id_size) 
     261   { 
     262      std::string child_id_str; 
     263      CTimer::get("XIOS").resume() ; 
     264      if (cstr2string(child_id, child_id_size, child_id_str)) 
     265      { 
     266         *child_ = parent_->createChildGroup(child_id_str) ; 
     267      } 
     268      else 
     269      { 
     270         *child_ = parent_->createChildGroup() ; 
     271      } 
     272      CTimer::get("XIOS").suspend() ; 
     273   } 
     274 
    248275   void cxios_xml_tree_add_axisgroup 
    249276      (XAxisGroupPtr parent_, XAxisGroupPtr * child_, const char * child_id, int child_id_size) 
     
    326353   } 
    327354 
     355   void cxios_xml_tree_add_scalartogrid 
     356      (XGridPtr parent_, XScalarPtr * child_, const char * child_id, int child_id_size) 
     357   { 
     358      std::string child_id_str; 
     359      CTimer::get("XIOS").resume() ; 
     360      if (cstr2string(child_id, child_id_size, child_id_str)) 
     361      { 
     362         *child_ = parent_->addScalar(child_id_str); 
     363      } 
     364      else 
     365      { 
     366         *child_ = parent_->addScalar(); 
     367      } 
     368      CTimer::get("XIOS").suspend() ; 
     369   } 
     370 
    328371   void cxios_xml_tree_add_axistogrid 
    329372      (XGridPtr parent_, XAxisPtr * child_, const char * child_id, int child_id_size) 
     
    463506      } 
    464507      *child_ = static_cast<XInverseAxisPtr>(tmpChild_); 
     508      CTimer::get("XIOS").suspend() ; 
     509   } 
     510 
     511   void cxios_xml_tree_add_reduceaxistoscalartoscalar 
     512      (XScalarPtr parent_, XReduceAxisToScalarPtr * child_, const char * child_id, int child_id_size) 
     513   { 
     514      std::string child_id_str; 
     515      XTransformationScalarPtr tmpChild_; 
     516      CTimer::get("XIOS").resume() ; 
     517      if (cstr2string(child_id, child_id_size, child_id_str)) 
     518      { 
     519         tmpChild_ = parent_->addTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, child_id_str); 
     520      } 
     521      else 
     522      { 
     523         tmpChild_ = parent_->addTransformation(TRANS_REDUCE_AXIS_TO_SCALAR); 
     524      } 
     525      *child_ = static_cast<XReduceAxisToScalarPtr>(tmpChild_); 
    465526      CTimer::get("XIOS").suspend() ; 
    466527   } 
  • XIOS/trunk/src/interface/c_attr/icfield_attr.cpp

    r790 r891  
    509509 
    510510 
     511  void cxios_set_field_scalar_ref(field_Ptr field_hdl, const char * scalar_ref, int scalar_ref_size) 
     512  { 
     513    std::string scalar_ref_str; 
     514    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return; 
     515    CTimer::get("XIOS").resume(); 
     516    field_hdl->scalar_ref.setValue(scalar_ref_str); 
     517    CTimer::get("XIOS").suspend(); 
     518  } 
     519 
     520  void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size) 
     521  { 
     522    CTimer::get("XIOS").resume(); 
     523    if (!string_copy(field_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size)) 
     524      ERROR("void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short"); 
     525    CTimer::get("XIOS").suspend(); 
     526  } 
     527 
     528  bool cxios_is_defined_field_scalar_ref(field_Ptr field_hdl) 
     529  { 
     530     CTimer::get("XIOS").resume(); 
     531     bool isDefined = field_hdl->scalar_ref.hasInheritedValue(); 
     532     CTimer::get("XIOS").suspend(); 
     533     return isDefined; 
     534  } 
     535 
     536 
    511537  void cxios_set_field_scale_factor(field_Ptr field_hdl, double scale_factor) 
    512538  { 
  • XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

    r790 r891  
    535535 
    536536 
     537  void cxios_set_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, const char * scalar_ref, int scalar_ref_size) 
     538  { 
     539    std::string scalar_ref_str; 
     540    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return; 
     541    CTimer::get("XIOS").resume(); 
     542    fieldgroup_hdl->scalar_ref.setValue(scalar_ref_str); 
     543    CTimer::get("XIOS").suspend(); 
     544  } 
     545 
     546  void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size) 
     547  { 
     548    CTimer::get("XIOS").resume(); 
     549    if (!string_copy(fieldgroup_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size)) 
     550      ERROR("void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short"); 
     551    CTimer::get("XIOS").suspend(); 
     552  } 
     553 
     554  bool cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl) 
     555  { 
     556     CTimer::get("XIOS").resume(); 
     557     bool isDefined = fieldgroup_hdl->scalar_ref.hasInheritedValue(); 
     558     CTimer::get("XIOS").suspend(); 
     559     return isDefined; 
     560  } 
     561 
     562 
    537563  void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor) 
    538564  { 
  • XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

    r802 r891  
    6464 
    6565 
     66  void cxios_set_file_cyclic(file_Ptr file_hdl, bool cyclic) 
     67  { 
     68    CTimer::get("XIOS").resume(); 
     69    file_hdl->cyclic.setValue(cyclic); 
     70    CTimer::get("XIOS").suspend(); 
     71  } 
     72 
     73  void cxios_get_file_cyclic(file_Ptr file_hdl, bool* cyclic) 
     74  { 
     75    CTimer::get("XIOS").resume(); 
     76    *cyclic = file_hdl->cyclic.getInheritedValue(); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  bool cxios_is_defined_file_cyclic(file_Ptr file_hdl) 
     81  { 
     82     CTimer::get("XIOS").resume(); 
     83     bool isDefined = file_hdl->cyclic.hasInheritedValue(); 
     84     CTimer::get("XIOS").suspend(); 
     85     return isDefined; 
     86  } 
     87 
     88 
    6689  void cxios_set_file_description(file_Ptr file_hdl, const char * description, int description_size) 
    6790  { 
  • XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp

    r802 r891  
    6464 
    6565 
     66  void cxios_set_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool cyclic) 
     67  { 
     68    CTimer::get("XIOS").resume(); 
     69    filegroup_hdl->cyclic.setValue(cyclic); 
     70    CTimer::get("XIOS").suspend(); 
     71  } 
     72 
     73  void cxios_get_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool* cyclic) 
     74  { 
     75    CTimer::get("XIOS").resume(); 
     76    *cyclic = filegroup_hdl->cyclic.getInheritedValue(); 
     77    CTimer::get("XIOS").suspend(); 
     78  } 
     79 
     80  bool cxios_is_defined_filegroup_cyclic(filegroup_Ptr filegroup_hdl) 
     81  { 
     82     CTimer::get("XIOS").resume(); 
     83     bool isDefined = filegroup_hdl->cyclic.hasInheritedValue(); 
     84     CTimer::get("XIOS").suspend(); 
     85     return isDefined; 
     86  } 
     87 
     88 
    6689  void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size) 
    6790  { 
  • XIOS/trunk/src/interface/c_attr/icinterpolate_axis_attr.cpp

    r786 r891  
    1717{ 
    1818  typedef xios::CInterpolateAxis* interpolate_axis_Ptr; 
     19 
     20  void cxios_set_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, const char * coordinate, int coordinate_size) 
     21  { 
     22    std::string coordinate_str; 
     23    if (!cstr2string(coordinate, coordinate_size, coordinate_str)) return; 
     24    CTimer::get("XIOS").resume(); 
     25    interpolate_axis_hdl->coordinate.setValue(coordinate_str); 
     26    CTimer::get("XIOS").suspend(); 
     27  } 
     28 
     29  void cxios_get_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, char * coordinate, int coordinate_size) 
     30  { 
     31    CTimer::get("XIOS").resume(); 
     32    if (!string_copy(interpolate_axis_hdl->coordinate.getInheritedValue(), coordinate, coordinate_size)) 
     33      ERROR("void cxios_get_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, char * coordinate, int coordinate_size)", << "Input string is too short"); 
     34    CTimer::get("XIOS").suspend(); 
     35  } 
     36 
     37  bool cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl) 
     38  { 
     39     CTimer::get("XIOS").resume(); 
     40     bool isDefined = interpolate_axis_hdl->coordinate.hasInheritedValue(); 
     41     CTimer::get("XIOS").suspend(); 
     42     return isDefined; 
     43  } 
     44 
    1945 
    2046  void cxios_set_interpolate_axis_order(interpolate_axis_Ptr interpolate_axis_hdl, int order) 
  • XIOS/trunk/src/interface/c_attr/icinterpolate_domain_attr.cpp

    r786 r891  
    6565     return isDefined; 
    6666  } 
     67 
     68 
     69  void cxios_set_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool renormalize) 
     70  { 
     71    CTimer::get("XIOS").resume(); 
     72    interpolate_domain_hdl->renormalize.setValue(renormalize); 
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
     76  void cxios_get_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool* renormalize) 
     77  { 
     78    CTimer::get("XIOS").resume(); 
     79    *renormalize = interpolate_domain_hdl->renormalize.getInheritedValue(); 
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = interpolate_domain_hdl->renormalize.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
    6790} 
  • XIOS/trunk/src/interface/fortran/ixios.F90

    r886 r891  
    6868USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr), xios(get_axisgroup_attr), xios(is_defined_axisgroup_attr) 
    6969 
     70USE iscalar, ONLY : txios(scalar), txios(scalargroup), xios(is_valid_scalar), xios(is_valid_scalargroup) 
     71 
     72USE iscalar_attr, ONLY : xios(set_scalar_attr), xios(get_scalar_attr), xios(is_defined_scalar_attr) 
     73 
     74USE iscalargroup_attr, ONLY : xios(set_scalargroup_attr), xios(get_scalargroup_attr), xios(is_defined_scalargroup_attr) 
     75 
    7076USE izoom_axis, ONLY : txios(zoom_axis), xios(is_valid_zoom_axis) 
    7177 
     
    95101                                              xios(get_generate_rectilinear_domain_attr), & 
    96102                                              xios(is_defined_generate_rectilinear_domain_attr) 
     103USE ireduce_axis_to_scalar, ONLY : txios(reduce_axis_to_scalar), xios(is_valid_reduce_axis_to_scalar) 
     104 
     105USE ireduce_axis_to_scalar_attr, ONLY : xios(set_reduce_axis_to_scalar_attr), xios(get_reduce_axis_to_scalar_attr), & 
     106                                        xios(is_defined_reduce_axis_to_scalar_attr) 
    97107 
    98108USE XIOS_INTERFACES, ONLY : xios(set_attr), xios(get_attr), xios(is_defined_attr), xios(get_handle), xios(add_child), & 
  • XIOS/trunk/src/interface/fortran/ixios_interfaces.F90

    r886 r891  
    5151USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr_hdl), xios(get_axisgroup_attr_hdl), xios(is_defined_axisgroup_attr_hdl) 
    5252 
     53USE iscalar, ONLY : xios(get_scalar_handle), xios(get_scalargroup_handle) 
     54 
     55USE iscalar_attr, ONLY : xios(set_scalar_attr_hdl), xios(get_scalar_attr_hdl), xios(is_defined_scalar_attr_hdl) 
     56 
     57USE iscalargroup_attr, ONLY : xios(set_scalargroup_attr_hdl), xios(get_scalargroup_attr_hdl), xios(is_defined_scalargroup_attr_hdl) 
     58 
    5359USE izoom_axis, ONLY : xios(get_zoom_axis_handle) 
    5460 
     
    7985                                              xios(is_defined_generate_rectilinear_domain_attr_hdl) 
    8086 
     87USE ireduce_axis_to_scalar, ONLY : xios(get_reduce_axis_to_scalar_handle) 
     88 
     89USE ireduce_axis_to_scalar_attr, ONLY : xios(set_reduce_axis_to_scalar_attr_hdl), xios(get_reduce_axis_to_scalar_attr_hdl), xios(is_defined_reduce_axis_to_scalar_attr_hdl) 
     90 
    8191USE ixml_tree, ONLY : xios(add_axis), xios(add_file), xios(add_grid), xios(add_field), xios(add_domain),   & 
    8292                      xios(add_fieldtofile), xios(add_variabletofile), xios(add_variabletofield),          & 
     
    8696                      xios(add_zoomdomaintodomain), xios(add_interpolatedomaintodomain),                   & 
    8797                      xios(add_generatedomaintodomain), xios(add_zoomaxistoaxis),                          & 
    88                       xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis) 
     98                      xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis), xios(add_scalar),      & 
     99                      xios(add_scalargroup), xios(add_scalartogrid), xios(add_reduceaxistoscalartoscalar) 
    89100 
    90101PRIVATE 
     
    98109                   xios(set_zoom_domain_attr_hdl), xios(set_interpolate_axis_attr_hdl),                      & 
    99110                   xios(set_interpolate_domain_attr_hdl), xios(set_inverse_axis_attr_hdl),                   & 
    100                    xios(set_generate_rectilinear_domain_attr_hdl) 
     111                   xios(set_generate_rectilinear_domain_attr_hdl), xios(set_scalar_attr_hdl),                & 
     112                   xios(set_scalargroup_attr_hdl), xios(set_reduce_axis_to_scalar_attr_hdl) 
    101113END INTERFACE xios(set_attr) 
    102114 
     
    109121                   xios(get_zoom_domain_attr_hdl), xios(get_interpolate_axis_attr_hdl),                      & 
    110122                   xios(get_interpolate_domain_attr_hdl), xios(get_inverse_axis_attr_hdl),                   & 
    111                    xios(get_generate_rectilinear_domain_attr_hdl) 
     123                   xios(get_generate_rectilinear_domain_attr_hdl), xios(get_scalar_attr_hdl),                & 
     124                   xios(get_scalargroup_attr_hdl), xios(get_reduce_axis_to_scalar_attr_hdl) 
    112125END INTERFACE xios(get_attr) 
    113126 
     
    120133                   xios(is_defined_zoom_axis_attr_hdl), xios(is_defined_zoom_domain_attr_hdl),                                    & 
    121134                   xios(is_defined_interpolate_axis_attr_hdl), xios(is_defined_interpolate_domain_attr_hdl),                      & 
    122                    xios(is_defined_inverse_axis_attr_hdl), xios(is_defined_generate_rectilinear_domain_attr_hdl) 
     135                   xios(is_defined_inverse_axis_attr_hdl), xios(is_defined_generate_rectilinear_domain_attr_hdl),                 & 
     136                   xios(is_defined_scalar_attr_hdl), xios(is_defined_scalargroup_attr_hdl),                                       & 
     137                   xios(is_defined_reduce_axis_to_scalar_attr_hdl) 
    123138END INTERFACE xios(is_defined_attr) 
    124139 
     
    131146                   xios(get_zoom_domain_handle), xios(get_interpolate_axis_handle),                 & 
    132147                   xios(get_interpolate_domain_handle), xios(get_inverse_axis_handle),              & 
    133                    xios(get_generate_rectilinear_domain_handle) 
     148                   xios(get_generate_rectilinear_domain_handle), xios(get_scalar_handle),           & 
     149                   xios(get_scalargroup_handle), xios(get_reduce_axis_to_scalar_handle) 
    134150END INTERFACE xios(get_handle) 
    135151 
     
    141157                   xios(add_axistogrid), xios(add_domaintogrid), xios(add_zoomdomaintodomain),                       & 
    142158                   xios(add_interpolatedomaintodomain), xios(add_generatedomaintodomain),                            & 
    143                    xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis) 
     159                   xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis),           & 
     160                   xios(add_scalar), xios(add_scalartogrid), xios(add_reduceaxistoscalartoscalar) 
    144161END INTERFACE xios(add_child) 
    145162 
  • XIOS/trunk/src/interface/fortran/ixml_tree.F90

    r840 r891  
    33MODULE IXML_TREE 
    44   USE, INTRINSIC :: ISO_C_BINDING 
     5   USE ISCALAR 
    56   USE IAXIS 
    67   USE IFILE 
     
    1516   USE IINTERPOLATE_AXIS 
    1617   USE IINVERSE_AXIS 
     18   USE IREDUCE_AXIS_TO_SCALAR 
    1719 
    1820   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
     
    4244      END SUBROUTINE cxios_xml_tree_add_file 
    4345 
     46      SUBROUTINE cxios_xml_tree_add_scalar(parent_, child_, child_id, child_id_size) BIND(C) 
     47         USE ISO_C_BINDING 
     48         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     49         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     50         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     51         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     52      END SUBROUTINE cxios_xml_tree_add_scalar 
     53 
    4454      SUBROUTINE cxios_xml_tree_add_axis(parent_, child_, child_id, child_id_size) BIND(C) 
    4555         USE ISO_C_BINDING 
     
    108118      END SUBROUTINE cxios_xml_tree_add_filegroup 
    109119 
     120      SUBROUTINE cxios_xml_tree_add_scalargroup(parent_, child_, child_id, child_id_size) BIND(C) 
     121         USE ISO_C_BINDING 
     122         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     123         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     124         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     125         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     126      END SUBROUTINE cxios_xml_tree_add_scalargroup 
     127 
    110128      SUBROUTINE cxios_xml_tree_add_axisgroup(parent_, child_, child_id, child_id_size) BIND(C) 
    111129         USE ISO_C_BINDING 
     
    148166      END SUBROUTINE cxios_xml_tree_add_variablegrouptofield 
    149167 
     168      SUBROUTINE cxios_xml_tree_add_scalartogrid(parent_, child_, child_id, child_id_size) BIND(C) 
     169         USE ISO_C_BINDING 
     170         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     171         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     172         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     173         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     174      END SUBROUTINE cxios_xml_tree_add_scalartogrid 
     175 
    150176      SUBROUTINE cxios_xml_tree_add_axistogrid(parent_, child_, child_id, child_id_size) BIND(C) 
    151177         USE ISO_C_BINDING 
     
    211237         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
    212238      END SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis 
     239 
     240      SUBROUTINE cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_, child_, child_id, child_id_size) BIND(C) 
     241         USE ISO_C_BINDING 
     242         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_ 
     243         INTEGER  (kind = C_INTPTR_T)               :: child_ 
     244         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id 
     245         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size 
     246      END SUBROUTINE cxios_xml_tree_add_reduceaxistoscalartoscalar 
    213247 
    214248      SUBROUTINE cxios_xml_tree_show(filename, filename_size) BIND(C) 
     
    235269   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    236270 
     271   SUBROUTINE xios(add_scalar)(parent_hdl, child_hdl, child_id) 
     272      TYPE(txios(scalargroup))     , INTENT(IN) :: parent_hdl 
     273      TYPE(txios(scalar))          , INTENT(OUT):: child_hdl 
     274      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: child_id 
     275 
     276      IF (PRESENT(child_id)) THEN 
     277         CALL cxios_xml_tree_add_scalar(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     278      ELSE 
     279         CALL cxios_xml_tree_add_scalar(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     280      END IF 
     281 
     282   END SUBROUTINE xios(add_scalar) 
    237283 
    238284   SUBROUTINE xios(add_axis)(parent_hdl, child_hdl, child_id) 
     
    341387   END SUBROUTINE xios(add_variabletofield) 
    342388 
     389   SUBROUTINE xios(add_scalargroup)(parent_hdl, child_hdl, child_id) 
     390      TYPE(txios(scalargroup))      , INTENT(IN) :: parent_hdl 
     391      TYPE(txios(scalargroup))      , INTENT(OUT):: child_hdl 
     392      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: child_id 
     393 
     394      IF (PRESENT(child_id)) THEN 
     395         CALL cxios_xml_tree_add_scalargroup(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     396      ELSE 
     397         CALL cxios_xml_tree_add_scalargroup(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     398      END IF 
     399 
     400   END SUBROUTINE xios(add_scalargroup) 
    343401 
    344402   SUBROUTINE xios(add_axisgroup)(parent_hdl, child_hdl, child_id) 
     
    446504   END SUBROUTINE xios(add_variablegrouptofield) 
    447505 
     506   SUBROUTINE xios(add_scalartogrid)(parent_hdl, child_hdl, child_id) 
     507      TYPE(txios(grid))             , INTENT(IN) :: parent_hdl 
     508      TYPE(txios(scalar))           , INTENT(OUT):: child_hdl 
     509      CHARACTER(len = *), OPTIONAL  , INTENT(IN) :: child_id 
     510 
     511      IF (PRESENT(child_id)) THEN 
     512         CALL cxios_xml_tree_add_scalartogrid(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     513      ELSE 
     514         CALL cxios_xml_tree_add_scalartogrid(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     515      END IF 
     516 
     517   END SUBROUTINE xios(add_scalartogrid) 
     518 
    448519   SUBROUTINE xios(add_axistogrid)(parent_hdl, child_hdl, child_id) 
    449520      TYPE(txios(grid))             , INTENT(IN) :: parent_hdl 
     
    549620 
    550621   END SUBROUTINE xios(add_inverseaxistoaxis) 
     622 
     623   SUBROUTINE xios(add_reduceaxistoscalartoscalar)(parent_hdl, child_hdl, child_id) 
     624      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl 
     625      TYPE(txios(inverse_axis))              , INTENT(OUT):: child_hdl 
     626      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id 
     627 
     628      IF (PRESENT(child_id)) THEN 
     629         CALL cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id)) 
     630      ELSE 
     631         CALL cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_hdl%daddr, child_hdl%daddr, "NONE", -1) 
     632      END IF 
     633 
     634   END SUBROUTINE xios(add_reduceaxistoscalartoscalar) 
    551635END MODULE IXML_TREE 
  • XIOS/trunk/src/interface/fortran_attr/field_interface_attr.F90

    r790 r891  
    391391 
    392392 
     393    SUBROUTINE cxios_set_field_scalar_ref(field_hdl, scalar_ref, scalar_ref_size) BIND(C) 
     394      USE ISO_C_BINDING 
     395      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     396      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref 
     397      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size 
     398    END SUBROUTINE cxios_set_field_scalar_ref 
     399 
     400    SUBROUTINE cxios_get_field_scalar_ref(field_hdl, scalar_ref, scalar_ref_size) BIND(C) 
     401      USE ISO_C_BINDING 
     402      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     403      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref 
     404      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size 
     405    END SUBROUTINE cxios_get_field_scalar_ref 
     406 
     407    FUNCTION cxios_is_defined_field_scalar_ref(field_hdl) BIND(C) 
     408      USE ISO_C_BINDING 
     409      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_scalar_ref 
     410      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl 
     411    END FUNCTION cxios_is_defined_field_scalar_ref 
     412 
     413 
    393414    SUBROUTINE cxios_set_field_scale_factor(field_hdl, scale_factor) BIND(C) 
    394415      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90

    r790 r891  
    412412 
    413413 
     414    SUBROUTINE cxios_set_fieldgroup_scalar_ref(fieldgroup_hdl, scalar_ref, scalar_ref_size) BIND(C) 
     415      USE ISO_C_BINDING 
     416      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     417      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref 
     418      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size 
     419    END SUBROUTINE cxios_set_fieldgroup_scalar_ref 
     420 
     421    SUBROUTINE cxios_get_fieldgroup_scalar_ref(fieldgroup_hdl, scalar_ref, scalar_ref_size) BIND(C) 
     422      USE ISO_C_BINDING 
     423      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     424      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref 
     425      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size 
     426    END SUBROUTINE cxios_get_fieldgroup_scalar_ref 
     427 
     428    FUNCTION cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_hdl) BIND(C) 
     429      USE ISO_C_BINDING 
     430      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_scalar_ref 
     431      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl 
     432    END FUNCTION cxios_is_defined_fieldgroup_scalar_ref 
     433 
     434 
    414435    SUBROUTINE cxios_set_fieldgroup_scale_factor(fieldgroup_hdl, scale_factor) BIND(C) 
    415436      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/file_interface_attr.F90

    r802 r891  
    4848 
    4949 
     50    SUBROUTINE cxios_set_file_cyclic(file_hdl, cyclic) BIND(C) 
     51      USE ISO_C_BINDING 
     52      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     53      LOGICAL (KIND=C_BOOL)      , VALUE :: cyclic 
     54    END SUBROUTINE cxios_set_file_cyclic 
     55 
     56    SUBROUTINE cxios_get_file_cyclic(file_hdl, cyclic) BIND(C) 
     57      USE ISO_C_BINDING 
     58      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     59      LOGICAL (KIND=C_BOOL)             :: cyclic 
     60    END SUBROUTINE cxios_get_file_cyclic 
     61 
     62    FUNCTION cxios_is_defined_file_cyclic(file_hdl) BIND(C) 
     63      USE ISO_C_BINDING 
     64      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_cyclic 
     65      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl 
     66    END FUNCTION cxios_is_defined_file_cyclic 
     67 
     68 
    5069    SUBROUTINE cxios_set_file_description(file_hdl, description, description_size) BIND(C) 
    5170      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90

    r802 r891  
    4848 
    4949 
     50    SUBROUTINE cxios_set_filegroup_cyclic(filegroup_hdl, cyclic) BIND(C) 
     51      USE ISO_C_BINDING 
     52      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     53      LOGICAL (KIND=C_BOOL)      , VALUE :: cyclic 
     54    END SUBROUTINE cxios_set_filegroup_cyclic 
     55 
     56    SUBROUTINE cxios_get_filegroup_cyclic(filegroup_hdl, cyclic) BIND(C) 
     57      USE ISO_C_BINDING 
     58      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     59      LOGICAL (KIND=C_BOOL)             :: cyclic 
     60    END SUBROUTINE cxios_get_filegroup_cyclic 
     61 
     62    FUNCTION cxios_is_defined_filegroup_cyclic(filegroup_hdl) BIND(C) 
     63      USE ISO_C_BINDING 
     64      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_cyclic 
     65      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl 
     66    END FUNCTION cxios_is_defined_filegroup_cyclic 
     67 
     68 
    5069    SUBROUTINE cxios_set_filegroup_description(filegroup_hdl, description, description_size) BIND(C) 
    5170      USE ISO_C_BINDING 
  • XIOS/trunk/src/interface/fortran_attr/ifield_attr.F90

    r790 r891  
    1414    ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    1515    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    16     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     16    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    1717    , unit, valid_max, valid_min ) 
    1818 
     
    4343      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access 
    4444      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     45      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref 
    4546      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor 
    4647      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
     
    5657      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    5758      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    58       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     59      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    5960      , unit, valid_max, valid_min ) 
    6061 
     
    6465    ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    6566    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    66     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     67    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    6768    , unit, valid_max, valid_min ) 
    6869 
     
    9293      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access 
    9394      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     95      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref 
    9496      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor 
    9597      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
     
    104106      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    105107      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    106       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     108      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    107109      , unit, valid_max, valid_min ) 
    108110 
     
    112114    ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    113115    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  & 
    114     , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  & 
     116    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  & 
    115117    , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    116118 
     
    140142      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access_ 
    141143      LOGICAL (KIND=C_BOOL) :: read_access__tmp 
     144      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_ 
    142145      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor_ 
    143146      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_ 
     
    229232      ENDIF 
    230233 
     234      IF (PRESENT(scalar_ref_)) THEN 
     235        CALL cxios_set_field_scalar_ref(field_hdl%daddr, scalar_ref_, len(scalar_ref_)) 
     236      ENDIF 
     237 
    231238      IF (PRESENT(scale_factor_)) THEN 
    232239        CALL cxios_set_field_scale_factor(field_hdl%daddr, scale_factor_) 
     
    263270    ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    264271    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    265     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     272    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    266273    , unit, valid_max, valid_min ) 
    267274 
     
    292299      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access 
    293300      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     301      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref 
    294302      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor 
    295303      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
     
    305313      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    306314      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    307       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     315      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    308316      , unit, valid_max, valid_min ) 
    309317 
     
    313321    ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    314322    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    315     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     323    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    316324    , unit, valid_max, valid_min ) 
    317325 
     
    341349      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access 
    342350      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     351      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref 
    343352      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor 
    344353      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
     
    353362      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    354363      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    355       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     364      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    356365      , unit, valid_max, valid_min ) 
    357366 
     
    361370    ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    362371    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  & 
    363     , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  & 
     372    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  & 
    364373    , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    365374 
     
    389398      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access_ 
    390399      LOGICAL (KIND=C_BOOL) :: read_access__tmp 
     400      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_ 
    391401      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor_ 
    392402      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_ 
     
    478488      ENDIF 
    479489 
     490      IF (PRESENT(scalar_ref_)) THEN 
     491        CALL cxios_get_field_scalar_ref(field_hdl%daddr, scalar_ref_, len(scalar_ref_)) 
     492      ENDIF 
     493 
    480494      IF (PRESENT(scale_factor_)) THEN 
    481495        CALL cxios_get_field_scale_factor(field_hdl%daddr, scale_factor_) 
     
    512526    ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    513527    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    514     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     528    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    515529    , unit, valid_max, valid_min ) 
    516530 
     
    556570      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access 
    557571      LOGICAL(KIND=C_BOOL) :: read_access_tmp 
     572      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref 
     573      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp 
    558574      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor 
    559575      LOGICAL(KIND=C_BOOL) :: scale_factor_tmp 
     
    575591      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    576592      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    577       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     593      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    578594      , unit, valid_max, valid_min ) 
    579595 
     
    583599    ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    584600    , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    585     , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     601    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    586602    , unit, valid_max, valid_min ) 
    587603 
     
    626642      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access 
    627643      LOGICAL(KIND=C_BOOL) :: read_access_tmp 
     644      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref 
     645      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp 
    628646      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor 
    629647      LOGICAL(KIND=C_BOOL) :: scale_factor_tmp 
     
    644662      ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  & 
    645663      , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  & 
    646       , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
     664      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  & 
    647665      , unit, valid_max, valid_min ) 
    648666 
     
    652670    ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    653671    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  & 
    654     , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  & 
     672    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  & 
    655673    , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    656674 
     
    695713      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access_ 
    696714      LOGICAL(KIND=C_BOOL) :: read_access__tmp 
     715      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_ 
     716      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp 
    697717      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor_ 
    698718      LOGICAL(KIND=C_BOOL) :: scale_factor__tmp 
     
    805825      ENDIF 
    806826 
     827      IF (PRESENT(scalar_ref_)) THEN 
     828        scalar_ref__tmp = cxios_is_defined_field_scalar_ref(field_hdl%daddr) 
     829        scalar_ref_ = scalar_ref__tmp 
     830      ENDIF 
     831 
    807832      IF (PRESENT(scale_factor_)) THEN 
    808833        scale_factor__tmp = cxios_is_defined_field_scale_factor(field_hdl%daddr) 
  • XIOS/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90

    r790 r891  
    1414    ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    1515    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    16     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    17     , ts_split_freq, unit, valid_max, valid_min ) 
     16    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     17    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    1818 
    1919    IMPLICIT NONE 
     
    4444      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access 
    4545      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     46      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref 
    4647      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor 
    4748      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
     
    5758      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    5859      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    59       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    60       , ts_split_freq, unit, valid_max, valid_min ) 
     60      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     61      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    6162 
    6263  END SUBROUTINE xios(set_fieldgroup_attr) 
     
    6566    ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    6667    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    67     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    68     , ts_split_freq, unit, valid_max, valid_min ) 
     68    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     69    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    6970 
    7071    IMPLICIT NONE 
     
    9495      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access 
    9596      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     97      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref 
    9698      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor 
    9799      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name 
     
    106108      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    107109      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    108       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    109       , ts_split_freq, unit, valid_max, valid_min ) 
     110      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     111      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    110112 
    111113  END SUBROUTINE xios(set_fieldgroup_attr_hdl) 
     
    114116    ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    115117    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  & 
    116     , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  & 
     118    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  & 
    117119    , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    118120 
     
    143145      LOGICAL  , OPTIONAL, INTENT(IN) :: read_access_ 
    144146      LOGICAL (KIND=C_BOOL) :: read_access__tmp 
     147      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_ 
    145148      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor_ 
    146149      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_ 
     
    236239      ENDIF 
    237240 
     241      IF (PRESENT(scalar_ref_)) THEN 
     242        CALL cxios_set_fieldgroup_scalar_ref(fieldgroup_hdl%daddr, scalar_ref_, len(scalar_ref_)) 
     243      ENDIF 
     244 
    238245      IF (PRESENT(scale_factor_)) THEN 
    239246        CALL cxios_set_fieldgroup_scale_factor(fieldgroup_hdl%daddr, scale_factor_) 
     
    270277    ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    271278    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    272     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    273     , ts_split_freq, unit, valid_max, valid_min ) 
     279    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     280    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    274281 
    275282    IMPLICIT NONE 
     
    300307      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access 
    301308      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     309      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref 
    302310      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor 
    303311      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
     
    313321      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    314322      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    315       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    316       , ts_split_freq, unit, valid_max, valid_min ) 
     323      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     324      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    317325 
    318326  END SUBROUTINE xios(get_fieldgroup_attr) 
     
    321329    ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    322330    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    323     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    324     , ts_split_freq, unit, valid_max, valid_min ) 
     331    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     332    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    325333 
    326334    IMPLICIT NONE 
     
    350358      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access 
    351359      LOGICAL (KIND=C_BOOL) :: read_access_tmp 
     360      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref 
    352361      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor 
    353362      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name 
     
    362371      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    363372      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    364       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    365       , ts_split_freq, unit, valid_max, valid_min ) 
     373      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     374      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    366375 
    367376  END SUBROUTINE xios(get_fieldgroup_attr_hdl) 
     
    370379    ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    371380    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  & 
    372     , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  & 
     381    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  & 
    373382    , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    374383 
     
    399408      LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access_ 
    400409      LOGICAL (KIND=C_BOOL) :: read_access__tmp 
     410      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_ 
    401411      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor_ 
    402412      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_ 
     
    492502      ENDIF 
    493503 
     504      IF (PRESENT(scalar_ref_)) THEN 
     505        CALL cxios_get_fieldgroup_scalar_ref(fieldgroup_hdl%daddr, scalar_ref_, len(scalar_ref_)) 
     506      ENDIF 
     507 
    494508      IF (PRESENT(scale_factor_)) THEN 
    495509        CALL cxios_get_fieldgroup_scale_factor(fieldgroup_hdl%daddr, scale_factor_) 
     
    526540    ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    527541    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    528     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    529     , ts_split_freq, unit, valid_max, valid_min ) 
     542    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     543    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    530544 
    531545    IMPLICIT NONE 
     
    572586      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access 
    573587      LOGICAL(KIND=C_BOOL) :: read_access_tmp 
     588      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref 
     589      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp 
    574590      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor 
    575591      LOGICAL(KIND=C_BOOL) :: scale_factor_tmp 
     
    591607      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    592608      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    593       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    594       , ts_split_freq, unit, valid_max, valid_min ) 
     609      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     610      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    595611 
    596612  END SUBROUTINE xios(is_defined_fieldgroup_attr) 
     
    599615    ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    600616    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    601     , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    602     , ts_split_freq, unit, valid_max, valid_min ) 
     617    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     618    , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    603619 
    604620    IMPLICIT NONE 
     
    644660      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access 
    645661      LOGICAL(KIND=C_BOOL) :: read_access_tmp 
     662      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref 
     663      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp 
    646664      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor 
    647665      LOGICAL(KIND=C_BOOL) :: scale_factor_tmp 
     
    662680      ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  & 
    663681      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  & 
    664       , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  & 
    665       , ts_split_freq, unit, valid_max, valid_min ) 
     682      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  & 
     683      , ts_enabled, ts_split_freq, unit, valid_max, valid_min ) 
    666684 
    667685  END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl) 
     
    670688    ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  & 
    671689    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  & 
    672     , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  & 
     690    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  & 
    673691    , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ ) 
    674692 
     
    715733      LOGICAL, OPTIONAL, INTENT(OUT) :: read_access_ 
    716734      LOGICAL(KIND=C_BOOL) :: read_access__tmp 
     735      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_ 
     736      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp 
    717737      LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor_ 
    718738      LOGICAL(KIND=C_BOOL) :: scale_factor__tmp 
     
    830850      ENDIF 
    831851 
     852      IF (PRESENT(scalar_ref_)) THEN 
     853        scalar_ref__tmp = cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_hdl%daddr) 
     854        scalar_ref_ = scalar_ref__tmp 
     855      ENDIF 
     856 
    832857      IF (PRESENT(scale_factor_)) THEN 
    833858        scale_factor__tmp = cxios_is_defined_fieldgroup_scale_factor(fieldgroup_hdl%daddr) 
  • XIOS/trunk/src/interface/fortran_attr/ifile_attr.F90

    r802 r891  
    1212 
    1313  SUBROUTINE xios(set_file_attr)  & 
    14     ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  & 
    15     , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  & 
    16     , time_counter, time_counter_name, timeseries, ts_prefix, type ) 
     14    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     15    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     16    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    1717 
    1818    IMPLICIT NONE 
     
    2222      LOGICAL (KIND=C_BOOL) :: append_tmp 
    2323      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
     24      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
     25      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    2426      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description 
    2527      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled 
     
    4547      CALL xios(get_file_handle)(file_id,file_hdl) 
    4648      CALL xios(set_file_attr_hdl_)   & 
    47       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    48       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     49      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     50      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    4951      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    5052 
     
    5254 
    5355  SUBROUTINE xios(set_file_attr_hdl)  & 
    54     ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    55     , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     56    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     57    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    5658    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    5759 
     
    6163      LOGICAL (KIND=C_BOOL) :: append_tmp 
    6264      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
     65      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
     66      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    6367      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description 
    6468      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled 
     
    8387 
    8488      CALL xios(set_file_attr_hdl_)  & 
    85       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    86       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     89      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     90      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    8791      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    8892 
     
    9094 
    9195  SUBROUTINE xios(set_file_attr_hdl_)   & 
    92     ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  & 
    93     , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
     96    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  & 
     97    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    9498    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    9599    , type_ ) 
     
    100104      LOGICAL (KIND=C_BOOL) :: append__tmp 
    101105      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
     106      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_ 
     107      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
    102108      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_ 
    103109      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled_ 
     
    130136      ENDIF 
    131137 
     138      IF (PRESENT(cyclic_)) THEN 
     139        cyclic__tmp = cyclic_ 
     140        CALL cxios_set_file_cyclic(file_hdl%daddr, cyclic__tmp) 
     141      ENDIF 
     142 
    132143      IF (PRESENT(description_)) THEN 
    133144        CALL cxios_set_file_description(file_hdl%daddr, description_, len(description_)) 
     
    210221 
    211222  SUBROUTINE xios(get_file_attr)  & 
    212     ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  & 
    213     , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  & 
    214     , time_counter, time_counter_name, timeseries, ts_prefix, type ) 
     223    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     224    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     225    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    215226 
    216227    IMPLICIT NONE 
     
    220231      LOGICAL (KIND=C_BOOL) :: append_tmp 
    221232      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
     233      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
     234      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    222235      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description 
    223236      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled 
     
    243256      CALL xios(get_file_handle)(file_id,file_hdl) 
    244257      CALL xios(get_file_attr_hdl_)   & 
    245       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    246       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     258      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     259      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    247260      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    248261 
     
    250263 
    251264  SUBROUTINE xios(get_file_attr_hdl)  & 
    252     ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    253     , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     265    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     266    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    254267    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    255268 
     
    259272      LOGICAL (KIND=C_BOOL) :: append_tmp 
    260273      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
     274      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
     275      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    261276      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description 
    262277      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled 
     
    281296 
    282297      CALL xios(get_file_attr_hdl_)  & 
    283       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    284       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     298      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     299      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    285300      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    286301 
     
    288303 
    289304  SUBROUTINE xios(get_file_attr_hdl_)   & 
    290     ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  & 
    291     , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
     305    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  & 
     306    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    292307    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    293308    , type_ ) 
     
    298313      LOGICAL (KIND=C_BOOL) :: append__tmp 
    299314      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
     315      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_ 
     316      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
    300317      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_ 
    301318      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled_ 
     
    328345      ENDIF 
    329346 
     347      IF (PRESENT(cyclic_)) THEN 
     348        CALL cxios_get_file_cyclic(file_hdl%daddr, cyclic__tmp) 
     349        cyclic_ = cyclic__tmp 
     350      ENDIF 
     351 
    330352      IF (PRESENT(description_)) THEN 
    331353        CALL cxios_get_file_description(file_hdl%daddr, description_, len(description_)) 
     
    408430 
    409431  SUBROUTINE xios(is_defined_file_attr)  & 
    410     ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  & 
    411     , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  & 
    412     , time_counter, time_counter_name, timeseries, ts_prefix, type ) 
     432    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     433    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     434    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    413435 
    414436    IMPLICIT NONE 
     
    419441      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    420442      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     443      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
     444      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
    421445      LOGICAL, OPTIONAL, INTENT(OUT) :: description 
    422446      LOGICAL(KIND=C_BOOL) :: description_tmp 
     
    460484      CALL xios(get_file_handle)(file_id,file_hdl) 
    461485      CALL xios(is_defined_file_attr_hdl_)   & 
    462       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    463       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     486      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     487      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    464488      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    465489 
     
    467491 
    468492  SUBROUTINE xios(is_defined_file_attr_hdl)  & 
    469     ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    470     , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     493    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     494    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    471495    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    472496 
     
    477501      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    478502      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     503      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
     504      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
    479505      LOGICAL, OPTIONAL, INTENT(OUT) :: description 
    480506      LOGICAL(KIND=C_BOOL) :: description_tmp 
     
    517543 
    518544      CALL xios(is_defined_file_attr_hdl_)  & 
    519       ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  & 
    520       , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
     545      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  & 
     546      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  & 
    521547      , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type ) 
    522548 
     
    524550 
    525551  SUBROUTINE xios(is_defined_file_attr_hdl_)   & 
    526     ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  & 
    527     , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
     552    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  & 
     553    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    528554    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    529555    , type_ ) 
     
    535561      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_ 
    536562      LOGICAL(KIND=C_BOOL) :: compression_level__tmp 
     563      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_ 
     564      LOGICAL(KIND=C_BOOL) :: cyclic__tmp 
    537565      LOGICAL, OPTIONAL, INTENT(OUT) :: description_ 
    538566      LOGICAL(KIND=C_BOOL) :: description__tmp 
     
    584612      ENDIF 
    585613 
     614      IF (PRESENT(cyclic_)) THEN 
     615        cyclic__tmp = cxios_is_defined_file_cyclic(file_hdl%daddr) 
     616        cyclic_ = cyclic__tmp 
     617      ENDIF 
     618 
    586619      IF (PRESENT(description_)) THEN 
    587620        description__tmp = cxios_is_defined_file_description(file_hdl%daddr) 
  • XIOS/trunk/src/interface/fortran_attr/ifilegroup_attr.F90

    r802 r891  
    1212 
    1313  SUBROUTINE xios(set_filegroup_attr)  & 
    14     ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  & 
     14    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  & 
    1515    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    1616    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
     
    2323      LOGICAL (KIND=C_BOOL) :: append_tmp 
    2424      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
     25      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
     26      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    2527      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description 
    2628      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled 
     
    4749      CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl) 
    4850      CALL xios(set_filegroup_attr_hdl_)   & 
    49       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    50       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    51       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    52       ) 
     51      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     52      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     53      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     54      , type ) 
    5355 
    5456  END SUBROUTINE xios(set_filegroup_attr) 
    5557 
    5658  SUBROUTINE xios(set_filegroup_attr_hdl)  & 
    57     ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    58     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    59     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    60     ) 
     59    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     60    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     61    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     62    , type ) 
    6163 
    6264    IMPLICIT NONE 
     
    6567      LOGICAL (KIND=C_BOOL) :: append_tmp 
    6668      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level 
     69      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic 
     70      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    6771      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description 
    6872      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled 
     
    8892 
    8993      CALL xios(set_filegroup_attr_hdl_)  & 
    90       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    91       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    92       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    93       ) 
     94      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     95      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     96      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     97      , type ) 
    9498 
    9599  END SUBROUTINE xios(set_filegroup_attr_hdl) 
    96100 
    97101  SUBROUTINE xios(set_filegroup_attr_hdl_)   & 
    98     ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  & 
    99     , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    100     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    101     , type_ ) 
     102    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  & 
     103    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
     104    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  & 
     105    , ts_prefix_, type_ ) 
    102106 
    103107    IMPLICIT NONE 
     
    106110      LOGICAL (KIND=C_BOOL) :: append__tmp 
    107111      INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_ 
     112      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_ 
     113      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
    108114      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_ 
    109115      LOGICAL  , OPTIONAL, INTENT(IN) :: enabled_ 
     
    137143      ENDIF 
    138144 
     145      IF (PRESENT(cyclic_)) THEN 
     146        cyclic__tmp = cyclic_ 
     147        CALL cxios_set_filegroup_cyclic(filegroup_hdl%daddr, cyclic__tmp) 
     148      ENDIF 
     149 
    139150      IF (PRESENT(description_)) THEN 
    140151        CALL cxios_set_filegroup_description(filegroup_hdl%daddr, description_, len(description_)) 
     
    221232 
    222233  SUBROUTINE xios(get_filegroup_attr)  & 
    223     ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  & 
     234    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  & 
    224235    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    225236    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
     
    232243      LOGICAL (KIND=C_BOOL) :: append_tmp 
    233244      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
     245      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
     246      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    234247      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description 
    235248      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled 
     
    256269      CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl) 
    257270      CALL xios(get_filegroup_attr_hdl_)   & 
    258       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    259       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    260       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    261       ) 
     271      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     272      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     273      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     274      , type ) 
    262275 
    263276  END SUBROUTINE xios(get_filegroup_attr) 
    264277 
    265278  SUBROUTINE xios(get_filegroup_attr_hdl)  & 
    266     ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    267     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    268     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    269     ) 
     279    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     280    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     281    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     282    , type ) 
    270283 
    271284    IMPLICIT NONE 
     
    274287      LOGICAL (KIND=C_BOOL) :: append_tmp 
    275288      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level 
     289      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic 
     290      LOGICAL (KIND=C_BOOL) :: cyclic_tmp 
    276291      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description 
    277292      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled 
     
    297312 
    298313      CALL xios(get_filegroup_attr_hdl_)  & 
    299       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    300       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    301       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    302       ) 
     314      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     315      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     316      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     317      , type ) 
    303318 
    304319  END SUBROUTINE xios(get_filegroup_attr_hdl) 
    305320 
    306321  SUBROUTINE xios(get_filegroup_attr_hdl_)   & 
    307     ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  & 
    308     , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    309     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    310     , type_ ) 
     322    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  & 
     323    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
     324    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  & 
     325    , ts_prefix_, type_ ) 
    311326 
    312327    IMPLICIT NONE 
     
    315330      LOGICAL (KIND=C_BOOL) :: append__tmp 
    316331      INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_ 
     332      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_ 
     333      LOGICAL (KIND=C_BOOL) :: cyclic__tmp 
    317334      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_ 
    318335      LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled_ 
     
    346363      ENDIF 
    347364 
     365      IF (PRESENT(cyclic_)) THEN 
     366        CALL cxios_get_filegroup_cyclic(filegroup_hdl%daddr, cyclic__tmp) 
     367        cyclic_ = cyclic__tmp 
     368      ENDIF 
     369 
    348370      IF (PRESENT(description_)) THEN 
    349371        CALL cxios_get_filegroup_description(filegroup_hdl%daddr, description_, len(description_)) 
     
    430452 
    431453  SUBROUTINE xios(is_defined_filegroup_attr)  & 
    432     ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  & 
     454    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  & 
    433455    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    434456    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
     
    442464      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    443465      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     466      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
     467      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
    444468      LOGICAL, OPTIONAL, INTENT(OUT) :: description 
    445469      LOGICAL(KIND=C_BOOL) :: description_tmp 
     
    485509      CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl) 
    486510      CALL xios(is_defined_filegroup_attr_hdl_)   & 
    487       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    488       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    489       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    490       ) 
     511      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     512      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     513      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     514      , type ) 
    491515 
    492516  END SUBROUTINE xios(is_defined_filegroup_attr) 
    493517 
    494518  SUBROUTINE xios(is_defined_filegroup_attr_hdl)  & 
    495     ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    496     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    497     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    498     ) 
     519    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     520    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     521    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     522    , type ) 
    499523 
    500524    IMPLICIT NONE 
     
    504528      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level 
    505529      LOGICAL(KIND=C_BOOL) :: compression_level_tmp 
     530      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic 
     531      LOGICAL(KIND=C_BOOL) :: cyclic_tmp 
    506532      LOGICAL, OPTIONAL, INTENT(OUT) :: description 
    507533      LOGICAL(KIND=C_BOOL) :: description_tmp 
     
    546572 
    547573      CALL xios(is_defined_filegroup_attr_hdl_)  & 
    548       ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  & 
    549       , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  & 
    550       , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  & 
    551       ) 
     574      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  & 
     575      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  & 
     576      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  & 
     577      , type ) 
    552578 
    553579  END SUBROUTINE xios(is_defined_filegroup_attr_hdl) 
    554580 
    555581  SUBROUTINE xios(is_defined_filegroup_attr_hdl_)   & 
    556     ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  & 
    557     , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  & 
    558     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  & 
    559     , type_ ) 
     582    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  & 
     583    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  & 
     584    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  & 
     585    , ts_prefix_, type_ ) 
    560586 
    561587    IMPLICIT NONE 
     
    565591      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_ 
    566592      LOGICAL(KIND=C_BOOL) :: compression_level__tmp 
     593      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_ 
     594      LOGICAL(KIND=C_BOOL) :: cyclic__tmp 
    567595      LOGICAL, OPTIONAL, INTENT(OUT) :: description_ 
    568596      LOGICAL(KIND=C_BOOL) :: description__tmp 
     
    616644      ENDIF 
    617645 
     646      IF (PRESENT(cyclic_)) THEN 
     647        cyclic__tmp = cxios_is_defined_filegroup_cyclic(filegroup_hdl%daddr) 
     648        cyclic_ = cyclic__tmp 
     649      ENDIF 
     650 
    618651      IF (PRESENT(description_)) THEN 
    619652        description__tmp = cxios_is_defined_filegroup_description(filegroup_hdl%daddr) 
  • XIOS/trunk/src/interface/fortran_attr/iinterpolate_axis_attr.F90

    r786 r891  
    1212 
    1313  SUBROUTINE xios(set_interpolate_axis_attr)  & 
    14     ( interpolate_axis_id, order, type ) 
     14    ( interpolate_axis_id, coordinate, order, type ) 
    1515 
    1616    IMPLICIT NONE 
    1717      TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl 
    1818      CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id 
     19      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate 
    1920      INTEGER  , OPTIONAL, INTENT(IN) :: order 
    2021      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type 
     
    2223      CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl) 
    2324      CALL xios(set_interpolate_axis_attr_hdl_)   & 
    24       ( interpolate_axis_hdl, order, type ) 
     25      ( interpolate_axis_hdl, coordinate, order, type ) 
    2526 
    2627  END SUBROUTINE xios(set_interpolate_axis_attr) 
    2728 
    2829  SUBROUTINE xios(set_interpolate_axis_attr_hdl)  & 
    29     ( interpolate_axis_hdl, order, type ) 
     30    ( interpolate_axis_hdl, coordinate, order, type ) 
    3031 
    3132    IMPLICIT NONE 
    3233      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     34      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate 
    3335      INTEGER  , OPTIONAL, INTENT(IN) :: order 
    3436      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type 
    3537 
    3638      CALL xios(set_interpolate_axis_attr_hdl_)  & 
    37       ( interpolate_axis_hdl, order, type ) 
     39      ( interpolate_axis_hdl, coordinate, order, type ) 
    3840 
    3941  END SUBROUTINE xios(set_interpolate_axis_attr_hdl) 
    4042 
    4143  SUBROUTINE xios(set_interpolate_axis_attr_hdl_)   & 
    42     ( interpolate_axis_hdl, order_, type_ ) 
     44    ( interpolate_axis_hdl, coordinate_, order_, type_ ) 
    4345 
    4446    IMPLICIT NONE 
    4547      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     48      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate_ 
    4649      INTEGER  , OPTIONAL, INTENT(IN) :: order_ 
    4750      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_ 
     51 
     52      IF (PRESENT(coordinate_)) THEN 
     53        CALL cxios_set_interpolate_axis_coordinate(interpolate_axis_hdl%daddr, coordinate_, len(coordinate_)) 
     54      ENDIF 
    4855 
    4956      IF (PRESENT(order_)) THEN 
     
    5865 
    5966  SUBROUTINE xios(get_interpolate_axis_attr)  & 
    60     ( interpolate_axis_id, order, type ) 
     67    ( interpolate_axis_id, coordinate, order, type ) 
    6168 
    6269    IMPLICIT NONE 
    6370      TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl 
    6471      CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id 
     72      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate 
    6573      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
    6674      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type 
     
    6876      CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl) 
    6977      CALL xios(get_interpolate_axis_attr_hdl_)   & 
    70       ( interpolate_axis_hdl, order, type ) 
     78      ( interpolate_axis_hdl, coordinate, order, type ) 
    7179 
    7280  END SUBROUTINE xios(get_interpolate_axis_attr) 
    7381 
    7482  SUBROUTINE xios(get_interpolate_axis_attr_hdl)  & 
    75     ( interpolate_axis_hdl, order, type ) 
     83    ( interpolate_axis_hdl, coordinate, order, type ) 
    7684 
    7785    IMPLICIT NONE 
    7886      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     87      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate 
    7988      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
    8089      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type 
    8190 
    8291      CALL xios(get_interpolate_axis_attr_hdl_)  & 
    83       ( interpolate_axis_hdl, order, type ) 
     92      ( interpolate_axis_hdl, coordinate, order, type ) 
    8493 
    8594  END SUBROUTINE xios(get_interpolate_axis_attr_hdl) 
    8695 
    8796  SUBROUTINE xios(get_interpolate_axis_attr_hdl_)   & 
    88     ( interpolate_axis_hdl, order_, type_ ) 
     97    ( interpolate_axis_hdl, coordinate_, order_, type_ ) 
    8998 
    9099    IMPLICIT NONE 
    91100      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     101      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate_ 
    92102      INTEGER  , OPTIONAL, INTENT(OUT) :: order_ 
    93103      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_ 
     104 
     105      IF (PRESENT(coordinate_)) THEN 
     106        CALL cxios_get_interpolate_axis_coordinate(interpolate_axis_hdl%daddr, coordinate_, len(coordinate_)) 
     107      ENDIF 
    94108 
    95109      IF (PRESENT(order_)) THEN 
     
    104118 
    105119  SUBROUTINE xios(is_defined_interpolate_axis_attr)  & 
    106     ( interpolate_axis_id, order, type ) 
     120    ( interpolate_axis_id, coordinate, order, type ) 
    107121 
    108122    IMPLICIT NONE 
    109123      TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl 
    110124      CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id 
     125      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate 
     126      LOGICAL(KIND=C_BOOL) :: coordinate_tmp 
    111127      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    112128      LOGICAL(KIND=C_BOOL) :: order_tmp 
     
    116132      CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl) 
    117133      CALL xios(is_defined_interpolate_axis_attr_hdl_)   & 
    118       ( interpolate_axis_hdl, order, type ) 
     134      ( interpolate_axis_hdl, coordinate, order, type ) 
    119135 
    120136  END SUBROUTINE xios(is_defined_interpolate_axis_attr) 
    121137 
    122138  SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl)  & 
    123     ( interpolate_axis_hdl, order, type ) 
     139    ( interpolate_axis_hdl, coordinate, order, type ) 
    124140 
    125141    IMPLICIT NONE 
    126142      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     143      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate 
     144      LOGICAL(KIND=C_BOOL) :: coordinate_tmp 
    127145      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    128146      LOGICAL(KIND=C_BOOL) :: order_tmp 
     
    131149 
    132150      CALL xios(is_defined_interpolate_axis_attr_hdl_)  & 
    133       ( interpolate_axis_hdl, order, type ) 
     151      ( interpolate_axis_hdl, coordinate, order, type ) 
    134152 
    135153  END SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl) 
    136154 
    137155  SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl_)   & 
    138     ( interpolate_axis_hdl, order_, type_ ) 
     156    ( interpolate_axis_hdl, coordinate_, order_, type_ ) 
    139157 
    140158    IMPLICIT NONE 
    141159      TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl 
     160      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate_ 
     161      LOGICAL(KIND=C_BOOL) :: coordinate__tmp 
    142162      LOGICAL, OPTIONAL, INTENT(OUT) :: order_ 
    143163      LOGICAL(KIND=C_BOOL) :: order__tmp 
    144164      LOGICAL, OPTIONAL, INTENT(OUT) :: type_ 
    145165      LOGICAL(KIND=C_BOOL) :: type__tmp 
     166 
     167      IF (PRESENT(coordinate_)) THEN 
     168        coordinate__tmp = cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_hdl%daddr) 
     169        coordinate_ = coordinate__tmp 
     170      ENDIF 
    146171 
    147172      IF (PRESENT(order_)) THEN 
  • XIOS/trunk/src/interface/fortran_attr/iinterpolate_domain_attr.F90

    r786 r891  
    1212 
    1313  SUBROUTINE xios(set_interpolate_domain_attr)  & 
    14     ( interpolate_domain_id, file, order ) 
     14    ( interpolate_domain_id, file, order, renormalize ) 
    1515 
    1616    IMPLICIT NONE 
     
    1919      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file 
    2020      INTEGER  , OPTIONAL, INTENT(IN) :: order 
     21      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize 
     22      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
    2123 
    2224      CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl) 
    2325      CALL xios(set_interpolate_domain_attr_hdl_)   & 
    24       ( interpolate_domain_hdl, file, order ) 
     26      ( interpolate_domain_hdl, file, order, renormalize ) 
    2527 
    2628  END SUBROUTINE xios(set_interpolate_domain_attr) 
    2729 
    2830  SUBROUTINE xios(set_interpolate_domain_attr_hdl)  & 
    29     ( interpolate_domain_hdl, file, order ) 
     31    ( interpolate_domain_hdl, file, order, renormalize ) 
    3032 
    3133    IMPLICIT NONE 
     
    3335      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file 
    3436      INTEGER  , OPTIONAL, INTENT(IN) :: order 
     37      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize 
     38      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
    3539 
    3640      CALL xios(set_interpolate_domain_attr_hdl_)  & 
    37       ( interpolate_domain_hdl, file, order ) 
     41      ( interpolate_domain_hdl, file, order, renormalize ) 
    3842 
    3943  END SUBROUTINE xios(set_interpolate_domain_attr_hdl) 
    4044 
    4145  SUBROUTINE xios(set_interpolate_domain_attr_hdl_)   & 
    42     ( interpolate_domain_hdl, file_, order_ ) 
     46    ( interpolate_domain_hdl, file_, order_, renormalize_ ) 
    4347 
    4448    IMPLICIT NONE 
     
    4650      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file_ 
    4751      INTEGER  , OPTIONAL, INTENT(IN) :: order_ 
     52      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize_ 
     53      LOGICAL (KIND=C_BOOL) :: renormalize__tmp 
    4854 
    4955      IF (PRESENT(file_)) THEN 
     
    5561      ENDIF 
    5662 
     63      IF (PRESENT(renormalize_)) THEN 
     64        renormalize__tmp = renormalize_ 
     65        CALL cxios_set_interpolate_domain_renormalize(interpolate_domain_hdl%daddr, renormalize__tmp) 
     66      ENDIF 
     67 
    5768  END SUBROUTINE xios(set_interpolate_domain_attr_hdl_) 
    5869 
    5970  SUBROUTINE xios(get_interpolate_domain_attr)  & 
    60     ( interpolate_domain_id, file, order ) 
     71    ( interpolate_domain_id, file, order, renormalize ) 
    6172 
    6273    IMPLICIT NONE 
     
    6576      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file 
    6677      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
     78      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize 
     79      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
    6780 
    6881      CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl) 
    6982      CALL xios(get_interpolate_domain_attr_hdl_)   & 
    70       ( interpolate_domain_hdl, file, order ) 
     83      ( interpolate_domain_hdl, file, order, renormalize ) 
    7184 
    7285  END SUBROUTINE xios(get_interpolate_domain_attr) 
    7386 
    7487  SUBROUTINE xios(get_interpolate_domain_attr_hdl)  & 
    75     ( interpolate_domain_hdl, file, order ) 
     88    ( interpolate_domain_hdl, file, order, renormalize ) 
    7689 
    7790    IMPLICIT NONE 
     
    7992      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file 
    8093      INTEGER  , OPTIONAL, INTENT(OUT) :: order 
     94      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize 
     95      LOGICAL (KIND=C_BOOL) :: renormalize_tmp 
    8196 
    8297      CALL xios(get_interpolate_domain_attr_hdl_)  & 
    83       ( interpolate_domain_hdl, file, order ) 
     98      ( interpolate_domain_hdl, file, order, renormalize ) 
    8499 
    85100  END SUBROUTINE xios(get_interpolate_domain_attr_hdl) 
    86101 
    87102  SUBROUTINE xios(get_interpolate_domain_attr_hdl_)   & 
    88     ( interpolate_domain_hdl, file_, order_ ) 
     103    ( interpolate_domain_hdl, file_, order_, renormalize_ ) 
    89104 
    90105    IMPLICIT NONE 
     
    92107      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file_ 
    93108      INTEGER  , OPTIONAL, INTENT(OUT) :: order_ 
     109      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize_ 
     110      LOGICAL (KIND=C_BOOL) :: renormalize__tmp 
    94111 
    95112      IF (PRESENT(file_)) THEN 
     
    101118      ENDIF 
    102119 
     120      IF (PRESENT(renormalize_)) THEN 
     121        CALL cxios_get_interpolate_domain_renormalize(interpolate_domain_hdl%daddr, renormalize__tmp) 
     122        renormalize_ = renormalize__tmp 
     123      ENDIF 
     124 
    103125  END SUBROUTINE xios(get_interpolate_domain_attr_hdl_) 
    104126 
    105127  SUBROUTINE xios(is_defined_interpolate_domain_attr)  & 
    106     ( interpolate_domain_id, file, order ) 
     128    ( interpolate_domain_id, file, order, renormalize ) 
    107129 
    108130    IMPLICIT NONE 
     
    113135      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    114136      LOGICAL(KIND=C_BOOL) :: order_tmp 
     137      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize 
     138      LOGICAL(KIND=C_BOOL) :: renormalize_tmp 
    115139 
    116140      CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl) 
    117141      CALL xios(is_defined_interpolate_domain_attr_hdl_)   & 
    118       ( interpolate_domain_hdl, file, order ) 
     142      ( interpolate_domain_hdl, file, order, renormalize ) 
    119143 
    120144  END SUBROUTINE xios(is_defined_interpolate_domain_attr) 
    121145 
    122146  SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl)  & 
    123     ( interpolate_domain_hdl, file, order ) 
     147    ( interpolate_domain_hdl, file, order, renormalize ) 
    124148 
    125149    IMPLICIT NONE 
     
    129153      LOGICAL, OPTIONAL, INTENT(OUT) :: order 
    130154      LOGICAL(KIND=C_BOOL) :: order_tmp 
     155      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize 
     156      LOGICAL(KIND=C_BOOL) :: renormalize_tmp 
    131157 
    132158      CALL xios(is_defined_interpolate_domain_attr_hdl_)  & 
    133       ( interpolate_domain_hdl, file, order ) 
     159      ( interpolate_domain_hdl, file, order, renormalize ) 
    134160 
    135161  END SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl) 
    136162 
    137163  SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl_)   & 
    138     ( interpolate_domain_hdl, file_, order_ ) 
     164    ( interpolate_domain_hdl, file_, order_, renormalize_ ) 
    139165 
    140166    IMPLICIT NONE 
     
    144170      LOGICAL, OPTIONAL, INTENT(OUT) :: order_ 
    145171      LOGICAL(KIND=C_BOOL) :: order__tmp 
     172      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize_ 
     173      LOGICAL(KIND=C_BOOL) :: renormalize__tmp 
    146174 
    147175      IF (PRESENT(file_)) THEN 
     
    155183      ENDIF 
    156184 
     185      IF (PRESENT(renormalize_)) THEN 
     186        renormalize__tmp = cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_hdl%daddr) 
     187        renormalize_ = renormalize__tmp 
     188      ENDIF 
     189 
    157190  END SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl_) 
    158191 
  • XIOS/trunk/src/interface/fortran_attr/interpolate_axis_interface_attr.F90

    r786 r891  
    99  INTERFACE 
    1010    ! Do not call directly / interface FORTRAN 2003 <-> C99 
     11 
     12    SUBROUTINE cxios_set_interpolate_axis_coordinate(interpolate_axis_hdl, coordinate, coordinate_size) BIND(C) 
     13      USE ISO_C_BINDING 
     14      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl 
     15      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: coordinate 
     16      INTEGER  (kind = C_INT)     , VALUE        :: coordinate_size 
     17    END SUBROUTINE cxios_set_interpolate_axis_coordinate 
     18 
     19    SUBROUTINE cxios_get_interpolate_axis_coordinate(interpolate_axis_hdl, coordinate, coordinate_size) BIND(C) 
     20      USE ISO_C_BINDING 
     21      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl 
     22      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: coordinate 
     23      INTEGER  (kind = C_INT)     , VALUE        :: coordinate_size 
     24    END SUBROUTINE cxios_get_interpolate_axis_coordinate 
     25 
     26    FUNCTION cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_hdl) BIND(C) 
     27      USE ISO_C_BINDING 
     28      LOGICAL(kind=C_BOOL) :: cxios_is_defined_interpolate_axis_coordinate 
     29      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl 
     30    END FUNCTION cxios_is_defined_interpolate_axis_coordinate 
     31 
    1132 
    1233    SUBROUTINE cxios_set_interpolate_axis_order(interpolate_axis_hdl, order) BIND(C) 
  • XIOS/trunk/src/interface/fortran_attr/interpolate_domain_interface_attr.F90

    r786 r891  
    4949    END FUNCTION cxios_is_defined_interpolate_domain_order 
    5050 
     51 
     52    SUBROUTINE cxios_set_interpolate_domain_renormalize(interpolate_domain_hdl, renormalize) BIND(C) 
     53      USE ISO_C_BINDING 
     54      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     55      LOGICAL (KIND=C_BOOL)      , VALUE :: renormalize 
     56    END SUBROUTINE cxios_set_interpolate_domain_renormalize 
     57 
     58    SUBROUTINE cxios_get_interpolate_domain_renormalize(interpolate_domain_hdl, renormalize) BIND(C) 
     59      USE ISO_C_BINDING 
     60      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     61      LOGICAL (KIND=C_BOOL)             :: renormalize 
     62    END SUBROUTINE cxios_get_interpolate_domain_renormalize 
     63 
     64    FUNCTION cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_hdl) BIND(C) 
     65      USE ISO_C_BINDING 
     66      LOGICAL(kind=C_BOOL) :: cxios_is_defined_interpolate_domain_renormalize 
     67      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl 
     68    END FUNCTION cxios_is_defined_interpolate_domain_renormalize 
     69 
    5170  END INTERFACE 
    5271 
  • XIOS/trunk/src/node/reduce_axis_to_scalar.cpp

    r888 r891  
    1919  CTransformation<CScalar>* CReduceAxisToScalar::create(const StdString& id, xml::CXMLNode* node) 
    2020  { 
    21     CReduceAxisToScalar* reduceAxis = CReduceAxisToScalarGroup::get("reduce_axis_definition")->createChild(id); 
     21    CReduceAxisToScalar* reduceAxis = CReduceAxisToScalarGroup::get("reduce_axis_to_scalar_definition")->createChild(id); 
    2222    if (node) reduceAxis->parse(*node); 
    2323    return static_cast<CTransformation<CScalar>*>(reduceAxis); 
     
    3333  //---------------------------------------------------------------- 
    3434 
    35   StdString CReduceAxisToScalar::GetName(void)    { return StdString("reduce_axis"); } 
    36   StdString CReduceAxisToScalar::GetDefName(void) { return StdString("reduce_axis"); } 
     35  StdString CReduceAxisToScalar::GetName(void)    { return StdString("reduce_axis_to_scalar"); } 
     36  StdString CReduceAxisToScalar::GetDefName(void) { return StdString("reduce_axis_to_scalar"); } 
    3737  ENodeType CReduceAxisToScalar::GetType(void)    { return eReduceAxisToScalar; } 
    3838 
Note: See TracChangeset for help on using the changeset viewer.