Index: XIOS/trunk/src/interface/c/icreduce_axis_to_scalar.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icreduce_axis_to_scalar.cpp	(revision 891)
+++ XIOS/trunk/src/interface/c/icreduce_axis_to_scalar.cpp	(revision 891)
@@ -0,0 +1,46 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include "xios.hpp"
+
+#include "object_template.hpp"
+#include "group_template.hpp"
+#include "attribute_template.hpp"
+
+#include "icutil.hpp"
+#include "timer.hpp"
+#include "reduce_axis_to_scalar.hpp"
+
+extern "C"
+{
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+   // ----------------------- RedÃ©finition de types ----------------------------
+
+   typedef xios::CReduceAxisToScalar      * XReduceAxisToScalarPtr;
+
+   // ------------------------ CrÃ©ation des handle -----------------------------
+   void cxios_reduce_axis_to_scalar_handle_create(XReduceAxisToScalarPtr * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CReduceAxisToScalar::get(id);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   // -------------------- VÃ©rification des identifiants -----------------------
+   void cxios_reduce_axis_to_scalar_valid_id(bool * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CReduceAxisToScalar::has(id);
+      CTimer::get("XIOS").suspend() ;
+   }
+} // extern "C"
Index: XIOS/trunk/src/interface/c/icscalar.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icscalar.cpp	(revision 891)
+++ XIOS/trunk/src/interface/c/icscalar.cpp	(revision 891)
@@ -0,0 +1,70 @@
+/* ************************************************************************** *
+ *      Copyright Â© IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
+ * ************************************************************************** */
+
+#include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include "xios.hpp"
+
+#include "object_template.hpp"
+#include "group_template.hpp"
+#include "attribute_template.hpp"
+
+#include "icutil.hpp"
+#include "timer.hpp"
+#include "scalar.hpp"
+
+extern "C"
+{
+// /////////////////////////////// DÃ©finitions ////////////////////////////// //
+
+   // ----------------------- RedÃ©finition de types ----------------------------
+
+   typedef xios::CScalar      * XScalarPtr;
+   typedef xios::CScalarGroup * XScalarGroupPtr;
+
+   // ------------------------ CrÃ©ation des handle -----------------------------
+
+   void cxios_scalar_handle_create (XScalarPtr * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CScalar::get(id);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_scalargroup_handle_create (XScalarGroupPtr * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CScalarGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
+    }
+
+   // -------------------- VÃ©rification des identifiants -----------------------
+
+   void cxios_scalar_valid_id (bool * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CScalar::has(id);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_scalargroup_valid_id (bool * _ret, const char * _id, int _id_len)
+   {
+      std::string id;
+      if (!cstr2string(_id, _id_len, id)) return;
+
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CScalarGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
+
+   }
+
+} // extern "C"
Index: XIOS/trunk/src/interface/c/icxml_tree.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 891)
@@ -15,16 +15,5 @@
 #include "timer.hpp"
 #include "context.hpp"
-#include "grid.hpp"
-#include "file.hpp"
-#include "field.hpp"
-#include "axis.hpp"
-#include "domain.hpp"
-#include "variable.hpp"
-#include "zoom_domain.hpp"
-#include "interpolate_domain.hpp"
-#include "generate_rectilinear_domain.hpp"
-#include "zoom_axis.hpp"
-#include "interpolate_axis.hpp"
-#include "inverse_axis.hpp"
+#include "node_type.hpp"
 
 extern "C"
@@ -47,4 +36,7 @@
    typedef xios::CDomain      * XDomainPtr;
    typedef xios::CDomainGroup * XDomainGroupPtr;
+
+   typedef xios::CScalar      * XScalarPtr;
+   typedef xios::CScalarGroup * XScalarGroupPtr;
 
    typedef xios::CAxis      * XAxisPtr;
@@ -64,4 +56,7 @@
    typedef xios::CInverseAxis             *  XInverseAxisPtr;
 
+   typedef xios::CTransformation<CScalar>   *  XTransformationScalarPtr;
+   typedef xios::CReduceAxisToScalar        *  XReduceAxisToScalarPtr;
+
    // ----------------------- Ajout d'enfant Ã  un parent -----------------------
 
@@ -130,4 +125,20 @@
    }
 
+   void cxios_xml_tree_add_scalar
+      (XScalarGroupPtr parent_, XScalarPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
+   }
+
    void cxios_xml_tree_add_domain
       (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size)
@@ -246,4 +257,20 @@
    }
 
+   void cxios_xml_tree_add_scalargroup
+      (XScalarGroupPtr parent_, XScalarGroupPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+      }
+      CTimer::get("XIOS").suspend() ;
+   }
+
    void cxios_xml_tree_add_axisgroup
       (XAxisGroupPtr parent_, XAxisGroupPtr * child_, const char * child_id, int child_id_size)
@@ -326,4 +353,20 @@
    }
 
+   void cxios_xml_tree_add_scalartogrid
+      (XGridPtr parent_, XScalarPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->addScalar(child_id_str);
+      }
+      else
+      {
+         *child_ = parent_->addScalar();
+      }
+      CTimer::get("XIOS").suspend() ;
+   }
+
    void cxios_xml_tree_add_axistogrid
       (XGridPtr parent_, XAxisPtr * child_, const char * child_id, int child_id_size)
@@ -463,4 +506,22 @@
       }
       *child_ = static_cast<XInverseAxisPtr>(tmpChild_);
+      CTimer::get("XIOS").suspend() ;
+   }
+
+   void cxios_xml_tree_add_reduceaxistoscalartoscalar
+      (XScalarPtr parent_, XReduceAxisToScalarPtr * child_, const char * child_id, int child_id_size)
+   {
+      std::string child_id_str;
+      XTransformationScalarPtr tmpChild_;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_REDUCE_AXIS_TO_SCALAR, child_id_str);
+      }
+      else
+      {
+         tmpChild_ = parent_->addTransformation(TRANS_REDUCE_AXIS_TO_SCALAR);
+      }
+      *child_ = static_cast<XReduceAxisToScalarPtr>(tmpChild_);
       CTimer::get("XIOS").suspend() ;
    }
Index: XIOS/trunk/src/interface/c_attr/icfield_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 891)
@@ -509,4 +509,30 @@
 
 
+  void cxios_set_field_scalar_ref(field_Ptr field_hdl, const char * scalar_ref, int scalar_ref_size)
+  {
+    std::string scalar_ref_str;
+    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
+    CTimer::get("XIOS").resume();
+    field_hdl->scalar_ref.setValue(scalar_ref_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(field_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
+      ERROR("void cxios_get_field_scalar_ref(field_Ptr field_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_scalar_ref(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->scalar_ref.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_field_scale_factor(field_Ptr field_hdl, double scale_factor)
   {
Index: XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 891)
@@ -535,4 +535,30 @@
 
 
+  void cxios_set_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, const char * scalar_ref, int scalar_ref_size)
+  {
+    std::string scalar_ref_str;
+    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->scalar_ref.setValue(scalar_ref_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(fieldgroup_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
+      ERROR("void cxios_get_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->scalar_ref.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_fieldgroup_scale_factor(fieldgroup_Ptr fieldgroup_hdl, double scale_factor)
   {
Index: XIOS/trunk/src/interface/c_attr/icfile_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 891)
@@ -64,4 +64,27 @@
 
 
+  void cxios_set_file_cyclic(file_Ptr file_hdl, bool cyclic)
+  {
+    CTimer::get("XIOS").resume();
+    file_hdl->cyclic.setValue(cyclic);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_cyclic(file_Ptr file_hdl, bool* cyclic)
+  {
+    CTimer::get("XIOS").resume();
+    *cyclic = file_hdl->cyclic.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_cyclic(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->cyclic.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_description(file_Ptr file_hdl, const char * description, int description_size)
   {
Index: XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 891)
@@ -64,4 +64,27 @@
 
 
+  void cxios_set_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool cyclic)
+  {
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->cyclic.setValue(cyclic);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_cyclic(filegroup_Ptr filegroup_hdl, bool* cyclic)
+  {
+    CTimer::get("XIOS").resume();
+    *cyclic = filegroup_hdl->cyclic.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_cyclic(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->cyclic.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_description(filegroup_Ptr filegroup_hdl, const char * description, int description_size)
   {
Index: XIOS/trunk/src/interface/c_attr/icinterpolate_axis_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icinterpolate_axis_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icinterpolate_axis_attr.cpp	(revision 891)
@@ -17,4 +17,30 @@
 {
   typedef xios::CInterpolateAxis* interpolate_axis_Ptr;
+
+  void cxios_set_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, const char * coordinate, int coordinate_size)
+  {
+    std::string coordinate_str;
+    if (!cstr2string(coordinate, coordinate_size, coordinate_str)) return;
+    CTimer::get("XIOS").resume();
+    interpolate_axis_hdl->coordinate.setValue(coordinate_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, char * coordinate, int coordinate_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(interpolate_axis_hdl->coordinate.getInheritedValue(), coordinate, coordinate_size))
+      ERROR("void cxios_get_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl, char * coordinate, int coordinate_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_Ptr interpolate_axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = interpolate_axis_hdl->coordinate.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
 
   void cxios_set_interpolate_axis_order(interpolate_axis_Ptr interpolate_axis_hdl, int order)
Index: XIOS/trunk/src/interface/c_attr/icinterpolate_domain_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icinterpolate_domain_attr.cpp	(revision 886)
+++ XIOS/trunk/src/interface/c_attr/icinterpolate_domain_attr.cpp	(revision 891)
@@ -65,3 +65,26 @@
      return isDefined;
   }
+
+
+  void cxios_set_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool renormalize)
+  {
+    CTimer::get("XIOS").resume();
+    interpolate_domain_hdl->renormalize.setValue(renormalize);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl, bool* renormalize)
+  {
+    CTimer::get("XIOS").resume();
+    *renormalize = interpolate_domain_hdl->renormalize.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_Ptr interpolate_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = interpolate_domain_hdl->renormalize.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
 }
Index: XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp	(revision 891)
+++ XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp	(revision 891)
@@ -0,0 +1,44 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include "xios.hpp"
+#include "attribute_template.hpp"
+#include "object_template.hpp"
+#include "group_template.hpp"
+#include "icutil.hpp"
+#include "icdate.hpp"
+#include "timer.hpp"
+#include "node_type.hpp"
+
+extern "C"
+{
+  typedef xios::CReduceAxisToScalar* reduce_axis_to_scalar_Ptr;
+
+  void cxios_set_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_Ptr reduce_axis_to_scalar_hdl, const char * operation, int operation_size)
+  {
+    std::string operation_str;
+    if (!cstr2string(operation, operation_size, operation_str)) return;
+    CTimer::get("XIOS").resume();
+    reduce_axis_to_scalar_hdl->operation.setValue(operation_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_Ptr reduce_axis_to_scalar_hdl, char * operation, int operation_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(reduce_axis_to_scalar_hdl->operation.getInheritedValue(), operation, operation_size))
+      ERROR("void cxios_get_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_Ptr reduce_axis_to_scalar_hdl, char * operation, int operation_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_Ptr reduce_axis_to_scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = reduce_axis_to_scalar_hdl->operation.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS/trunk/src/interface/c_attr/icscalar_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icscalar_attr.cpp	(revision 891)
+++ XIOS/trunk/src/interface/c_attr/icscalar_attr.cpp	(revision 891)
@@ -0,0 +1,171 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include "xios.hpp"
+#include "attribute_template.hpp"
+#include "object_template.hpp"
+#include "group_template.hpp"
+#include "icutil.hpp"
+#include "icdate.hpp"
+#include "timer.hpp"
+#include "node_type.hpp"
+
+extern "C"
+{
+  typedef xios::CScalar* scalar_Ptr;
+
+  void cxios_set_scalar_long_name(scalar_Ptr scalar_hdl, const char * long_name, int long_name_size)
+  {
+    std::string long_name_str;
+    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->long_name.setValue(long_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_long_name(scalar_Ptr scalar_hdl, char * long_name, int long_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->long_name.getInheritedValue(), long_name, long_name_size))
+      ERROR("void cxios_get_scalar_long_name(scalar_Ptr scalar_hdl, char * long_name, int long_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_long_name(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->long_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_name(scalar_Ptr scalar_hdl, const char * name, int name_size)
+  {
+    std::string name_str;
+    if (!cstr2string(name, name_size, name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->name.setValue(name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_name(scalar_Ptr scalar_hdl, char * name, int name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->name.getInheritedValue(), name, name_size))
+      ERROR("void cxios_get_scalar_name(scalar_Ptr scalar_hdl, char * name, int name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_name(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_scalar_ref(scalar_Ptr scalar_hdl, const char * scalar_ref, int scalar_ref_size)
+  {
+    std::string scalar_ref_str;
+    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->scalar_ref.setValue(scalar_ref_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_scalar_ref(scalar_Ptr scalar_hdl, char * scalar_ref, int scalar_ref_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
+      ERROR("void cxios_get_scalar_scalar_ref(scalar_Ptr scalar_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_scalar_ref(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->scalar_ref.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_standard_name(scalar_Ptr scalar_hdl, const char * standard_name, int standard_name_size)
+  {
+    std::string standard_name_str;
+    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->standard_name.setValue(standard_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_standard_name(scalar_Ptr scalar_hdl, char * standard_name, int standard_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
+      ERROR("void cxios_get_scalar_standard_name(scalar_Ptr scalar_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_standard_name(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->standard_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_unit(scalar_Ptr scalar_hdl, const char * unit, int unit_size)
+  {
+    std::string unit_str;
+    if (!cstr2string(unit, unit_size, unit_str)) return;
+    CTimer::get("XIOS").resume();
+    scalar_hdl->unit.setValue(unit_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_unit(scalar_Ptr scalar_hdl, char * unit, int unit_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalar_hdl->unit.getInheritedValue(), unit, unit_size))
+      ERROR("void cxios_get_scalar_unit(scalar_Ptr scalar_hdl, char * unit, int unit_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_unit(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->unit.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalar_value(scalar_Ptr scalar_hdl, double value)
+  {
+    CTimer::get("XIOS").resume();
+    scalar_hdl->value.setValue(value);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalar_value(scalar_Ptr scalar_hdl, double* value)
+  {
+    CTimer::get("XIOS").resume();
+    *value = scalar_hdl->value.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalar_value(scalar_Ptr scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalar_hdl->value.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS/trunk/src/interface/c_attr/icscalargroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icscalargroup_attr.cpp	(revision 891)
+++ XIOS/trunk/src/interface/c_attr/icscalargroup_attr.cpp	(revision 891)
@@ -0,0 +1,197 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include "xios.hpp"
+#include "attribute_template.hpp"
+#include "object_template.hpp"
+#include "group_template.hpp"
+#include "icutil.hpp"
+#include "icdate.hpp"
+#include "timer.hpp"
+#include "node_type.hpp"
+
+extern "C"
+{
+  typedef xios::CScalarGroup* scalargroup_Ptr;
+
+  void cxios_set_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, const char * group_ref, int group_ref_size)
+  {
+    std::string group_ref_str;
+    if (!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->group_ref.setValue(group_ref_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, char * group_ref, int group_ref_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->group_ref.getInheritedValue(), group_ref, group_ref_size))
+      ERROR("void cxios_get_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl, char * group_ref, int group_ref_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_group_ref(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->group_ref.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, const char * long_name, int long_name_size)
+  {
+    std::string long_name_str;
+    if (!cstr2string(long_name, long_name_size, long_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->long_name.setValue(long_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, char * long_name, int long_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->long_name.getInheritedValue(), long_name, long_name_size))
+      ERROR("void cxios_get_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl, char * long_name, int long_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_long_name(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->long_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_name(scalargroup_Ptr scalargroup_hdl, const char * name, int name_size)
+  {
+    std::string name_str;
+    if (!cstr2string(name, name_size, name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->name.setValue(name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_name(scalargroup_Ptr scalargroup_hdl, char * name, int name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->name.getInheritedValue(), name, name_size))
+      ERROR("void cxios_get_scalargroup_name(scalargroup_Ptr scalargroup_hdl, char * name, int name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_name(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_scalar_ref(scalargroup_Ptr scalargroup_hdl, const char * scalar_ref, int scalar_ref_size)
+  {
+    std::string scalar_ref_str;
+    if (!cstr2string(scalar_ref, scalar_ref_size, scalar_ref_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->scalar_ref.setValue(scalar_ref_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_scalar_ref(scalargroup_Ptr scalargroup_hdl, char * scalar_ref, int scalar_ref_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->scalar_ref.getInheritedValue(), scalar_ref, scalar_ref_size))
+      ERROR("void cxios_get_scalargroup_scalar_ref(scalargroup_Ptr scalargroup_hdl, char * scalar_ref, int scalar_ref_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_scalar_ref(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->scalar_ref.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_standard_name(scalargroup_Ptr scalargroup_hdl, const char * standard_name, int standard_name_size)
+  {
+    std::string standard_name_str;
+    if (!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->standard_name.setValue(standard_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_standard_name(scalargroup_Ptr scalargroup_hdl, char * standard_name, int standard_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->standard_name.getInheritedValue(), standard_name, standard_name_size))
+      ERROR("void cxios_get_scalargroup_standard_name(scalargroup_Ptr scalargroup_hdl, char * standard_name, int standard_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_standard_name(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->standard_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_unit(scalargroup_Ptr scalargroup_hdl, const char * unit, int unit_size)
+  {
+    std::string unit_str;
+    if (!cstr2string(unit, unit_size, unit_str)) return;
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->unit.setValue(unit_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_unit(scalargroup_Ptr scalargroup_hdl, char * unit, int unit_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(scalargroup_hdl->unit.getInheritedValue(), unit, unit_size))
+      ERROR("void cxios_get_scalargroup_unit(scalargroup_Ptr scalargroup_hdl, char * unit, int unit_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_unit(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->unit.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_scalargroup_value(scalargroup_Ptr scalargroup_hdl, double value)
+  {
+    CTimer::get("XIOS").resume();
+    scalargroup_hdl->value.setValue(value);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_scalargroup_value(scalargroup_Ptr scalargroup_hdl, double* value)
+  {
+    CTimer::get("XIOS").resume();
+    *value = scalargroup_hdl->value.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_scalargroup_value(scalargroup_Ptr scalargroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = scalargroup_hdl->value.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS/trunk/src/interface/fortran/ireduce_axis_to_scalar.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/ireduce_axis_to_scalar.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran/ireduce_axis_to_scalar.F90	(revision 891)
@@ -0,0 +1,30 @@
+#include "xios_fortran_prefix.hpp"
+
+MODULE IREDUCE_AXIS_TO_SCALAR
+   USE, INTRINSIC :: ISO_C_BINDING
+   USE REDUCE_AXIS_TO_SCALAR_INTERFACE
+
+   TYPE txios(reduce_axis_to_scalar)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(reduce_axis_to_scalar)
+
+   CONTAINS ! Fonctions disponibles pour les utilisateurs.
+
+   SUBROUTINE xios(get_reduce_axis_to_scalar_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *), INTENT(IN) :: idt
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(OUT):: ret
+      CALL cxios_reduce_axis_to_scalar_handle_create(ret%daddr, idt, len(idt))
+   END SUBROUTINE xios(get_reduce_axis_to_scalar_handle)
+
+   LOGICAL FUNCTION xios(is_valid_reduce_axis_to_scalar)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_reduce_axis_to_scalar_valid_id(val, idt, len(idt))
+      xios(is_valid_reduce_axis_to_scalar) = val
+
+   END FUNCTION  xios(is_valid_reduce_axis_to_scalar)
+
+END MODULE IREDUCE_AXIS_TO_SCALAR
Index: XIOS/trunk/src/interface/fortran/iscalar.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/iscalar.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran/iscalar.F90	(revision 891)
@@ -0,0 +1,56 @@
+#include "xios_fortran_prefix.hpp"
+
+MODULE ISCALAR
+   USE, INTRINSIC :: ISO_C_BINDING
+   USE SCALAR_INTERFACE
+   USE SCALARGROUP_INTERFACE
+
+   TYPE txios(scalar)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(scalar)
+
+   TYPE txios(scalargroup)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(scalargroup)
+
+
+
+   CONTAINS ! Fonctions disponibles pour les utilisateurs.
+
+   SUBROUTINE xios(get_scalar_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *), INTENT(IN) :: idt
+      TYPE(txios(scalar)) , INTENT(OUT):: ret
+      CALL cxios_scalar_handle_create(ret%daddr, idt, len(idt))
+   END SUBROUTINE xios(get_scalar_handle)
+
+   SUBROUTINE xios(get_scalargroup_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *)    , INTENT(IN) :: idt
+      TYPE(txios(scalargroup)), INTENT(OUT):: ret
+
+      CALL cxios_scalargroup_handle_create(ret%daddr, idt, len(idt))
+
+   END SUBROUTINE xios(get_scalargroup_handle)
+
+   LOGICAL FUNCTION xios(is_valid_scalar)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_scalar_valid_id(val, idt, len(idt))
+      xios(is_valid_scalar) = val
+
+   END FUNCTION  xios(is_valid_scalar)
+
+   LOGICAL FUNCTION xios(is_valid_scalargroup)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_scalargroup_valid_id(val, idt, len(idt))
+      xios(is_valid_scalargroup) = val
+
+   END FUNCTION  xios(is_valid_scalargroup)
+
+END MODULE ISCALAR
Index: XIOS/trunk/src/interface/fortran/ixios.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/ixios.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran/ixios.F90	(revision 891)
@@ -68,4 +68,10 @@
 USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr), xios(get_axisgroup_attr), xios(is_defined_axisgroup_attr)
 
+USE iscalar, ONLY : txios(scalar), txios(scalargroup), xios(is_valid_scalar), xios(is_valid_scalargroup)
+
+USE iscalar_attr, ONLY : xios(set_scalar_attr), xios(get_scalar_attr), xios(is_defined_scalar_attr)
+
+USE iscalargroup_attr, ONLY : xios(set_scalargroup_attr), xios(get_scalargroup_attr), xios(is_defined_scalargroup_attr)
+
 USE izoom_axis, ONLY : txios(zoom_axis), xios(is_valid_zoom_axis)
 
@@ -95,4 +101,8 @@
                                               xios(get_generate_rectilinear_domain_attr), &
                                               xios(is_defined_generate_rectilinear_domain_attr)
+USE ireduce_axis_to_scalar, ONLY : txios(reduce_axis_to_scalar), xios(is_valid_reduce_axis_to_scalar)
+
+USE ireduce_axis_to_scalar_attr, ONLY : xios(set_reduce_axis_to_scalar_attr), xios(get_reduce_axis_to_scalar_attr), &
+                                        xios(is_defined_reduce_axis_to_scalar_attr)
 
 USE XIOS_INTERFACES, ONLY : xios(set_attr), xios(get_attr), xios(is_defined_attr), xios(get_handle), xios(add_child), &
Index: XIOS/trunk/src/interface/fortran/ixios_interfaces.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 891)
@@ -51,4 +51,10 @@
 USE iaxisgroup_attr, ONLY : xios(set_axisgroup_attr_hdl), xios(get_axisgroup_attr_hdl), xios(is_defined_axisgroup_attr_hdl)
 
+USE iscalar, ONLY : xios(get_scalar_handle), xios(get_scalargroup_handle)
+
+USE iscalar_attr, ONLY : xios(set_scalar_attr_hdl), xios(get_scalar_attr_hdl), xios(is_defined_scalar_attr_hdl)
+
+USE iscalargroup_attr, ONLY : xios(set_scalargroup_attr_hdl), xios(get_scalargroup_attr_hdl), xios(is_defined_scalargroup_attr_hdl)
+
 USE izoom_axis, ONLY : xios(get_zoom_axis_handle)
 
@@ -79,4 +85,8 @@
                                               xios(is_defined_generate_rectilinear_domain_attr_hdl)
 
+USE ireduce_axis_to_scalar, ONLY : xios(get_reduce_axis_to_scalar_handle)
+
+USE 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)
+
 USE ixml_tree, ONLY : xios(add_axis), xios(add_file), xios(add_grid), xios(add_field), xios(add_domain),   &
                       xios(add_fieldtofile), xios(add_variabletofile), xios(add_variabletofield),          &
@@ -86,5 +96,6 @@
                       xios(add_zoomdomaintodomain), xios(add_interpolatedomaintodomain),                   &
                       xios(add_generatedomaintodomain), xios(add_zoomaxistoaxis),                          &
-                      xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis)
+                      xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis), xios(add_scalar),      &
+                      xios(add_scalargroup), xios(add_scalartogrid), xios(add_reduceaxistoscalartoscalar)
 
 PRIVATE
@@ -98,5 +109,6 @@
                    xios(set_zoom_domain_attr_hdl), xios(set_interpolate_axis_attr_hdl),                      &
                    xios(set_interpolate_domain_attr_hdl), xios(set_inverse_axis_attr_hdl),                   &
-                   xios(set_generate_rectilinear_domain_attr_hdl)
+                   xios(set_generate_rectilinear_domain_attr_hdl), xios(set_scalar_attr_hdl),                &
+                   xios(set_scalargroup_attr_hdl), xios(set_reduce_axis_to_scalar_attr_hdl)
 END INTERFACE xios(set_attr)
 
@@ -109,5 +121,6 @@
                    xios(get_zoom_domain_attr_hdl), xios(get_interpolate_axis_attr_hdl),                      &
                    xios(get_interpolate_domain_attr_hdl), xios(get_inverse_axis_attr_hdl),                   &
-                   xios(get_generate_rectilinear_domain_attr_hdl)
+                   xios(get_generate_rectilinear_domain_attr_hdl), xios(get_scalar_attr_hdl),                &
+                   xios(get_scalargroup_attr_hdl), xios(get_reduce_axis_to_scalar_attr_hdl)
 END INTERFACE xios(get_attr)
 
@@ -120,5 +133,7 @@
                    xios(is_defined_zoom_axis_attr_hdl), xios(is_defined_zoom_domain_attr_hdl),                                    &
                    xios(is_defined_interpolate_axis_attr_hdl), xios(is_defined_interpolate_domain_attr_hdl),                      &
-                   xios(is_defined_inverse_axis_attr_hdl), xios(is_defined_generate_rectilinear_domain_attr_hdl)
+                   xios(is_defined_inverse_axis_attr_hdl), xios(is_defined_generate_rectilinear_domain_attr_hdl),                 &
+                   xios(is_defined_scalar_attr_hdl), xios(is_defined_scalargroup_attr_hdl),                                       &
+                   xios(is_defined_reduce_axis_to_scalar_attr_hdl)
 END INTERFACE xios(is_defined_attr)
 
@@ -131,5 +146,6 @@
                    xios(get_zoom_domain_handle), xios(get_interpolate_axis_handle),                 &
                    xios(get_interpolate_domain_handle), xios(get_inverse_axis_handle),              &
-                   xios(get_generate_rectilinear_domain_handle)
+                   xios(get_generate_rectilinear_domain_handle), xios(get_scalar_handle),           &
+                   xios(get_scalargroup_handle), xios(get_reduce_axis_to_scalar_handle)
 END INTERFACE xios(get_handle)
 
@@ -141,5 +157,6 @@
                    xios(add_axistogrid), xios(add_domaintogrid), xios(add_zoomdomaintodomain),                       &
                    xios(add_interpolatedomaintodomain), xios(add_generatedomaintodomain),                            &
-                   xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis)
+                   xios(add_zoomaxistoaxis), xios(add_interpolateaxistoaxis), xios(add_inverseaxistoaxis),           &
+                   xios(add_scalar), xios(add_scalartogrid), xios(add_reduceaxistoscalartoscalar)
 END INTERFACE xios(add_child)
 
Index: XIOS/trunk/src/interface/fortran/ixml_tree.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/ixml_tree.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran/ixml_tree.F90	(revision 891)
@@ -3,4 +3,5 @@
 MODULE IXML_TREE
    USE, INTRINSIC :: ISO_C_BINDING
+   USE ISCALAR
    USE IAXIS
    USE IFILE
@@ -15,4 +16,5 @@
    USE IINTERPOLATE_AXIS
    USE IINVERSE_AXIS
+   USE IREDUCE_AXIS_TO_SCALAR
 
    INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
@@ -42,4 +44,12 @@
       END SUBROUTINE cxios_xml_tree_add_file
 
+      SUBROUTINE cxios_xml_tree_add_scalar(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_scalar
+
       SUBROUTINE cxios_xml_tree_add_axis(parent_, child_, child_id, child_id_size) BIND(C)
          USE ISO_C_BINDING
@@ -108,4 +118,12 @@
       END SUBROUTINE cxios_xml_tree_add_filegroup
 
+      SUBROUTINE cxios_xml_tree_add_scalargroup(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_scalargroup
+
       SUBROUTINE cxios_xml_tree_add_axisgroup(parent_, child_, child_id, child_id_size) BIND(C)
          USE ISO_C_BINDING
@@ -148,4 +166,12 @@
       END SUBROUTINE cxios_xml_tree_add_variablegrouptofield
 
+      SUBROUTINE cxios_xml_tree_add_scalartogrid(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_scalartogrid
+
       SUBROUTINE cxios_xml_tree_add_axistogrid(parent_, child_, child_id, child_id_size) BIND(C)
          USE ISO_C_BINDING
@@ -211,4 +237,12 @@
          INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
       END SUBROUTINE cxios_xml_tree_add_inverseaxistoaxis
+
+      SUBROUTINE cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_, child_, child_id, child_id_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T), VALUE        :: parent_
+         INTEGER  (kind = C_INTPTR_T)               :: child_
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: child_id
+         INTEGER  (kind = C_INT)     , VALUE        :: child_id_size
+      END SUBROUTINE cxios_xml_tree_add_reduceaxistoscalartoscalar
 
       SUBROUTINE cxios_xml_tree_show(filename, filename_size) BIND(C)
@@ -235,4 +269,16 @@
    CONTAINS ! Fonctions disponibles pour les utilisateurs.
 
+   SUBROUTINE xios(add_scalar)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(scalargroup))     , INTENT(IN) :: parent_hdl
+      TYPE(txios(scalar))          , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_scalar(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_scalar(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_scalar)
 
    SUBROUTINE xios(add_axis)(parent_hdl, child_hdl, child_id)
@@ -341,4 +387,16 @@
    END SUBROUTINE xios(add_variabletofield)
 
+   SUBROUTINE xios(add_scalargroup)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(scalargroup))      , INTENT(IN) :: parent_hdl
+      TYPE(txios(scalargroup))      , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL, INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_scalargroup(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_scalargroup(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_scalargroup)
 
    SUBROUTINE xios(add_axisgroup)(parent_hdl, child_hdl, child_id)
@@ -446,4 +504,17 @@
    END SUBROUTINE xios(add_variablegrouptofield)
 
+   SUBROUTINE xios(add_scalartogrid)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(grid))             , INTENT(IN) :: parent_hdl
+      TYPE(txios(scalar))           , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL  , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_scalartogrid(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_scalartogrid(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_scalartogrid)
+
    SUBROUTINE xios(add_axistogrid)(parent_hdl, child_hdl, child_id)
       TYPE(txios(grid))             , INTENT(IN) :: parent_hdl
@@ -549,3 +620,16 @@
 
    END SUBROUTINE xios(add_inverseaxistoaxis)
+
+   SUBROUTINE xios(add_reduceaxistoscalartoscalar)(parent_hdl, child_hdl, child_id)
+      TYPE(txios(axis))                      , INTENT(IN) :: parent_hdl
+      TYPE(txios(inverse_axis))              , INTENT(OUT):: child_hdl
+      CHARACTER(len = *), OPTIONAL           , INTENT(IN) :: child_id
+
+      IF (PRESENT(child_id)) THEN
+         CALL cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_hdl%daddr, child_hdl%daddr, child_id, len(child_id))
+      ELSE
+         CALL cxios_xml_tree_add_reduceaxistoscalartoscalar(parent_hdl%daddr, child_hdl%daddr, "NONE", -1)
+      END IF
+
+   END SUBROUTINE xios(add_reduceaxistoscalartoscalar)
 END MODULE IXML_TREE
Index: XIOS/trunk/src/interface/fortran/reduce_axis_to_scalar_interface.f90
===================================================================
--- XIOS/trunk/src/interface/fortran/reduce_axis_to_scalar_interface.f90	(revision 891)
+++ XIOS/trunk/src/interface/fortran/reduce_axis_to_scalar_interface.f90	(revision 891)
@@ -0,0 +1,22 @@
+MODULE REDUCE_AXIS_TO_SCALAR_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+      SUBROUTINE cxios_reduce_axis_to_scalar_handle_create(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T)               :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_reduce_axis_to_scalar_handle_create
+
+      SUBROUTINE cxios_reduce_axis_to_scalar_valid_id(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         LOGICAL  (kind = C_BOOL)                   :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_reduce_axis_to_scalar_valid_id
+
+   END INTERFACE
+
+END MODULE REDUCE_AXIS_TO_SCALAR_INTERFACE
Index: XIOS/trunk/src/interface/fortran/scalar_interface.f90
===================================================================
--- XIOS/trunk/src/interface/fortran/scalar_interface.f90	(revision 891)
+++ XIOS/trunk/src/interface/fortran/scalar_interface.f90	(revision 891)
@@ -0,0 +1,22 @@
+MODULE SCALAR_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+      SUBROUTINE cxios_scalar_handle_create(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T)               :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_scalar_handle_create
+
+      SUBROUTINE cxios_scalar_valid_id(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         LOGICAL  (kind = C_BOOL)                   :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_scalar_valid_id
+
+   END INTERFACE
+
+END MODULE SCALAR_INTERFACE
Index: XIOS/trunk/src/interface/fortran/scalargroup_interface.f90
===================================================================
--- XIOS/trunk/src/interface/fortran/scalargroup_interface.f90	(revision 891)
+++ XIOS/trunk/src/interface/fortran/scalargroup_interface.f90	(revision 891)
@@ -0,0 +1,23 @@
+MODULE SCALARGROUP_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+
+      SUBROUTINE cxios_scalargroup_handle_create(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         INTEGER  (kind = C_INTPTR_T)               :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_scalargroup_handle_create
+
+      SUBROUTINE cxios_scalargroup_valid_id(ret, idt, idt_size) BIND(C)
+         USE ISO_C_BINDING
+         LOGICAL  (kind = C_BOOL)                   :: ret
+         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt
+         INTEGER  (kind = C_INT)     , VALUE        :: idt_size
+      END SUBROUTINE cxios_scalargroup_valid_id
+
+   END INTERFACE
+
+END MODULE SCALARGROUP_INTERFACE
Index: XIOS/trunk/src/interface/fortran_attr/field_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/field_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/field_interface_attr.F90	(revision 891)
@@ -391,4 +391,25 @@
 
 
+    SUBROUTINE cxios_set_field_scalar_ref(field_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_set_field_scalar_ref
+
+    SUBROUTINE cxios_get_field_scalar_ref(field_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_get_field_scalar_ref
+
+    FUNCTION cxios_is_defined_field_scalar_ref(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_scalar_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_scalar_ref
+
+
     SUBROUTINE cxios_set_field_scale_factor(field_hdl, scale_factor) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90	(revision 891)
@@ -412,4 +412,25 @@
 
 
+    SUBROUTINE cxios_set_fieldgroup_scalar_ref(fieldgroup_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_set_fieldgroup_scalar_ref
+
+    SUBROUTINE cxios_get_fieldgroup_scalar_ref(fieldgroup_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_get_fieldgroup_scalar_ref
+
+    FUNCTION cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_scalar_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_scalar_ref
+
+
     SUBROUTINE cxios_set_fieldgroup_scale_factor(fieldgroup_hdl, scale_factor) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/file_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/file_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/file_interface_attr.F90	(revision 891)
@@ -48,4 +48,23 @@
 
 
+    SUBROUTINE cxios_set_file_cyclic(file_hdl, cyclic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: cyclic
+    END SUBROUTINE cxios_set_file_cyclic
+
+    SUBROUTINE cxios_get_file_cyclic(file_hdl, cyclic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      LOGICAL (KIND=C_BOOL)             :: cyclic
+    END SUBROUTINE cxios_get_file_cyclic
+
+    FUNCTION cxios_is_defined_file_cyclic(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_cyclic
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_cyclic
+
+
     SUBROUTINE cxios_set_file_description(file_hdl, description, description_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90	(revision 891)
@@ -48,4 +48,23 @@
 
 
+    SUBROUTINE cxios_set_filegroup_cyclic(filegroup_hdl, cyclic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: cyclic
+    END SUBROUTINE cxios_set_filegroup_cyclic
+
+    SUBROUTINE cxios_get_filegroup_cyclic(filegroup_hdl, cyclic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      LOGICAL (KIND=C_BOOL)             :: cyclic
+    END SUBROUTINE cxios_get_filegroup_cyclic
+
+    FUNCTION cxios_is_defined_filegroup_cyclic(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_cyclic
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_cyclic
+
+
     SUBROUTINE cxios_set_filegroup_description(filegroup_hdl, description, description_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/ifield_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/ifield_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/ifield_attr.F90	(revision 891)
@@ -14,5 +14,5 @@
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -43,4 +43,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
@@ -56,5 +57,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -64,5 +65,5 @@
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -92,4 +93,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
@@ -104,5 +106,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -112,5 +114,5 @@
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
-    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
     , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -140,4 +142,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access_
       LOGICAL (KIND=C_BOOL) :: read_access__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
@@ -229,4 +232,8 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_set_field_scalar_ref(field_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         CALL cxios_set_field_scale_factor(field_hdl%daddr, scale_factor_)
@@ -263,5 +270,5 @@
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -292,4 +299,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
@@ -305,5 +313,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -313,5 +321,5 @@
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -341,4 +349,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
@@ -353,5 +362,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -361,5 +370,5 @@
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
-    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
     , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -389,4 +398,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access_
       LOGICAL (KIND=C_BOOL) :: read_access__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
@@ -478,4 +488,8 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_get_field_scalar_ref(field_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         CALL cxios_get_field_scale_factor(field_hdl%daddr, scale_factor_)
@@ -512,5 +526,5 @@
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -556,4 +570,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL(KIND=C_BOOL) :: read_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor
       LOGICAL(KIND=C_BOOL) :: scale_factor_tmp
@@ -575,5 +591,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -583,5 +599,5 @@
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
     , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+    , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
     , unit, valid_max, valid_min )
 
@@ -626,4 +642,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL(KIND=C_BOOL) :: read_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor
       LOGICAL(KIND=C_BOOL) :: scale_factor_tmp
@@ -644,5 +662,5 @@
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
       , enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, indexed_output, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, ts_enabled, ts_split_freq  &
+      , name, operation, prec, read_access, scalar_ref, scale_factor, standard_name, ts_enabled, ts_split_freq  &
       , unit, valid_max, valid_min )
 
@@ -652,5 +670,5 @@
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
-    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
     , ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -695,4 +713,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access_
       LOGICAL(KIND=C_BOOL) :: read_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_
+      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor_
       LOGICAL(KIND=C_BOOL) :: scale_factor__tmp
@@ -805,4 +825,9 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        scalar_ref__tmp = cxios_is_defined_field_scalar_ref(field_hdl%daddr)
+        scalar_ref_ = scalar_ref__tmp
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         scale_factor__tmp = cxios_is_defined_field_scale_factor(field_hdl%daddr)
Index: XIOS/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90	(revision 891)
@@ -14,6 +14,6 @@
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -44,4 +44,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
@@ -57,6 +58,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(set_fieldgroup_attr)
@@ -65,6 +66,6 @@
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -94,4 +95,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
@@ -106,6 +108,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(set_fieldgroup_attr_hdl)
@@ -114,5 +116,5 @@
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  &
-    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  &
+    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  &
     , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -143,4 +145,5 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_access_
       LOGICAL (KIND=C_BOOL) :: read_access__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: scale_factor_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
@@ -236,4 +239,8 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_set_fieldgroup_scalar_ref(fieldgroup_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         CALL cxios_set_fieldgroup_scale_factor(fieldgroup_hdl%daddr, scale_factor_)
@@ -270,6 +277,6 @@
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -300,4 +307,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
@@ -313,6 +321,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(get_fieldgroup_attr)
@@ -321,6 +329,6 @@
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -350,4 +358,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL (KIND=C_BOOL) :: read_access_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
@@ -362,6 +371,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(get_fieldgroup_attr_hdl)
@@ -370,5 +379,5 @@
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  &
-    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  &
+    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  &
     , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -399,4 +408,5 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_access_
       LOGICAL (KIND=C_BOOL) :: read_access__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: scale_factor_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
@@ -492,4 +502,8 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_get_fieldgroup_scalar_ref(fieldgroup_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         CALL cxios_get_fieldgroup_scale_factor(fieldgroup_hdl%daddr, scale_factor_)
@@ -526,6 +540,6 @@
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -572,4 +586,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL(KIND=C_BOOL) :: read_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor
       LOGICAL(KIND=C_BOOL) :: scale_factor_tmp
@@ -591,6 +607,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr)
@@ -599,6 +615,6 @@
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
     , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-    , ts_split_freq, unit, valid_max, valid_min )
+    , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+    , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -644,4 +660,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access
       LOGICAL(KIND=C_BOOL) :: read_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor
       LOGICAL(KIND=C_BOOL) :: scale_factor_tmp
@@ -662,6 +680,6 @@
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
       , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, indexed_output  &
-      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, ts_enabled  &
-      , ts_split_freq, unit, valid_max, valid_min )
+      , level, long_name, name, operation, prec, read_access, scalar_ref, scale_factor, standard_name  &
+      , ts_enabled, ts_split_freq, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)
@@ -670,5 +688,5 @@
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
     , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_  &
-    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_  &
+    , indexed_output_, level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_  &
     , standard_name_, ts_enabled_, ts_split_freq_, unit_, valid_max_, valid_min_ )
 
@@ -715,4 +733,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_access_
       LOGICAL(KIND=C_BOOL) :: read_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_
+      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: scale_factor_
       LOGICAL(KIND=C_BOOL) :: scale_factor__tmp
@@ -830,4 +850,9 @@
       ENDIF
 
+      IF (PRESENT(scalar_ref_)) THEN
+        scalar_ref__tmp = cxios_is_defined_fieldgroup_scalar_ref(fieldgroup_hdl%daddr)
+        scalar_ref_ = scalar_ref__tmp
+      ENDIF
+
       IF (PRESENT(scale_factor_)) THEN
         scale_factor__tmp = cxios_is_defined_fieldgroup_scale_factor(fieldgroup_hdl%daddr)
Index: XIOS/trunk/src/interface/fortran_attr/ifile_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/ifile_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/ifile_attr.F90	(revision 891)
@@ -12,7 +12,7 @@
 
   SUBROUTINE xios(set_file_attr)  &
-    ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  &
-    , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  &
-    , time_counter, time_counter_name, timeseries, ts_prefix, type )
+    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
     IMPLICIT NONE
@@ -22,4 +22,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled
@@ -45,6 +47,6 @@
       CALL xios(get_file_handle)(file_id,file_hdl)
       CALL xios(set_file_attr_hdl_)   &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -52,6 +54,6 @@
 
   SUBROUTINE xios(set_file_attr_hdl)  &
-    ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-    , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
     , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -61,4 +63,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled
@@ -83,6 +87,6 @@
 
       CALL xios(set_file_attr_hdl_)  &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -90,6 +94,6 @@
 
   SUBROUTINE xios(set_file_attr_hdl_)   &
-    ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  &
-    , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
+    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  &
+    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
     , type_ )
@@ -100,4 +104,6 @@
       LOGICAL (KIND=C_BOOL) :: append__tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_
+      LOGICAL (KIND=C_BOOL) :: cyclic__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled_
@@ -130,4 +136,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        cyclic__tmp = cyclic_
+        CALL cxios_set_file_cyclic(file_hdl%daddr, cyclic__tmp)
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         CALL cxios_set_file_description(file_hdl%daddr, description_, len(description_))
@@ -210,7 +221,7 @@
 
   SUBROUTINE xios(get_file_attr)  &
-    ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  &
-    , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  &
-    , time_counter, time_counter_name, timeseries, ts_prefix, type )
+    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
     IMPLICIT NONE
@@ -220,4 +231,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled
@@ -243,6 +256,6 @@
       CALL xios(get_file_handle)(file_id,file_hdl)
       CALL xios(get_file_attr_hdl_)   &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -250,6 +263,6 @@
 
   SUBROUTINE xios(get_file_attr_hdl)  &
-    ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-    , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
     , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -259,4 +272,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled
@@ -281,6 +296,6 @@
 
       CALL xios(get_file_attr_hdl_)  &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -288,6 +303,6 @@
 
   SUBROUTINE xios(get_file_attr_hdl_)   &
-    ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  &
-    , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
+    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  &
+    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
     , type_ )
@@ -298,4 +313,6 @@
       LOGICAL (KIND=C_BOOL) :: append__tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_
+      LOGICAL (KIND=C_BOOL) :: cyclic__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled_
@@ -328,4 +345,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        CALL cxios_get_file_cyclic(file_hdl%daddr, cyclic__tmp)
+        cyclic_ = cyclic__tmp
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         CALL cxios_get_file_description(file_hdl%daddr, description_, len(description_))
@@ -408,7 +430,7 @@
 
   SUBROUTINE xios(is_defined_file_attr)  &
-    ( file_id, append, compression_level, description, enabled, format, min_digits, mode, name, name_suffix  &
-    , output_freq, output_level, par_access, record_offset, split_freq, split_freq_format, sync_freq  &
-    , time_counter, time_counter_name, timeseries, ts_prefix, type )
+    ( file_id, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
     IMPLICIT NONE
@@ -419,4 +441,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL(KIND=C_BOOL) :: cyclic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -460,6 +484,6 @@
       CALL xios(get_file_handle)(file_id,file_hdl)
       CALL xios(is_defined_file_attr_hdl_)   &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -467,6 +491,6 @@
 
   SUBROUTINE xios(is_defined_file_attr_hdl)  &
-    ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-    , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+    ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+    , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
     , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -477,4 +501,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL(KIND=C_BOOL) :: cyclic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -517,6 +543,6 @@
 
       CALL xios(is_defined_file_attr_hdl_)  &
-      ( file_hdl, append, compression_level, description, enabled, format, min_digits, mode, name  &
-      , name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
+      ( file_hdl, append, compression_level, cyclic, description, enabled, format, min_digits, mode  &
+      , name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq, split_freq_format  &
       , sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type )
 
@@ -524,6 +550,6 @@
 
   SUBROUTINE xios(is_defined_file_attr_hdl_)   &
-    ( file_hdl, append_, compression_level_, description_, enabled_, format_, min_digits_, mode_  &
-    , name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
+    ( file_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, min_digits_  &
+    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
     , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
     , type_ )
@@ -535,4 +561,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_
       LOGICAL(KIND=C_BOOL) :: compression_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_
+      LOGICAL(KIND=C_BOOL) :: cyclic__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description_
       LOGICAL(KIND=C_BOOL) :: description__tmp
@@ -584,4 +612,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        cyclic__tmp = cxios_is_defined_file_cyclic(file_hdl%daddr)
+        cyclic_ = cyclic__tmp
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         description__tmp = cxios_is_defined_file_description(file_hdl%daddr)
Index: XIOS/trunk/src/interface/fortran_attr/ifilegroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/ifilegroup_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/ifilegroup_attr.F90	(revision 891)
@@ -12,5 +12,5 @@
 
   SUBROUTINE xios(set_filegroup_attr)  &
-    ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  &
+    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  &
     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
@@ -23,4 +23,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled
@@ -47,16 +49,16 @@
       CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl)
       CALL xios(set_filegroup_attr_hdl_)   &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(set_filegroup_attr)
 
   SUBROUTINE xios(set_filegroup_attr_hdl)  &
-    ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-     )
+    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+    , type )
 
     IMPLICIT NONE
@@ -65,4 +67,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled
@@ -88,16 +92,16 @@
 
       CALL xios(set_filegroup_attr_hdl_)  &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(set_filegroup_attr_hdl)
 
   SUBROUTINE xios(set_filegroup_attr_hdl_)   &
-    ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  &
-    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
-    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
-    , type_ )
+    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  &
+    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  &
+    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  &
+    , ts_prefix_, type_ )
 
     IMPLICIT NONE
@@ -106,4 +110,6 @@
       LOGICAL (KIND=C_BOOL) :: append__tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: cyclic_
+      LOGICAL (KIND=C_BOOL) :: cyclic__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
       LOGICAL  , OPTIONAL, INTENT(IN) :: enabled_
@@ -137,4 +143,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        cyclic__tmp = cyclic_
+        CALL cxios_set_filegroup_cyclic(filegroup_hdl%daddr, cyclic__tmp)
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         CALL cxios_set_filegroup_description(filegroup_hdl%daddr, description_, len(description_))
@@ -221,5 +232,5 @@
 
   SUBROUTINE xios(get_filegroup_attr)  &
-    ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  &
+    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  &
     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
@@ -232,4 +243,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled
@@ -256,16 +269,16 @@
       CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl)
       CALL xios(get_filegroup_attr_hdl_)   &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(get_filegroup_attr)
 
   SUBROUTINE xios(get_filegroup_attr_hdl)  &
-    ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-     )
+    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+    , type )
 
     IMPLICIT NONE
@@ -274,4 +287,6 @@
       LOGICAL (KIND=C_BOOL) :: append_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL (KIND=C_BOOL) :: cyclic_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled
@@ -297,16 +312,16 @@
 
       CALL xios(get_filegroup_attr_hdl_)  &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(get_filegroup_attr_hdl)
 
   SUBROUTINE xios(get_filegroup_attr_hdl_)   &
-    ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  &
-    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
-    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
-    , type_ )
+    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  &
+    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  &
+    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  &
+    , ts_prefix_, type_ )
 
     IMPLICIT NONE
@@ -315,4 +330,6 @@
       LOGICAL (KIND=C_BOOL) :: append__tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: cyclic_
+      LOGICAL (KIND=C_BOOL) :: cyclic__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: enabled_
@@ -346,4 +363,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        CALL cxios_get_filegroup_cyclic(filegroup_hdl%daddr, cyclic__tmp)
+        cyclic_ = cyclic__tmp
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         CALL cxios_get_filegroup_description(filegroup_hdl%daddr, description_, len(description_))
@@ -430,5 +452,5 @@
 
   SUBROUTINE xios(is_defined_filegroup_attr)  &
-    ( filegroup_id, append, compression_level, description, enabled, format, group_ref, min_digits  &
+    ( filegroup_id, append, compression_level, cyclic, description, enabled, format, group_ref, min_digits  &
     , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
     , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
@@ -442,4 +464,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL(KIND=C_BOOL) :: cyclic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -485,16 +509,16 @@
       CALL xios(get_filegroup_handle)(filegroup_id,filegroup_hdl)
       CALL xios(is_defined_filegroup_attr_hdl_)   &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(is_defined_filegroup_attr)
 
   SUBROUTINE xios(is_defined_filegroup_attr_hdl)  &
-    ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-    , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-    , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-     )
+    ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+    , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+    , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+    , type )
 
     IMPLICIT NONE
@@ -504,4 +528,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic
+      LOGICAL(KIND=C_BOOL) :: cyclic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -546,16 +572,16 @@
 
       CALL xios(is_defined_filegroup_attr_hdl_)  &
-      ( filegroup_hdl, append, compression_level, description, enabled, format, group_ref, min_digits  &
-      , mode, name, name_suffix, output_freq, output_level, par_access, record_offset, split_freq  &
-      , split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix, type  &
-       )
+      ( filegroup_hdl, append, compression_level, cyclic, description, enabled, format, group_ref  &
+      , min_digits, mode, name, name_suffix, output_freq, output_level, par_access, record_offset  &
+      , split_freq, split_freq_format, sync_freq, time_counter, time_counter_name, timeseries, ts_prefix  &
+      , type )
 
   END SUBROUTINE xios(is_defined_filegroup_attr_hdl)
 
   SUBROUTINE xios(is_defined_filegroup_attr_hdl_)   &
-    ( filegroup_hdl, append_, compression_level_, description_, enabled_, format_, group_ref_, min_digits_  &
-    , mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_, split_freq_  &
-    , split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_, ts_prefix_  &
-    , type_ )
+    ( filegroup_hdl, append_, compression_level_, cyclic_, description_, enabled_, format_, group_ref_  &
+    , min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_, record_offset_  &
+    , split_freq_, split_freq_format_, sync_freq_, time_counter_, time_counter_name_, timeseries_  &
+    , ts_prefix_, type_ )
 
     IMPLICIT NONE
@@ -565,4 +591,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_
       LOGICAL(KIND=C_BOOL) :: compression_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: cyclic_
+      LOGICAL(KIND=C_BOOL) :: cyclic__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description_
       LOGICAL(KIND=C_BOOL) :: description__tmp
@@ -616,4 +644,9 @@
       ENDIF
 
+      IF (PRESENT(cyclic_)) THEN
+        cyclic__tmp = cxios_is_defined_filegroup_cyclic(filegroup_hdl%daddr)
+        cyclic_ = cyclic__tmp
+      ENDIF
+
       IF (PRESENT(description_)) THEN
         description__tmp = cxios_is_defined_filegroup_description(filegroup_hdl%daddr)
Index: XIOS/trunk/src/interface/fortran_attr/iinterpolate_axis_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iinterpolate_axis_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/iinterpolate_axis_attr.F90	(revision 891)
@@ -12,9 +12,10 @@
 
   SUBROUTINE xios(set_interpolate_axis_attr)  &
-    ( interpolate_axis_id, order, type )
+    ( interpolate_axis_id, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl
       CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate
       INTEGER  , OPTIONAL, INTENT(IN) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -22,28 +23,34 @@
       CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl)
       CALL xios(set_interpolate_axis_attr_hdl_)   &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(set_interpolate_axis_attr)
 
   SUBROUTINE xios(set_interpolate_axis_attr_hdl)  &
-    ( interpolate_axis_hdl, order, type )
+    ( interpolate_axis_hdl, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate
       INTEGER  , OPTIONAL, INTENT(IN) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
       CALL xios(set_interpolate_axis_attr_hdl_)  &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(set_interpolate_axis_attr_hdl)
 
   SUBROUTINE xios(set_interpolate_axis_attr_hdl_)   &
-    ( interpolate_axis_hdl, order_, type_ )
+    ( interpolate_axis_hdl, coordinate_, order_, type_ )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: coordinate_
       INTEGER  , OPTIONAL, INTENT(IN) :: order_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+
+      IF (PRESENT(coordinate_)) THEN
+        CALL cxios_set_interpolate_axis_coordinate(interpolate_axis_hdl%daddr, coordinate_, len(coordinate_))
+      ENDIF
 
       IF (PRESENT(order_)) THEN
@@ -58,9 +65,10 @@
 
   SUBROUTINE xios(get_interpolate_axis_attr)  &
-    ( interpolate_axis_id, order, type )
+    ( interpolate_axis_id, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl
       CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -68,28 +76,34 @@
       CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl)
       CALL xios(get_interpolate_axis_attr_hdl_)   &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(get_interpolate_axis_attr)
 
   SUBROUTINE xios(get_interpolate_axis_attr_hdl)  &
-    ( interpolate_axis_hdl, order, type )
+    ( interpolate_axis_hdl, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
       CALL xios(get_interpolate_axis_attr_hdl_)  &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(get_interpolate_axis_attr_hdl)
 
   SUBROUTINE xios(get_interpolate_axis_attr_hdl_)   &
-    ( interpolate_axis_hdl, order_, type_ )
+    ( interpolate_axis_hdl, coordinate_, order_, type_ )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: coordinate_
       INTEGER  , OPTIONAL, INTENT(OUT) :: order_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+
+      IF (PRESENT(coordinate_)) THEN
+        CALL cxios_get_interpolate_axis_coordinate(interpolate_axis_hdl%daddr, coordinate_, len(coordinate_))
+      ENDIF
 
       IF (PRESENT(order_)) THEN
@@ -104,9 +118,11 @@
 
   SUBROUTINE xios(is_defined_interpolate_axis_attr)  &
-    ( interpolate_axis_id, order, type )
+    ( interpolate_axis_id, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis))  :: interpolate_axis_hdl
       CHARACTER(LEN=*), INTENT(IN) ::interpolate_axis_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate
+      LOGICAL(KIND=C_BOOL) :: coordinate_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
@@ -116,13 +132,15 @@
       CALL xios(get_interpolate_axis_handle)(interpolate_axis_id,interpolate_axis_hdl)
       CALL xios(is_defined_interpolate_axis_attr_hdl_)   &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(is_defined_interpolate_axis_attr)
 
   SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl)  &
-    ( interpolate_axis_hdl, order, type )
+    ( interpolate_axis_hdl, coordinate, order, type )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate
+      LOGICAL(KIND=C_BOOL) :: coordinate_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
@@ -131,17 +149,24 @@
 
       CALL xios(is_defined_interpolate_axis_attr_hdl_)  &
-      ( interpolate_axis_hdl, order, type )
+      ( interpolate_axis_hdl, coordinate, order, type )
 
   END SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl)
 
   SUBROUTINE xios(is_defined_interpolate_axis_attr_hdl_)   &
-    ( interpolate_axis_hdl, order_, type_ )
+    ( interpolate_axis_hdl, coordinate_, order_, type_ )
 
     IMPLICIT NONE
       TYPE(txios(interpolate_axis)) , INTENT(IN) :: interpolate_axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: coordinate_
+      LOGICAL(KIND=C_BOOL) :: coordinate__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order_
       LOGICAL(KIND=C_BOOL) :: order__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type_
       LOGICAL(KIND=C_BOOL) :: type__tmp
+
+      IF (PRESENT(coordinate_)) THEN
+        coordinate__tmp = cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_hdl%daddr)
+        coordinate_ = coordinate__tmp
+      ENDIF
 
       IF (PRESENT(order_)) THEN
Index: XIOS/trunk/src/interface/fortran_attr/iinterpolate_domain_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iinterpolate_domain_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/iinterpolate_domain_attr.F90	(revision 891)
@@ -12,5 +12,5 @@
 
   SUBROUTINE xios(set_interpolate_domain_attr)  &
-    ( interpolate_domain_id, file, order )
+    ( interpolate_domain_id, file, order, renormalize )
 
     IMPLICIT NONE
@@ -19,13 +19,15 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file
       INTEGER  , OPTIONAL, INTENT(IN) :: order
+      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize
+      LOGICAL (KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl)
       CALL xios(set_interpolate_domain_attr_hdl_)   &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(set_interpolate_domain_attr)
 
   SUBROUTINE xios(set_interpolate_domain_attr_hdl)  &
-    ( interpolate_domain_hdl, file, order )
+    ( interpolate_domain_hdl, file, order, renormalize )
 
     IMPLICIT NONE
@@ -33,12 +35,14 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file
       INTEGER  , OPTIONAL, INTENT(IN) :: order
+      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize
+      LOGICAL (KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(set_interpolate_domain_attr_hdl_)  &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(set_interpolate_domain_attr_hdl)
 
   SUBROUTINE xios(set_interpolate_domain_attr_hdl_)   &
-    ( interpolate_domain_hdl, file_, order_ )
+    ( interpolate_domain_hdl, file_, order_, renormalize_ )
 
     IMPLICIT NONE
@@ -46,4 +50,6 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: file_
       INTEGER  , OPTIONAL, INTENT(IN) :: order_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: renormalize_
+      LOGICAL (KIND=C_BOOL) :: renormalize__tmp
 
       IF (PRESENT(file_)) THEN
@@ -55,8 +61,13 @@
       ENDIF
 
+      IF (PRESENT(renormalize_)) THEN
+        renormalize__tmp = renormalize_
+        CALL cxios_set_interpolate_domain_renormalize(interpolate_domain_hdl%daddr, renormalize__tmp)
+      ENDIF
+
   END SUBROUTINE xios(set_interpolate_domain_attr_hdl_)
 
   SUBROUTINE xios(get_interpolate_domain_attr)  &
-    ( interpolate_domain_id, file, order )
+    ( interpolate_domain_id, file, order, renormalize )
 
     IMPLICIT NONE
@@ -65,13 +76,15 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize
+      LOGICAL (KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl)
       CALL xios(get_interpolate_domain_attr_hdl_)   &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(get_interpolate_domain_attr)
 
   SUBROUTINE xios(get_interpolate_domain_attr_hdl)  &
-    ( interpolate_domain_hdl, file, order )
+    ( interpolate_domain_hdl, file, order, renormalize )
 
     IMPLICIT NONE
@@ -79,12 +92,14 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize
+      LOGICAL (KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(get_interpolate_domain_attr_hdl_)  &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(get_interpolate_domain_attr_hdl)
 
   SUBROUTINE xios(get_interpolate_domain_attr_hdl_)   &
-    ( interpolate_domain_hdl, file_, order_ )
+    ( interpolate_domain_hdl, file_, order_, renormalize_ )
 
     IMPLICIT NONE
@@ -92,4 +107,6 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: file_
       INTEGER  , OPTIONAL, INTENT(OUT) :: order_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: renormalize_
+      LOGICAL (KIND=C_BOOL) :: renormalize__tmp
 
       IF (PRESENT(file_)) THEN
@@ -101,8 +118,13 @@
       ENDIF
 
+      IF (PRESENT(renormalize_)) THEN
+        CALL cxios_get_interpolate_domain_renormalize(interpolate_domain_hdl%daddr, renormalize__tmp)
+        renormalize_ = renormalize__tmp
+      ENDIF
+
   END SUBROUTINE xios(get_interpolate_domain_attr_hdl_)
 
   SUBROUTINE xios(is_defined_interpolate_domain_attr)  &
-    ( interpolate_domain_id, file, order )
+    ( interpolate_domain_id, file, order, renormalize )
 
     IMPLICIT NONE
@@ -113,13 +135,15 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize
+      LOGICAL(KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(get_interpolate_domain_handle)(interpolate_domain_id,interpolate_domain_hdl)
       CALL xios(is_defined_interpolate_domain_attr_hdl_)   &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(is_defined_interpolate_domain_attr)
 
   SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl)  &
-    ( interpolate_domain_hdl, file, order )
+    ( interpolate_domain_hdl, file, order, renormalize )
 
     IMPLICIT NONE
@@ -129,12 +153,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize
+      LOGICAL(KIND=C_BOOL) :: renormalize_tmp
 
       CALL xios(is_defined_interpolate_domain_attr_hdl_)  &
-      ( interpolate_domain_hdl, file, order )
+      ( interpolate_domain_hdl, file, order, renormalize )
 
   END SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl)
 
   SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl_)   &
-    ( interpolate_domain_hdl, file_, order_ )
+    ( interpolate_domain_hdl, file_, order_, renormalize_ )
 
     IMPLICIT NONE
@@ -144,4 +170,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: order_
       LOGICAL(KIND=C_BOOL) :: order__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: renormalize_
+      LOGICAL(KIND=C_BOOL) :: renormalize__tmp
 
       IF (PRESENT(file_)) THEN
@@ -155,4 +183,9 @@
       ENDIF
 
+      IF (PRESENT(renormalize_)) THEN
+        renormalize__tmp = cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_hdl%daddr)
+        renormalize_ = renormalize__tmp
+      ENDIF
+
   END SUBROUTINE xios(is_defined_interpolate_domain_attr_hdl_)
 
Index: XIOS/trunk/src/interface/fortran_attr/interpolate_axis_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/interpolate_axis_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/interpolate_axis_interface_attr.F90	(revision 891)
@@ -9,4 +9,25 @@
   INTERFACE
     ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_interpolate_axis_coordinate(interpolate_axis_hdl, coordinate, coordinate_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: coordinate
+      INTEGER  (kind = C_INT)     , VALUE        :: coordinate_size
+    END SUBROUTINE cxios_set_interpolate_axis_coordinate
+
+    SUBROUTINE cxios_get_interpolate_axis_coordinate(interpolate_axis_hdl, coordinate, coordinate_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: coordinate
+      INTEGER  (kind = C_INT)     , VALUE        :: coordinate_size
+    END SUBROUTINE cxios_get_interpolate_axis_coordinate
+
+    FUNCTION cxios_is_defined_interpolate_axis_coordinate(interpolate_axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_interpolate_axis_coordinate
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_axis_hdl
+    END FUNCTION cxios_is_defined_interpolate_axis_coordinate
+
 
     SUBROUTINE cxios_set_interpolate_axis_order(interpolate_axis_hdl, order) BIND(C)
Index: XIOS/trunk/src/interface/fortran_attr/interpolate_domain_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/interpolate_domain_interface_attr.F90	(revision 886)
+++ XIOS/trunk/src/interface/fortran_attr/interpolate_domain_interface_attr.F90	(revision 891)
@@ -49,4 +49,23 @@
     END FUNCTION cxios_is_defined_interpolate_domain_order
 
+
+    SUBROUTINE cxios_set_interpolate_domain_renormalize(interpolate_domain_hdl, renormalize) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: renormalize
+    END SUBROUTINE cxios_set_interpolate_domain_renormalize
+
+    SUBROUTINE cxios_get_interpolate_domain_renormalize(interpolate_domain_hdl, renormalize) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl
+      LOGICAL (KIND=C_BOOL)             :: renormalize
+    END SUBROUTINE cxios_get_interpolate_domain_renormalize
+
+    FUNCTION cxios_is_defined_interpolate_domain_renormalize(interpolate_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_interpolate_domain_renormalize
+      INTEGER (kind = C_INTPTR_T), VALUE :: interpolate_domain_hdl
+    END FUNCTION cxios_is_defined_interpolate_domain_renormalize
+
   END INTERFACE
 
Index: XIOS/trunk/src/interface/fortran_attr/ireduce_axis_to_scalar_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/ireduce_axis_to_scalar_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/ireduce_axis_to_scalar_attr.F90	(revision 891)
@@ -0,0 +1,134 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE ireduce_axis_to_scalar_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE ireduce_axis_to_scalar
+  USE reduce_axis_to_scalar_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_reduce_axis_to_scalar_attr)  &
+    ( reduce_axis_to_scalar_id, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar))  :: reduce_axis_to_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::reduce_axis_to_scalar_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: operation
+
+      CALL xios(get_reduce_axis_to_scalar_handle)(reduce_axis_to_scalar_id,reduce_axis_to_scalar_hdl)
+      CALL xios(set_reduce_axis_to_scalar_attr_hdl_)   &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(set_reduce_axis_to_scalar_attr)
+
+  SUBROUTINE xios(set_reduce_axis_to_scalar_attr_hdl)  &
+    ( reduce_axis_to_scalar_hdl, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: operation
+
+      CALL xios(set_reduce_axis_to_scalar_attr_hdl_)  &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(set_reduce_axis_to_scalar_attr_hdl)
+
+  SUBROUTINE xios(set_reduce_axis_to_scalar_attr_hdl_)   &
+    ( reduce_axis_to_scalar_hdl, operation_ )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: operation_
+
+      IF (PRESENT(operation_)) THEN
+        CALL cxios_set_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl%daddr, operation_, len(operation_))
+      ENDIF
+
+  END SUBROUTINE xios(set_reduce_axis_to_scalar_attr_hdl_)
+
+  SUBROUTINE xios(get_reduce_axis_to_scalar_attr)  &
+    ( reduce_axis_to_scalar_id, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar))  :: reduce_axis_to_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::reduce_axis_to_scalar_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: operation
+
+      CALL xios(get_reduce_axis_to_scalar_handle)(reduce_axis_to_scalar_id,reduce_axis_to_scalar_hdl)
+      CALL xios(get_reduce_axis_to_scalar_attr_hdl_)   &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(get_reduce_axis_to_scalar_attr)
+
+  SUBROUTINE xios(get_reduce_axis_to_scalar_attr_hdl)  &
+    ( reduce_axis_to_scalar_hdl, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: operation
+
+      CALL xios(get_reduce_axis_to_scalar_attr_hdl_)  &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(get_reduce_axis_to_scalar_attr_hdl)
+
+  SUBROUTINE xios(get_reduce_axis_to_scalar_attr_hdl_)   &
+    ( reduce_axis_to_scalar_hdl, operation_ )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: operation_
+
+      IF (PRESENT(operation_)) THEN
+        CALL cxios_get_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl%daddr, operation_, len(operation_))
+      ENDIF
+
+  END SUBROUTINE xios(get_reduce_axis_to_scalar_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr)  &
+    ( reduce_axis_to_scalar_id, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar))  :: reduce_axis_to_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::reduce_axis_to_scalar_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+
+      CALL xios(get_reduce_axis_to_scalar_handle)(reduce_axis_to_scalar_id,reduce_axis_to_scalar_hdl)
+      CALL xios(is_defined_reduce_axis_to_scalar_attr_hdl_)   &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr)
+
+  SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr_hdl)  &
+    ( reduce_axis_to_scalar_hdl, operation )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation
+      LOGICAL(KIND=C_BOOL) :: operation_tmp
+
+      CALL xios(is_defined_reduce_axis_to_scalar_attr_hdl_)  &
+      ( reduce_axis_to_scalar_hdl, operation )
+
+  END SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr_hdl)
+
+  SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr_hdl_)   &
+    ( reduce_axis_to_scalar_hdl, operation_ )
+
+    IMPLICIT NONE
+      TYPE(txios(reduce_axis_to_scalar)) , INTENT(IN) :: reduce_axis_to_scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: operation_
+      LOGICAL(KIND=C_BOOL) :: operation__tmp
+
+      IF (PRESENT(operation_)) THEN
+        operation__tmp = cxios_is_defined_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl%daddr)
+        operation_ = operation__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_reduce_axis_to_scalar_attr_hdl_)
+
+END MODULE ireduce_axis_to_scalar_attr
Index: XIOS/trunk/src/interface/fortran_attr/iscalar_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iscalar_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/iscalar_attr.F90	(revision 891)
@@ -0,0 +1,259 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE iscalar_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE iscalar
+  USE scalar_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_scalar_attr)  &
+    ( scalar_id, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar))  :: scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalar_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value
+
+      CALL xios(get_scalar_handle)(scalar_id,scalar_hdl)
+      CALL xios(set_scalar_attr_hdl_)   &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(set_scalar_attr)
+
+  SUBROUTINE xios(set_scalar_attr_hdl)  &
+    ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value
+
+      CALL xios(set_scalar_attr_hdl_)  &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(set_scalar_attr_hdl)
+
+  SUBROUTINE xios(set_scalar_attr_hdl_)   &
+    ( scalar_hdl, long_name_, name_, scalar_ref_, standard_name_, unit_, value_ )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_
+
+      IF (PRESENT(long_name_)) THEN
+        CALL cxios_set_scalar_long_name(scalar_hdl%daddr, long_name_, len(long_name_))
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        CALL cxios_set_scalar_name(scalar_hdl%daddr, name_, len(name_))
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_set_scalar_scalar_ref(scalar_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        CALL cxios_set_scalar_standard_name(scalar_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        CALL cxios_set_scalar_unit(scalar_hdl%daddr, unit_, len(unit_))
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        CALL cxios_set_scalar_value(scalar_hdl%daddr, value_)
+      ENDIF
+
+  END SUBROUTINE xios(set_scalar_attr_hdl_)
+
+  SUBROUTINE xios(get_scalar_attr)  &
+    ( scalar_id, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar))  :: scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalar_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value
+
+      CALL xios(get_scalar_handle)(scalar_id,scalar_hdl)
+      CALL xios(get_scalar_attr_hdl_)   &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(get_scalar_attr)
+
+  SUBROUTINE xios(get_scalar_attr_hdl)  &
+    ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value
+
+      CALL xios(get_scalar_attr_hdl_)  &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(get_scalar_attr_hdl)
+
+  SUBROUTINE xios(get_scalar_attr_hdl_)   &
+    ( scalar_hdl, long_name_, name_, scalar_ref_, standard_name_, unit_, value_ )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_
+
+      IF (PRESENT(long_name_)) THEN
+        CALL cxios_get_scalar_long_name(scalar_hdl%daddr, long_name_, len(long_name_))
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        CALL cxios_get_scalar_name(scalar_hdl%daddr, name_, len(name_))
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_get_scalar_scalar_ref(scalar_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        CALL cxios_get_scalar_standard_name(scalar_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        CALL cxios_get_scalar_unit(scalar_hdl%daddr, unit_, len(unit_))
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        CALL cxios_get_scalar_value(scalar_hdl%daddr, value_)
+      ENDIF
+
+  END SUBROUTINE xios(get_scalar_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_scalar_attr)  &
+    ( scalar_id, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar))  :: scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalar_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+
+      CALL xios(get_scalar_handle)(scalar_id,scalar_hdl)
+      CALL xios(is_defined_scalar_attr_hdl_)   &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(is_defined_scalar_attr)
+
+  SUBROUTINE xios(is_defined_scalar_attr_hdl)  &
+    ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+
+      CALL xios(is_defined_scalar_attr_hdl_)  &
+      ( scalar_hdl, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(is_defined_scalar_attr_hdl)
+
+  SUBROUTINE xios(is_defined_scalar_attr_hdl_)   &
+    ( scalar_hdl, long_name_, name_, scalar_ref_, standard_name_, unit_, value_ )
+
+    IMPLICIT NONE
+      TYPE(txios(scalar)) , INTENT(IN) :: scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_
+      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value_
+      LOGICAL(KIND=C_BOOL) :: value__tmp
+
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp = cxios_is_defined_scalar_long_name(scalar_hdl%daddr)
+        long_name_ = long_name__tmp
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        name__tmp = cxios_is_defined_scalar_name(scalar_hdl%daddr)
+        name_ = name__tmp
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        scalar_ref__tmp = cxios_is_defined_scalar_scalar_ref(scalar_hdl%daddr)
+        scalar_ref_ = scalar_ref__tmp
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp = cxios_is_defined_scalar_standard_name(scalar_hdl%daddr)
+        standard_name_ = standard_name__tmp
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        unit__tmp = cxios_is_defined_scalar_unit(scalar_hdl%daddr)
+        unit_ = unit__tmp
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        value__tmp = cxios_is_defined_scalar_value(scalar_hdl%daddr)
+        value_ = value__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_scalar_attr_hdl_)
+
+END MODULE iscalar_attr
Index: XIOS/trunk/src/interface/fortran_attr/iscalargroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iscalargroup_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/iscalargroup_attr.F90	(revision 891)
@@ -0,0 +1,287 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE iscalargroup_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE iscalar
+  USE scalargroup_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_scalargroup_attr)  &
+    ( scalargroup_id, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup))  :: scalargroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalargroup_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value
+
+      CALL xios(get_scalargroup_handle)(scalargroup_id,scalargroup_hdl)
+      CALL xios(set_scalargroup_attr_hdl_)   &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(set_scalargroup_attr)
+
+  SUBROUTINE xios(set_scalargroup_attr_hdl)  &
+    ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value
+
+      CALL xios(set_scalargroup_attr_hdl_)  &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(set_scalargroup_attr_hdl)
+
+  SUBROUTINE xios(set_scalargroup_attr_hdl_)   &
+    ( scalargroup_hdl, group_ref_, long_name_, name_, scalar_ref_, standard_name_, unit_, value_  &
+     )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: scalar_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_
+
+      IF (PRESENT(group_ref_)) THEN
+        CALL cxios_set_scalargroup_group_ref(scalargroup_hdl%daddr, group_ref_, len(group_ref_))
+      ENDIF
+
+      IF (PRESENT(long_name_)) THEN
+        CALL cxios_set_scalargroup_long_name(scalargroup_hdl%daddr, long_name_, len(long_name_))
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        CALL cxios_set_scalargroup_name(scalargroup_hdl%daddr, name_, len(name_))
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_set_scalargroup_scalar_ref(scalargroup_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        CALL cxios_set_scalargroup_standard_name(scalargroup_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        CALL cxios_set_scalargroup_unit(scalargroup_hdl%daddr, unit_, len(unit_))
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        CALL cxios_set_scalargroup_value(scalargroup_hdl%daddr, value_)
+      ENDIF
+
+  END SUBROUTINE xios(set_scalargroup_attr_hdl_)
+
+  SUBROUTINE xios(get_scalargroup_attr)  &
+    ( scalargroup_id, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup))  :: scalargroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalargroup_id
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value
+
+      CALL xios(get_scalargroup_handle)(scalargroup_id,scalargroup_hdl)
+      CALL xios(get_scalargroup_attr_hdl_)   &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(get_scalargroup_attr)
+
+  SUBROUTINE xios(get_scalargroup_attr_hdl)  &
+    ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value
+
+      CALL xios(get_scalargroup_attr_hdl_)  &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(get_scalargroup_attr_hdl)
+
+  SUBROUTINE xios(get_scalargroup_attr_hdl_)   &
+    ( scalargroup_hdl, group_ref_, long_name_, name_, scalar_ref_, standard_name_, unit_, value_  &
+     )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: scalar_ref_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_
+
+      IF (PRESENT(group_ref_)) THEN
+        CALL cxios_get_scalargroup_group_ref(scalargroup_hdl%daddr, group_ref_, len(group_ref_))
+      ENDIF
+
+      IF (PRESENT(long_name_)) THEN
+        CALL cxios_get_scalargroup_long_name(scalargroup_hdl%daddr, long_name_, len(long_name_))
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        CALL cxios_get_scalargroup_name(scalargroup_hdl%daddr, name_, len(name_))
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        CALL cxios_get_scalargroup_scalar_ref(scalargroup_hdl%daddr, scalar_ref_, len(scalar_ref_))
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        CALL cxios_get_scalargroup_standard_name(scalargroup_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        CALL cxios_get_scalargroup_unit(scalargroup_hdl%daddr, unit_, len(unit_))
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        CALL cxios_get_scalargroup_value(scalargroup_hdl%daddr, value_)
+      ENDIF
+
+  END SUBROUTINE xios(get_scalargroup_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_scalargroup_attr)  &
+    ( scalargroup_id, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup))  :: scalargroup_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::scalargroup_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+
+      CALL xios(get_scalargroup_handle)(scalargroup_id,scalargroup_hdl)
+      CALL xios(is_defined_scalargroup_attr_hdl_)   &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(is_defined_scalargroup_attr)
+
+  SUBROUTINE xios(is_defined_scalargroup_attr_hdl)  &
+    ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
+      LOGICAL(KIND=C_BOOL) :: long_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name
+      LOGICAL(KIND=C_BOOL) :: name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref
+      LOGICAL(KIND=C_BOOL) :: scalar_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
+      LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit
+      LOGICAL(KIND=C_BOOL) :: unit_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value
+      LOGICAL(KIND=C_BOOL) :: value_tmp
+
+      CALL xios(is_defined_scalargroup_attr_hdl_)  &
+      ( scalargroup_hdl, group_ref, long_name, name, scalar_ref, standard_name, unit, value )
+
+  END SUBROUTINE xios(is_defined_scalargroup_attr_hdl)
+
+  SUBROUTINE xios(is_defined_scalargroup_attr_hdl_)   &
+    ( scalargroup_hdl, group_ref_, long_name_, name_, scalar_ref_, standard_name_, unit_, value_  &
+     )
+
+    IMPLICIT NONE
+      TYPE(txios(scalargroup)) , INTENT(IN) :: scalargroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
+      LOGICAL(KIND=C_BOOL) :: long_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: name_
+      LOGICAL(KIND=C_BOOL) :: name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: scalar_ref_
+      LOGICAL(KIND=C_BOOL) :: scalar_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
+      LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: unit_
+      LOGICAL(KIND=C_BOOL) :: unit__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: value_
+      LOGICAL(KIND=C_BOOL) :: value__tmp
+
+      IF (PRESENT(group_ref_)) THEN
+        group_ref__tmp = cxios_is_defined_scalargroup_group_ref(scalargroup_hdl%daddr)
+        group_ref_ = group_ref__tmp
+      ENDIF
+
+      IF (PRESENT(long_name_)) THEN
+        long_name__tmp = cxios_is_defined_scalargroup_long_name(scalargroup_hdl%daddr)
+        long_name_ = long_name__tmp
+      ENDIF
+
+      IF (PRESENT(name_)) THEN
+        name__tmp = cxios_is_defined_scalargroup_name(scalargroup_hdl%daddr)
+        name_ = name__tmp
+      ENDIF
+
+      IF (PRESENT(scalar_ref_)) THEN
+        scalar_ref__tmp = cxios_is_defined_scalargroup_scalar_ref(scalargroup_hdl%daddr)
+        scalar_ref_ = scalar_ref__tmp
+      ENDIF
+
+      IF (PRESENT(standard_name_)) THEN
+        standard_name__tmp = cxios_is_defined_scalargroup_standard_name(scalargroup_hdl%daddr)
+        standard_name_ = standard_name__tmp
+      ENDIF
+
+      IF (PRESENT(unit_)) THEN
+        unit__tmp = cxios_is_defined_scalargroup_unit(scalargroup_hdl%daddr)
+        unit_ = unit__tmp
+      ENDIF
+
+      IF (PRESENT(value_)) THEN
+        value__tmp = cxios_is_defined_scalargroup_value(scalargroup_hdl%daddr)
+        value_ = value__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_scalargroup_attr_hdl_)
+
+END MODULE iscalargroup_attr
Index: XIOS/trunk/src/interface/fortran_attr/reduce_axis_to_scalar_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/reduce_axis_to_scalar_interface_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/reduce_axis_to_scalar_interface_attr.F90	(revision 891)
@@ -0,0 +1,34 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE reduce_axis_to_scalar_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl, operation, operation_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: reduce_axis_to_scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation
+      INTEGER  (kind = C_INT)     , VALUE        :: operation_size
+    END SUBROUTINE cxios_set_reduce_axis_to_scalar_operation
+
+    SUBROUTINE cxios_get_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl, operation, operation_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: reduce_axis_to_scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: operation
+      INTEGER  (kind = C_INT)     , VALUE        :: operation_size
+    END SUBROUTINE cxios_get_reduce_axis_to_scalar_operation
+
+    FUNCTION cxios_is_defined_reduce_axis_to_scalar_operation(reduce_axis_to_scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_reduce_axis_to_scalar_operation
+      INTEGER (kind = C_INTPTR_T), VALUE :: reduce_axis_to_scalar_hdl
+    END FUNCTION cxios_is_defined_reduce_axis_to_scalar_operation
+
+  END INTERFACE
+
+END MODULE reduce_axis_to_scalar_interface_attr
Index: XIOS/trunk/src/interface/fortran_attr/scalar_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/scalar_interface_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/scalar_interface_attr.F90	(revision 891)
@@ -0,0 +1,137 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE scalar_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_scalar_long_name(scalar_hdl, long_name, long_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name
+      INTEGER  (kind = C_INT)     , VALUE        :: long_name_size
+    END SUBROUTINE cxios_set_scalar_long_name
+
+    SUBROUTINE cxios_get_scalar_long_name(scalar_hdl, long_name, long_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name
+      INTEGER  (kind = C_INT)     , VALUE        :: long_name_size
+    END SUBROUTINE cxios_get_scalar_long_name
+
+    FUNCTION cxios_is_defined_scalar_long_name(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_long_name
+
+
+    SUBROUTINE cxios_set_scalar_name(scalar_hdl, name, name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name
+      INTEGER  (kind = C_INT)     , VALUE        :: name_size
+    END SUBROUTINE cxios_set_scalar_name
+
+    SUBROUTINE cxios_get_scalar_name(scalar_hdl, name, name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name
+      INTEGER  (kind = C_INT)     , VALUE        :: name_size
+    END SUBROUTINE cxios_get_scalar_name
+
+    FUNCTION cxios_is_defined_scalar_name(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_name
+
+
+    SUBROUTINE cxios_set_scalar_scalar_ref(scalar_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_set_scalar_scalar_ref
+
+    SUBROUTINE cxios_get_scalar_scalar_ref(scalar_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_get_scalar_scalar_ref
+
+    FUNCTION cxios_is_defined_scalar_scalar_ref(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_scalar_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_scalar_ref
+
+
+    SUBROUTINE cxios_set_scalar_standard_name(scalar_hdl, standard_name, standard_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name
+      INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size
+    END SUBROUTINE cxios_set_scalar_standard_name
+
+    SUBROUTINE cxios_get_scalar_standard_name(scalar_hdl, standard_name, standard_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name
+      INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size
+    END SUBROUTINE cxios_get_scalar_standard_name
+
+    FUNCTION cxios_is_defined_scalar_standard_name(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_standard_name
+
+
+    SUBROUTINE cxios_set_scalar_unit(scalar_hdl, unit, unit_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit
+      INTEGER  (kind = C_INT)     , VALUE        :: unit_size
+    END SUBROUTINE cxios_set_scalar_unit
+
+    SUBROUTINE cxios_get_scalar_unit(scalar_hdl, unit, unit_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit
+      INTEGER  (kind = C_INT)     , VALUE        :: unit_size
+    END SUBROUTINE cxios_get_scalar_unit
+
+    FUNCTION cxios_is_defined_scalar_unit(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_unit
+
+
+    SUBROUTINE cxios_set_scalar_value(scalar_hdl, value) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: value
+    END SUBROUTINE cxios_set_scalar_value
+
+    SUBROUTINE cxios_get_scalar_value(scalar_hdl, value) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+      REAL (KIND=C_DOUBLE)             :: value
+    END SUBROUTINE cxios_get_scalar_value
+
+    FUNCTION cxios_is_defined_scalar_value(scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalar_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalar_hdl
+    END FUNCTION cxios_is_defined_scalar_value
+
+  END INTERFACE
+
+END MODULE scalar_interface_attr
Index: XIOS/trunk/src/interface/fortran_attr/scalargroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/scalargroup_interface_attr.F90	(revision 891)
+++ XIOS/trunk/src/interface/fortran_attr/scalargroup_interface_attr.F90	(revision 891)
@@ -0,0 +1,158 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE scalargroup_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_scalargroup_group_ref(scalargroup_hdl, group_ref, group_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: group_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: group_ref_size
+    END SUBROUTINE cxios_set_scalargroup_group_ref
+
+    SUBROUTINE cxios_get_scalargroup_group_ref(scalargroup_hdl, group_ref, group_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: group_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: group_ref_size
+    END SUBROUTINE cxios_get_scalargroup_group_ref
+
+    FUNCTION cxios_is_defined_scalargroup_group_ref(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_group_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_group_ref
+
+
+    SUBROUTINE cxios_set_scalargroup_long_name(scalargroup_hdl, long_name, long_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name
+      INTEGER  (kind = C_INT)     , VALUE        :: long_name_size
+    END SUBROUTINE cxios_set_scalargroup_long_name
+
+    SUBROUTINE cxios_get_scalargroup_long_name(scalargroup_hdl, long_name, long_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: long_name
+      INTEGER  (kind = C_INT)     , VALUE        :: long_name_size
+    END SUBROUTINE cxios_get_scalargroup_long_name
+
+    FUNCTION cxios_is_defined_scalargroup_long_name(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_long_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_long_name
+
+
+    SUBROUTINE cxios_set_scalargroup_name(scalargroup_hdl, name, name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name
+      INTEGER  (kind = C_INT)     , VALUE        :: name_size
+    END SUBROUTINE cxios_set_scalargroup_name
+
+    SUBROUTINE cxios_get_scalargroup_name(scalargroup_hdl, name, name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: name
+      INTEGER  (kind = C_INT)     , VALUE        :: name_size
+    END SUBROUTINE cxios_get_scalargroup_name
+
+    FUNCTION cxios_is_defined_scalargroup_name(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_name
+
+
+    SUBROUTINE cxios_set_scalargroup_scalar_ref(scalargroup_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_set_scalargroup_scalar_ref
+
+    SUBROUTINE cxios_get_scalargroup_scalar_ref(scalargroup_hdl, scalar_ref, scalar_ref_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: scalar_ref
+      INTEGER  (kind = C_INT)     , VALUE        :: scalar_ref_size
+    END SUBROUTINE cxios_get_scalargroup_scalar_ref
+
+    FUNCTION cxios_is_defined_scalargroup_scalar_ref(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_scalar_ref
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_scalar_ref
+
+
+    SUBROUTINE cxios_set_scalargroup_standard_name(scalargroup_hdl, standard_name, standard_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name
+      INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size
+    END SUBROUTINE cxios_set_scalargroup_standard_name
+
+    SUBROUTINE cxios_get_scalargroup_standard_name(scalargroup_hdl, standard_name, standard_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: standard_name
+      INTEGER  (kind = C_INT)     , VALUE        :: standard_name_size
+    END SUBROUTINE cxios_get_scalargroup_standard_name
+
+    FUNCTION cxios_is_defined_scalargroup_standard_name(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_standard_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_standard_name
+
+
+    SUBROUTINE cxios_set_scalargroup_unit(scalargroup_hdl, unit, unit_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit
+      INTEGER  (kind = C_INT)     , VALUE        :: unit_size
+    END SUBROUTINE cxios_set_scalargroup_unit
+
+    SUBROUTINE cxios_get_scalargroup_unit(scalargroup_hdl, unit, unit_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: unit
+      INTEGER  (kind = C_INT)     , VALUE        :: unit_size
+    END SUBROUTINE cxios_get_scalargroup_unit
+
+    FUNCTION cxios_is_defined_scalargroup_unit(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_unit
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_unit
+
+
+    SUBROUTINE cxios_set_scalargroup_value(scalargroup_hdl, value) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: value
+    END SUBROUTINE cxios_set_scalargroup_value
+
+    SUBROUTINE cxios_get_scalargroup_value(scalargroup_hdl, value) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+      REAL (KIND=C_DOUBLE)             :: value
+    END SUBROUTINE cxios_get_scalargroup_value
+
+    FUNCTION cxios_is_defined_scalargroup_value(scalargroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_scalargroup_value
+      INTEGER (kind = C_INTPTR_T), VALUE :: scalargroup_hdl
+    END FUNCTION cxios_is_defined_scalargroup_value
+
+  END INTERFACE
+
+END MODULE scalargroup_interface_attr
