Index: XIOS3/trunk/src/generate_fortran_interface.cpp
===================================================================
--- XIOS3/trunk/src/generate_fortran_interface.cpp	(revision 2614)
+++ XIOS3/trunk/src/generate_fortran_interface.cpp	(revision 2616)
@@ -335,4 +335,12 @@
   file.close();
 
+  file.open((path+"redistribute_domain_interface_attr.F90").c_str());
+  redistributeDomain.generateFortran2003Interface(file);
+  file.close();
+
+  file.open((path+"icredistribute_domain_attr.cpp").c_str());
+  redistributeDomain.generateCInterface(file);
+  file.close();
+  
   file.open((path+"iredistribute_domain_attr.F90").c_str());
   redistributeDomain.generateFortranInterface(file);
@@ -444,4 +452,12 @@
   file.close();
 
+  file.open((path+"redistribute_axis_interface_attr.F90").c_str());
+  redistributeAxis.generateFortran2003Interface(file);
+  file.close();
+
+  file.open((path+"icredistribute_axis_attr.cpp").c_str());
+  redistributeAxis.generateCInterface(file);
+  file.close();
+
   file.open((path+"iredistribute_axis_attr.F90").c_str());
   redistributeAxis.generateFortranInterface(file);
@@ -501,4 +517,12 @@
   file.close();
 
+  file.open((path+"redistribute_scalar_interface_attr.F90").c_str());
+  redistributeScalar.generateFortran2003Interface(file);
+  file.close();
+
+  file.open((path+"icredistribute_scalar_attr.cpp").c_str());
+  redistributeScalar.generateCInterface(file);
+  file.close();
+
   file.open((path+"iredistribute_scalar_attr.F90").c_str());
   redistributeScalar.generateFortranInterface(file);
Index: XIOS3/trunk/src/interface/c_attr/icaxis_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 2616)
@@ -143,4 +143,27 @@
 
 
+  void cxios_set_axis_chunking_weight(axis_Ptr axis_hdl, double chunking_weight)
+  {
+    CTimer::get("XIOS").resume();
+    axis_hdl->chunking_weight.setValue(chunking_weight);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_chunking_weight(axis_Ptr axis_hdl, double* chunking_weight)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight = axis_hdl->chunking_weight.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_chunking_weight(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->chunking_weight.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axis_comment(axis_Ptr axis_hdl, const char * comment, int comment_size)
   {
Index: XIOS3/trunk/src/interface/c_attr/icaxisgroup_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 2616)
@@ -143,4 +143,27 @@
 
 
+  void cxios_set_axisgroup_chunking_weight(axisgroup_Ptr axisgroup_hdl, double chunking_weight)
+  {
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->chunking_weight.setValue(chunking_weight);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_chunking_weight(axisgroup_Ptr axisgroup_hdl, double* chunking_weight)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight = axisgroup_hdl->chunking_weight.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_chunking_weight(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->chunking_weight.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axisgroup_comment(axisgroup_Ptr axisgroup_hdl, const char * comment, int comment_size)
   {
Index: XIOS3/trunk/src/interface/c_attr/iccontext_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/iccontext_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/iccontext_attr.cpp	(revision 2616)
@@ -40,4 +40,209 @@
 
 
+  void cxios_set_context_default_gatherer(context_Ptr context_hdl, const char * default_gatherer, int default_gatherer_size)
+  {
+    std::string default_gatherer_str;
+    if (!cstr2string(default_gatherer, default_gatherer_size, default_gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_gatherer.setValue(default_gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_gatherer(context_Ptr context_hdl, char * default_gatherer, int default_gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_gatherer.getInheritedValue(), default_gatherer, default_gatherer_size))
+      ERROR("void cxios_get_context_default_gatherer(context_Ptr context_hdl, char * default_gatherer, int default_gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_gatherer(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_pool(context_Ptr context_hdl, const char * default_pool, int default_pool_size)
+  {
+    std::string default_pool_str;
+    if (!cstr2string(default_pool, default_pool_size, default_pool_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_pool.setValue(default_pool_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_pool(context_Ptr context_hdl, char * default_pool, int default_pool_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_pool.getInheritedValue(), default_pool, default_pool_size))
+      ERROR("void cxios_get_context_default_pool(context_Ptr context_hdl, char * default_pool, int default_pool_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_pool(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_pool.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_pool_gatherer(context_Ptr context_hdl, const char * default_pool_gatherer, int default_pool_gatherer_size)
+  {
+    std::string default_pool_gatherer_str;
+    if (!cstr2string(default_pool_gatherer, default_pool_gatherer_size, default_pool_gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_pool_gatherer.setValue(default_pool_gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_pool_gatherer(context_Ptr context_hdl, char * default_pool_gatherer, int default_pool_gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_pool_gatherer.getInheritedValue(), default_pool_gatherer, default_pool_gatherer_size))
+      ERROR("void cxios_get_context_default_pool_gatherer(context_Ptr context_hdl, char * default_pool_gatherer, int default_pool_gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_pool_gatherer(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_pool_gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_pool_reader(context_Ptr context_hdl, const char * default_pool_reader, int default_pool_reader_size)
+  {
+    std::string default_pool_reader_str;
+    if (!cstr2string(default_pool_reader, default_pool_reader_size, default_pool_reader_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_pool_reader.setValue(default_pool_reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_pool_reader(context_Ptr context_hdl, char * default_pool_reader, int default_pool_reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_pool_reader.getInheritedValue(), default_pool_reader, default_pool_reader_size))
+      ERROR("void cxios_get_context_default_pool_reader(context_Ptr context_hdl, char * default_pool_reader, int default_pool_reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_pool_reader(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_pool_reader.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_pool_writer(context_Ptr context_hdl, const char * default_pool_writer, int default_pool_writer_size)
+  {
+    std::string default_pool_writer_str;
+    if (!cstr2string(default_pool_writer, default_pool_writer_size, default_pool_writer_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_pool_writer.setValue(default_pool_writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_pool_writer(context_Ptr context_hdl, char * default_pool_writer, int default_pool_writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_pool_writer.getInheritedValue(), default_pool_writer, default_pool_writer_size))
+      ERROR("void cxios_get_context_default_pool_writer(context_Ptr context_hdl, char * default_pool_writer, int default_pool_writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_pool_writer(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_pool_writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_reader(context_Ptr context_hdl, const char * default_reader, int default_reader_size)
+  {
+    std::string default_reader_str;
+    if (!cstr2string(default_reader, default_reader_size, default_reader_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_reader.setValue(default_reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_reader(context_Ptr context_hdl, char * default_reader, int default_reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_reader.getInheritedValue(), default_reader, default_reader_size))
+      ERROR("void cxios_get_context_default_reader(context_Ptr context_hdl, char * default_reader, int default_reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_reader(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_reader.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_using_server2(context_Ptr context_hdl, bool default_using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    context_hdl->default_using_server2.setValue(default_using_server2);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_using_server2(context_Ptr context_hdl, bool* default_using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    *default_using_server2 = context_hdl->default_using_server2.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_using_server2(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_using_server2.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_context_default_writer(context_Ptr context_hdl, const char * default_writer, int default_writer_size)
+  {
+    std::string default_writer_str;
+    if (!cstr2string(default_writer, default_writer_size, default_writer_str)) return;
+    CTimer::get("XIOS").resume();
+    context_hdl->default_writer.setValue(default_writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_context_default_writer(context_Ptr context_hdl, char * default_writer, int default_writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(context_hdl->default_writer.getInheritedValue(), default_writer, default_writer_size))
+      ERROR("void cxios_get_context_default_writer(context_Ptr context_hdl, char * default_writer, int default_writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_context_default_writer(context_Ptr context_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = context_hdl->default_writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_context_output_dir(context_Ptr context_hdl, const char * output_dir, int output_dir_size)
   {
Index: XIOS3/trunk/src/interface/c_attr/icdomain_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 2616)
@@ -42,4 +42,54 @@
 
 
+  void cxios_set_domain_area_1d(domain_Ptr domain_hdl, double* area_1d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(area_1d, shape(extent[0]), neverDeleteData);
+    domain_hdl->area_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_area_1d(domain_Ptr domain_hdl, double* area_1d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(area_1d, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->area_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_area_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->area_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_area_2d(domain_Ptr domain_hdl, double* area_2d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(area_2d, shape(extent[0], extent[1]), neverDeleteData);
+    domain_hdl->area_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_area_2d(domain_Ptr domain_hdl, double* area_2d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(area_2d, shape(extent[0], extent[1]), neverDeleteData);
+    tmp=domain_hdl->area_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_area_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->area_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int* extent)
   {
@@ -194,4 +244,50 @@
 
 
+  void cxios_set_domain_chunking_weight_i(domain_Ptr domain_hdl, double chunking_weight_i)
+  {
+    CTimer::get("XIOS").resume();
+    domain_hdl->chunking_weight_i.setValue(chunking_weight_i);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_chunking_weight_i(domain_Ptr domain_hdl, double* chunking_weight_i)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight_i = domain_hdl->chunking_weight_i.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_chunking_weight_i(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->chunking_weight_i.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_chunking_weight_j(domain_Ptr domain_hdl, double chunking_weight_j)
+  {
+    CTimer::get("XIOS").resume();
+    domain_hdl->chunking_weight_j.setValue(chunking_weight_j);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_chunking_weight_j(domain_Ptr domain_hdl, double* chunking_weight_j)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight_j = domain_hdl->chunking_weight_j.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_chunking_weight_j(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->chunking_weight_j.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_comment(domain_Ptr domain_hdl, const char * comment, int comment_size)
   {
@@ -928,4 +1024,30 @@
 
 
+  void cxios_set_domain_nvertex_name(domain_Ptr domain_hdl, const char * nvertex_name, int nvertex_name_size)
+  {
+    std::string nvertex_name_str;
+    if (!cstr2string(nvertex_name, nvertex_name_size, nvertex_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domain_hdl->nvertex_name.setValue(nvertex_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_nvertex_name(domain_Ptr domain_hdl, char * nvertex_name, int nvertex_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domain_hdl->nvertex_name.getInheritedValue(), nvertex_name, nvertex_name_size))
+      ERROR("void cxios_get_domain_nvertex_name(domain_Ptr domain_hdl, char * nvertex_name, int nvertex_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_nvertex_name(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->nvertex_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_prec(domain_Ptr domain_hdl, int prec)
   {
Index: XIOS3/trunk/src/interface/c_attr/icdomaingroup_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 2616)
@@ -42,4 +42,54 @@
 
 
+  void cxios_set_domaingroup_area_1d(domaingroup_Ptr domaingroup_hdl, double* area_1d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(area_1d, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->area_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_area_1d(domaingroup_Ptr domaingroup_hdl, double* area_1d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(area_1d, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->area_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_area_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->area_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_area_2d(domaingroup_Ptr domaingroup_hdl, double* area_2d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(area_2d, shape(extent[0], extent[1]), neverDeleteData);
+    domaingroup_hdl->area_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_area_2d(domaingroup_Ptr domaingroup_hdl, double* area_2d, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(area_2d, shape(extent[0], extent[1]), neverDeleteData);
+    tmp=domaingroup_hdl->area_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_area_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->area_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_1d, int* extent)
   {
@@ -194,4 +244,50 @@
 
 
+  void cxios_set_domaingroup_chunking_weight_i(domaingroup_Ptr domaingroup_hdl, double chunking_weight_i)
+  {
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->chunking_weight_i.setValue(chunking_weight_i);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_chunking_weight_i(domaingroup_Ptr domaingroup_hdl, double* chunking_weight_i)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight_i = domaingroup_hdl->chunking_weight_i.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_chunking_weight_i(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->chunking_weight_i.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_chunking_weight_j(domaingroup_Ptr domaingroup_hdl, double chunking_weight_j)
+  {
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->chunking_weight_j.setValue(chunking_weight_j);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_chunking_weight_j(domaingroup_Ptr domaingroup_hdl, double* chunking_weight_j)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_weight_j = domaingroup_hdl->chunking_weight_j.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_chunking_weight_j(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->chunking_weight_j.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_comment(domaingroup_Ptr domaingroup_hdl, const char * comment, int comment_size)
   {
@@ -954,4 +1050,30 @@
 
 
+  void cxios_set_domaingroup_nvertex_name(domaingroup_Ptr domaingroup_hdl, const char * nvertex_name, int nvertex_name_size)
+  {
+    std::string nvertex_name_str;
+    if (!cstr2string(nvertex_name, nvertex_name_size, nvertex_name_str)) return;
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->nvertex_name.setValue(nvertex_name_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_nvertex_name(domaingroup_Ptr domaingroup_hdl, char * nvertex_name, int nvertex_name_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(domaingroup_hdl->nvertex_name.getInheritedValue(), nvertex_name, nvertex_name_size))
+      ERROR("void cxios_get_domaingroup_nvertex_name(domaingroup_Ptr domaingroup_hdl, char * nvertex_name, int nvertex_name_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_nvertex_name(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->nvertex_name.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_prec(domaingroup_Ptr domaingroup_hdl, int prec)
   {
Index: XIOS3/trunk/src/interface/c_attr/icfield_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 2616)
@@ -164,4 +164,27 @@
 
 
+  void cxios_set_field_chunking_blocksize_target(field_Ptr field_hdl, double chunking_blocksize_target)
+  {
+    CTimer::get("XIOS").resume();
+    field_hdl->chunking_blocksize_target.setValue(chunking_blocksize_target);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_chunking_blocksize_target(field_Ptr field_hdl, double* chunking_blocksize_target)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_blocksize_target = field_hdl->chunking_blocksize_target.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_chunking_blocksize_target(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->chunking_blocksize_target.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_field_comment(field_Ptr field_hdl, const char * comment, int comment_size)
   {
@@ -208,4 +231,78 @@
      CTimer::get("XIOS").resume();
      bool isDefined = field_hdl->compression_level.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_field_compression_params(field_Ptr field_hdl, double* compression_params, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(compression_params, shape(extent[0]), neverDeleteData);
+    field_hdl->compression_params.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_compression_params(field_Ptr field_hdl, double* compression_params, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(compression_params, shape(extent[0]), neverDeleteData);
+    tmp=field_hdl->compression_params.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_compression_params(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->compression_params.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_field_compression_type(field_Ptr field_hdl, const char * compression_type, int compression_type_size)
+  {
+    std::string compression_type_str;
+    if (!cstr2string(compression_type, compression_type_size, compression_type_str)) return;
+    CTimer::get("XIOS").resume();
+    field_hdl->compression_type.setValue(compression_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_compression_type(field_Ptr field_hdl, char * compression_type, int compression_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(field_hdl->compression_type.getInheritedValue(), compression_type, compression_type_size))
+      ERROR("void cxios_get_field_compression_type(field_Ptr field_hdl, char * compression_type, int compression_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_compression_type(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->compression_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_field_conversion_by_NetCDF(field_Ptr field_hdl, bool conversion_by_NetCDF)
+  {
+    CTimer::get("XIOS").resume();
+    field_hdl->conversion_by_NetCDF.setValue(conversion_by_NetCDF);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_conversion_by_NetCDF(field_Ptr field_hdl, bool* conversion_by_NetCDF)
+  {
+    CTimer::get("XIOS").resume();
+    *conversion_by_NetCDF = field_hdl->conversion_by_NetCDF.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_conversion_by_NetCDF(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->conversion_by_NetCDF.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
Index: XIOS3/trunk/src/interface/c_attr/icfieldgroup_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 2616)
@@ -164,4 +164,27 @@
 
 
+  void cxios_set_fieldgroup_chunking_blocksize_target(fieldgroup_Ptr fieldgroup_hdl, double chunking_blocksize_target)
+  {
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->chunking_blocksize_target.setValue(chunking_blocksize_target);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_chunking_blocksize_target(fieldgroup_Ptr fieldgroup_hdl, double* chunking_blocksize_target)
+  {
+    CTimer::get("XIOS").resume();
+    *chunking_blocksize_target = fieldgroup_hdl->chunking_blocksize_target.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_chunking_blocksize_target(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->chunking_blocksize_target.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_fieldgroup_comment(fieldgroup_Ptr fieldgroup_hdl, const char * comment, int comment_size)
   {
@@ -208,4 +231,78 @@
      CTimer::get("XIOS").resume();
      bool isDefined = fieldgroup_hdl->compression_level.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_fieldgroup_compression_params(fieldgroup_Ptr fieldgroup_hdl, double* compression_params, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(compression_params, shape(extent[0]), neverDeleteData);
+    fieldgroup_hdl->compression_params.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_compression_params(fieldgroup_Ptr fieldgroup_hdl, double* compression_params, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(compression_params, shape(extent[0]), neverDeleteData);
+    tmp=fieldgroup_hdl->compression_params.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_compression_params(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->compression_params.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_fieldgroup_compression_type(fieldgroup_Ptr fieldgroup_hdl, const char * compression_type, int compression_type_size)
+  {
+    std::string compression_type_str;
+    if (!cstr2string(compression_type, compression_type_size, compression_type_str)) return;
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->compression_type.setValue(compression_type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_compression_type(fieldgroup_Ptr fieldgroup_hdl, char * compression_type, int compression_type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(fieldgroup_hdl->compression_type.getInheritedValue(), compression_type, compression_type_size))
+      ERROR("void cxios_get_fieldgroup_compression_type(fieldgroup_Ptr fieldgroup_hdl, char * compression_type, int compression_type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_compression_type(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->compression_type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_fieldgroup_conversion_by_NetCDF(fieldgroup_Ptr fieldgroup_hdl, bool conversion_by_NetCDF)
+  {
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->conversion_by_NetCDF.setValue(conversion_by_NetCDF);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_conversion_by_NetCDF(fieldgroup_Ptr fieldgroup_hdl, bool* conversion_by_NetCDF)
+  {
+    CTimer::get("XIOS").resume();
+    *conversion_by_NetCDF = fieldgroup_hdl->conversion_by_NetCDF.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_conversion_by_NetCDF(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->conversion_by_NetCDF.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
Index: XIOS3/trunk/src/interface/c_attr/icfile_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 2616)
@@ -239,4 +239,30 @@
 
 
+  void cxios_set_file_gatherer(file_Ptr file_hdl, const char * gatherer, int gatherer_size)
+  {
+    std::string gatherer_str;
+    if (!cstr2string(gatherer, gatherer_size, gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->gatherer.setValue(gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_gatherer(file_Ptr file_hdl, char * gatherer, int gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->gatherer.getInheritedValue(), gatherer, gatherer_size))
+      ERROR("void cxios_get_file_gatherer(file_Ptr file_hdl, char * gatherer, int gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_gatherer(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_min_digits(file_Ptr file_hdl, int min_digits)
   {
@@ -427,4 +453,82 @@
 
 
+  void cxios_set_file_pool_gatherer(file_Ptr file_hdl, const char * pool_gatherer, int pool_gatherer_size)
+  {
+    std::string pool_gatherer_str;
+    if (!cstr2string(pool_gatherer, pool_gatherer_size, pool_gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->pool_gatherer.setValue(pool_gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_pool_gatherer(file_Ptr file_hdl, char * pool_gatherer, int pool_gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->pool_gatherer.getInheritedValue(), pool_gatherer, pool_gatherer_size))
+      ERROR("void cxios_get_file_pool_gatherer(file_Ptr file_hdl, char * pool_gatherer, int pool_gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_pool_gatherer(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->pool_gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_pool_reader(file_Ptr file_hdl, const char * pool_reader, int pool_reader_size)
+  {
+    std::string pool_reader_str;
+    if (!cstr2string(pool_reader, pool_reader_size, pool_reader_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->pool_reader.setValue(pool_reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_pool_reader(file_Ptr file_hdl, char * pool_reader, int pool_reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->pool_reader.getInheritedValue(), pool_reader, pool_reader_size))
+      ERROR("void cxios_get_file_pool_reader(file_Ptr file_hdl, char * pool_reader, int pool_reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_pool_reader(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->pool_reader.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_pool_writer(file_Ptr file_hdl, const char * pool_writer, int pool_writer_size)
+  {
+    std::string pool_writer_str;
+    if (!cstr2string(pool_writer, pool_writer_size, pool_writer_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->pool_writer.setValue(pool_writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_pool_writer(file_Ptr file_hdl, char * pool_writer, int pool_writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->pool_writer.getInheritedValue(), pool_writer, pool_writer_size))
+      ERROR("void cxios_get_file_pool_writer(file_Ptr file_hdl, char * pool_writer, int pool_writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_pool_writer(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->pool_writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_read_metadata_par(file_Ptr file_hdl, bool read_metadata_par)
   {
@@ -445,4 +549,30 @@
      CTimer::get("XIOS").resume();
      bool isDefined = file_hdl->read_metadata_par.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_file_reader(file_Ptr file_hdl, const char * reader, int reader_size)
+  {
+    std::string reader_str;
+    if (!cstr2string(reader, reader_size, reader_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->reader.setValue(reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_reader(file_Ptr file_hdl, char * reader, int reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->reader.getInheritedValue(), reader, reader_size))
+      ERROR("void cxios_get_file_reader(file_Ptr file_hdl, char * reader, int reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_reader(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->reader.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -885,4 +1015,27 @@
 
 
+  void cxios_set_file_using_server2(file_Ptr file_hdl, bool using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    file_hdl->using_server2.setValue(using_server2);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_using_server2(file_Ptr file_hdl, bool* using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    *using_server2 = file_hdl->using_server2.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_using_server2(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->using_server2.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_file_uuid_format(file_Ptr file_hdl, const char * uuid_format, int uuid_format_size)
   {
@@ -935,3 +1088,29 @@
      return isDefined;
   }
+
+
+  void cxios_set_file_writer(file_Ptr file_hdl, const char * writer, int writer_size)
+  {
+    std::string writer_str;
+    if (!cstr2string(writer, writer_size, writer_str)) return;
+    CTimer::get("XIOS").resume();
+    file_hdl->writer.setValue(writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_file_writer(file_Ptr file_hdl, char * writer, int writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(file_hdl->writer.getInheritedValue(), writer, writer_size))
+      ERROR("void cxios_get_file_writer(file_Ptr file_hdl, char * writer, int writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_file_writer(file_Ptr file_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = file_hdl->writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
 }
Index: XIOS3/trunk/src/interface/c_attr/icfilegroup_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 2614)
+++ XIOS3/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 2616)
@@ -239,4 +239,30 @@
 
 
+  void cxios_set_filegroup_gatherer(filegroup_Ptr filegroup_hdl, const char * gatherer, int gatherer_size)
+  {
+    std::string gatherer_str;
+    if (!cstr2string(gatherer, gatherer_size, gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->gatherer.setValue(gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_gatherer(filegroup_Ptr filegroup_hdl, char * gatherer, int gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->gatherer.getInheritedValue(), gatherer, gatherer_size))
+      ERROR("void cxios_get_filegroup_gatherer(filegroup_Ptr filegroup_hdl, char * gatherer, int gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_gatherer(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_group_ref(filegroup_Ptr filegroup_hdl, const char * group_ref, int group_ref_size)
   {
@@ -453,4 +479,82 @@
 
 
+  void cxios_set_filegroup_pool_gatherer(filegroup_Ptr filegroup_hdl, const char * pool_gatherer, int pool_gatherer_size)
+  {
+    std::string pool_gatherer_str;
+    if (!cstr2string(pool_gatherer, pool_gatherer_size, pool_gatherer_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->pool_gatherer.setValue(pool_gatherer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_pool_gatherer(filegroup_Ptr filegroup_hdl, char * pool_gatherer, int pool_gatherer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->pool_gatherer.getInheritedValue(), pool_gatherer, pool_gatherer_size))
+      ERROR("void cxios_get_filegroup_pool_gatherer(filegroup_Ptr filegroup_hdl, char * pool_gatherer, int pool_gatherer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_pool_gatherer(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->pool_gatherer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_pool_reader(filegroup_Ptr filegroup_hdl, const char * pool_reader, int pool_reader_size)
+  {
+    std::string pool_reader_str;
+    if (!cstr2string(pool_reader, pool_reader_size, pool_reader_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->pool_reader.setValue(pool_reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_pool_reader(filegroup_Ptr filegroup_hdl, char * pool_reader, int pool_reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->pool_reader.getInheritedValue(), pool_reader, pool_reader_size))
+      ERROR("void cxios_get_filegroup_pool_reader(filegroup_Ptr filegroup_hdl, char * pool_reader, int pool_reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_pool_reader(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->pool_reader.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_pool_writer(filegroup_Ptr filegroup_hdl, const char * pool_writer, int pool_writer_size)
+  {
+    std::string pool_writer_str;
+    if (!cstr2string(pool_writer, pool_writer_size, pool_writer_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->pool_writer.setValue(pool_writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_pool_writer(filegroup_Ptr filegroup_hdl, char * pool_writer, int pool_writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->pool_writer.getInheritedValue(), pool_writer, pool_writer_size))
+      ERROR("void cxios_get_filegroup_pool_writer(filegroup_Ptr filegroup_hdl, char * pool_writer, int pool_writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_pool_writer(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->pool_writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_read_metadata_par(filegroup_Ptr filegroup_hdl, bool read_metadata_par)
   {
@@ -471,4 +575,30 @@
      CTimer::get("XIOS").resume();
      bool isDefined = filegroup_hdl->read_metadata_par.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_filegroup_reader(filegroup_Ptr filegroup_hdl, const char * reader, int reader_size)
+  {
+    std::string reader_str;
+    if (!cstr2string(reader, reader_size, reader_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->reader.setValue(reader_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_reader(filegroup_Ptr filegroup_hdl, char * reader, int reader_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->reader.getInheritedValue(), reader, reader_size))
+      ERROR("void cxios_get_filegroup_reader(filegroup_Ptr filegroup_hdl, char * reader, int reader_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_reader(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->reader.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -911,4 +1041,27 @@
 
 
+  void cxios_set_filegroup_using_server2(filegroup_Ptr filegroup_hdl, bool using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->using_server2.setValue(using_server2);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_using_server2(filegroup_Ptr filegroup_hdl, bool* using_server2)
+  {
+    CTimer::get("XIOS").resume();
+    *using_server2 = filegroup_hdl->using_server2.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_using_server2(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->using_server2.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_filegroup_uuid_format(filegroup_Ptr filegroup_hdl, const char * uuid_format, int uuid_format_size)
   {
@@ -961,3 +1114,29 @@
      return isDefined;
   }
+
+
+  void cxios_set_filegroup_writer(filegroup_Ptr filegroup_hdl, const char * writer, int writer_size)
+  {
+    std::string writer_str;
+    if (!cstr2string(writer, writer_size, writer_str)) return;
+    CTimer::get("XIOS").resume();
+    filegroup_hdl->writer.setValue(writer_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_filegroup_writer(filegroup_Ptr filegroup_hdl, char * writer, int writer_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(filegroup_hdl->writer.getInheritedValue(), writer, writer_size))
+      ERROR("void cxios_get_filegroup_writer(filegroup_Ptr filegroup_hdl, char * writer, int writer_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_filegroup_writer(filegroup_Ptr filegroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = filegroup_hdl->writer.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
 }
Index: XIOS3/trunk/src/interface/c_attr/icredistribute_axis_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icredistribute_axis_attr.cpp	(revision 2616)
+++ XIOS3/trunk/src/interface/c_attr/icredistribute_axis_attr.cpp	(revision 2616)
@@ -0,0 +1,93 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.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::CRedistributeAxis* redistribute_axis_Ptr;
+
+  void cxios_set_redistribute_axis_index(redistribute_axis_Ptr redistribute_axis_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    redistribute_axis_hdl->index.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_axis_index(redistribute_axis_Ptr redistribute_axis_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_axis_hdl->index.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_axis_index(redistribute_axis_Ptr redistribute_axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_axis_hdl->index.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_axis_mask(redistribute_axis_Ptr redistribute_axis_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    redistribute_axis_hdl->mask.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_axis_mask(redistribute_axis_Ptr redistribute_axis_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_axis_hdl->mask.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_axis_mask(redistribute_axis_Ptr redistribute_axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_axis_hdl->mask.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_axis_type(redistribute_axis_Ptr redistribute_axis_hdl, const char * type, int type_size)
+  {
+    std::string type_str;
+    if (!cstr2string(type, type_size, type_str)) return;
+    CTimer::get("XIOS").resume();
+    redistribute_axis_hdl->type.fromString(type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_axis_type(redistribute_axis_Ptr redistribute_axis_hdl, char * type, int type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(redistribute_axis_hdl->type.getInheritedStringValue(), type, type_size))
+      ERROR("void cxios_get_redistribute_axis_type(redistribute_axis_Ptr redistribute_axis_hdl, char * type, int type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_axis_type(redistribute_axis_Ptr redistribute_axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_axis_hdl->type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS3/trunk/src/interface/c_attr/icredistribute_domain_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icredistribute_domain_attr.cpp	(revision 2616)
+++ XIOS3/trunk/src/interface/c_attr/icredistribute_domain_attr.cpp	(revision 2616)
@@ -0,0 +1,93 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.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::CRedistributeDomain* redistribute_domain_Ptr;
+
+  void cxios_set_redistribute_domain_index(redistribute_domain_Ptr redistribute_domain_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    redistribute_domain_hdl->index.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_domain_index(redistribute_domain_Ptr redistribute_domain_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_domain_hdl->index.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_domain_index(redistribute_domain_Ptr redistribute_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_domain_hdl->index.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_domain_mask(redistribute_domain_Ptr redistribute_domain_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    redistribute_domain_hdl->mask.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_domain_mask(redistribute_domain_Ptr redistribute_domain_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_domain_hdl->mask.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_domain_mask(redistribute_domain_Ptr redistribute_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_domain_hdl->mask.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_domain_type(redistribute_domain_Ptr redistribute_domain_hdl, const char * type, int type_size)
+  {
+    std::string type_str;
+    if (!cstr2string(type, type_size, type_str)) return;
+    CTimer::get("XIOS").resume();
+    redistribute_domain_hdl->type.fromString(type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_domain_type(redistribute_domain_Ptr redistribute_domain_hdl, char * type, int type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(redistribute_domain_hdl->type.getInheritedStringValue(), type, type_size))
+      ERROR("void cxios_get_redistribute_domain_type(redistribute_domain_Ptr redistribute_domain_hdl, char * type, int type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_domain_type(redistribute_domain_Ptr redistribute_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_domain_hdl->type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS3/trunk/src/interface/c_attr/icredistribute_scalar_attr.cpp
===================================================================
--- XIOS3/trunk/src/interface/c_attr/icredistribute_scalar_attr.cpp	(revision 2616)
+++ XIOS3/trunk/src/interface/c_attr/icredistribute_scalar_attr.cpp	(revision 2616)
@@ -0,0 +1,93 @@
+/* ************************************************************************** *
+ *               Interface auto generated - do not modify                     *
+ * ************************************************************************** */
+
+#include <boost/multi_array.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::CRedistributeScalar* redistribute_scalar_Ptr;
+
+  void cxios_set_redistribute_scalar_index(redistribute_scalar_Ptr redistribute_scalar_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    redistribute_scalar_hdl->index.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_scalar_index(redistribute_scalar_Ptr redistribute_scalar_hdl, int* index, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(index, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_scalar_hdl->index.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_scalar_index(redistribute_scalar_Ptr redistribute_scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_scalar_hdl->index.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_scalar_mask(redistribute_scalar_Ptr redistribute_scalar_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    redistribute_scalar_hdl->mask.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_scalar_mask(redistribute_scalar_Ptr redistribute_scalar_hdl, bool* mask, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask, shape(extent[0]), neverDeleteData);
+    tmp=redistribute_scalar_hdl->mask.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_scalar_mask(redistribute_scalar_Ptr redistribute_scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_scalar_hdl->mask.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_redistribute_scalar_type(redistribute_scalar_Ptr redistribute_scalar_hdl, const char * type, int type_size)
+  {
+    std::string type_str;
+    if (!cstr2string(type, type_size, type_str)) return;
+    CTimer::get("XIOS").resume();
+    redistribute_scalar_hdl->type.fromString(type_str);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_redistribute_scalar_type(redistribute_scalar_Ptr redistribute_scalar_hdl, char * type, int type_size)
+  {
+    CTimer::get("XIOS").resume();
+    if (!string_copy(redistribute_scalar_hdl->type.getInheritedStringValue(), type, type_size))
+      ERROR("void cxios_get_redistribute_scalar_type(redistribute_scalar_Ptr redistribute_scalar_hdl, char * type, int type_size)", << "Input string is too short");
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_redistribute_scalar_type(redistribute_scalar_Ptr redistribute_scalar_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = redistribute_scalar_hdl->type.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+}
Index: XIOS3/trunk/src/interface/fortran/iredistribute_axis.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran/iredistribute_axis.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/iredistribute_axis.F90	(revision 2616)
@@ -0,0 +1,30 @@
+#include "xios_fortran_prefix.hpp"
+
+MODULE IREDISTRIBUTE_AXIS
+   USE, INTRINSIC :: ISO_C_BINDING
+   USE REDISTRIBUTE_AXIS_INTERFACE
+
+   TYPE txios(redistribute_axis)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(redistribute_axis)
+
+   CONTAINS ! Fonctions disponibles pour les utilisateurs.
+
+   SUBROUTINE xios(get_redistribute_axis_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *), INTENT(IN) :: idt
+      TYPE(txios(redistribute_axis)) , INTENT(OUT):: ret
+      CALL cxios_redistribute_axis_handle_create(ret%daddr, idt, len(idt))
+   END SUBROUTINE xios(get_redistribute_axis_handle)
+
+   LOGICAL FUNCTION xios(is_valid_redistribute_axis)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_redistribute_axis_valid_id(val, idt, len(idt))
+      xios(is_valid_redistribute_axis) = val
+
+   END FUNCTION  xios(is_valid_redistribute_axis)
+
+END MODULE IREDISTRIBUTE_AXIS
Index: XIOS3/trunk/src/interface/fortran/iredistribute_domain.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran/iredistribute_domain.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/iredistribute_domain.F90	(revision 2616)
@@ -0,0 +1,30 @@
+#include "xios_fortran_prefix.hpp"
+
+MODULE IREDISTRIBUTE_DOMAIN
+   USE, INTRINSIC :: ISO_C_BINDING
+   USE REDISTRIBUTE_DOMAIN_INTERFACE
+
+   TYPE txios(redistribute_domain)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(redistribute_domain)
+
+   CONTAINS ! Fonctions disponibles pour les utilisateurs.
+
+   SUBROUTINE xios(get_redistribute_domain_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *), INTENT(IN) :: idt
+      TYPE(txios(redistribute_domain)) , INTENT(OUT):: ret
+      CALL cxios_redistribute_domain_handle_create(ret%daddr, idt, len(idt))
+   END SUBROUTINE xios(get_redistribute_domain_handle)
+
+   LOGICAL FUNCTION xios(is_valid_redistribute_domain)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_redistribute_domain_valid_id(val, idt, len(idt))
+      xios(is_valid_redistribute_domain) = val
+
+   END FUNCTION  xios(is_valid_redistribute_domain)
+
+END MODULE IREDISTRIBUTE_DOMAIN
Index: XIOS3/trunk/src/interface/fortran/iredistribute_scalar.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran/iredistribute_scalar.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/iredistribute_scalar.F90	(revision 2616)
@@ -0,0 +1,30 @@
+#include "xios_fortran_prefix.hpp"
+
+MODULE IREDISTRIBUTE_SCALAR
+   USE, INTRINSIC :: ISO_C_BINDING
+   USE REDISTRIBUTE_SCALAR_INTERFACE
+
+   TYPE txios(redistribute_scalar)
+      INTEGER(kind = C_INTPTR_T) :: daddr
+   END TYPE txios(redistribute_scalar)
+
+   CONTAINS ! Fonctions disponibles pour les utilisateurs.
+
+   SUBROUTINE xios(get_redistribute_scalar_handle)(idt,ret)
+      IMPLICIT NONE
+      CHARACTER(len = *), INTENT(IN) :: idt
+      TYPE(txios(redistribute_scalar)) , INTENT(OUT):: ret
+      CALL cxios_redistribute_scalar_handle_create(ret%daddr, idt, len(idt))
+   END SUBROUTINE xios(get_redistribute_scalar_handle)
+
+   LOGICAL FUNCTION xios(is_valid_redistribute_scalar)(idt)
+      IMPLICIT NONE
+      CHARACTER(len  = *)    , INTENT(IN) :: idt
+      LOGICAL  (kind = 1)                 :: val
+
+      CALL cxios_redistribute_scalar_valid_id(val, idt, len(idt))
+      xios(is_valid_redistribute_scalar) = val
+
+   END FUNCTION  xios(is_valid_redistribute_scalar)
+
+END MODULE IREDISTRIBUTE_SCALAR
Index: XIOS3/trunk/src/interface/fortran/redistribute_axis_interface.f90
===================================================================
--- XIOS3/trunk/src/interface/fortran/redistribute_axis_interface.f90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/redistribute_axis_interface.f90	(revision 2616)
@@ -0,0 +1,22 @@
+MODULE REDISTRIBUTE_AXIS_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+      SUBROUTINE cxios_redistribute_axis_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_redistribute_axis_handle_create
+
+      SUBROUTINE cxios_redistribute_axis_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_redistribute_axis_valid_id
+
+   END INTERFACE
+
+END MODULE REDISTRIBUTE_AXIS_INTERFACE
Index: XIOS3/trunk/src/interface/fortran/redistribute_domain_interface.f90
===================================================================
--- XIOS3/trunk/src/interface/fortran/redistribute_domain_interface.f90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/redistribute_domain_interface.f90	(revision 2616)
@@ -0,0 +1,22 @@
+MODULE REDISTRIBUTE_DOMAIN_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+      SUBROUTINE cxios_redistribute_domain_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_redistribute_domain_handle_create
+
+      SUBROUTINE cxios_redistribute_domain_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_redistribute_domain_valid_id
+
+   END INTERFACE
+
+END MODULE REDISTRIBUTE_DOMAIN_INTERFACE
Index: XIOS3/trunk/src/interface/fortran/redistribute_scalar_interface.f90
===================================================================
--- XIOS3/trunk/src/interface/fortran/redistribute_scalar_interface.f90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran/redistribute_scalar_interface.f90	(revision 2616)
@@ -0,0 +1,22 @@
+MODULE REDISTRIBUTE_SCALAR_INTERFACE
+   USE, INTRINSIC :: ISO_C_BINDING
+
+   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99
+
+      SUBROUTINE cxios_redistribute_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_redistribute_scalar_handle_create
+
+      SUBROUTINE cxios_redistribute_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_redistribute_scalar_valid_id
+
+   END INTERFACE
+
+END MODULE REDISTRIBUTE_SCALAR_INTERFACE
Index: XIOS3/trunk/src/interface/fortran_attr/axis_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 2616)
@@ -113,4 +113,23 @@
 
 
+    SUBROUTINE cxios_set_axis_chunking_weight(axis_hdl, chunking_weight) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight
+    END SUBROUTINE cxios_set_axis_chunking_weight
+
+    SUBROUTINE cxios_get_axis_chunking_weight(axis_hdl, chunking_weight) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight
+    END SUBROUTINE cxios_get_axis_chunking_weight
+
+    FUNCTION cxios_is_defined_axis_chunking_weight(axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_chunking_weight
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_chunking_weight
+
+
     SUBROUTINE cxios_set_axis_comment(axis_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 2616)
@@ -113,4 +113,23 @@
 
 
+    SUBROUTINE cxios_set_axisgroup_chunking_weight(axisgroup_hdl, chunking_weight) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight
+    END SUBROUTINE cxios_set_axisgroup_chunking_weight
+
+    SUBROUTINE cxios_get_axisgroup_chunking_weight(axisgroup_hdl, chunking_weight) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight
+    END SUBROUTINE cxios_get_axisgroup_chunking_weight
+
+    FUNCTION cxios_is_defined_axisgroup_chunking_weight(axisgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_chunking_weight
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_chunking_weight
+
+
     SUBROUTINE cxios_set_axisgroup_comment(axisgroup_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/context_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/context_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/context_interface_attr.F90	(revision 2616)
@@ -29,4 +29,170 @@
 
 
+    SUBROUTINE cxios_set_context_default_gatherer(context_hdl, default_gatherer, default_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_gatherer_size
+    END SUBROUTINE cxios_set_context_default_gatherer
+
+    SUBROUTINE cxios_get_context_default_gatherer(context_hdl, default_gatherer, default_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_gatherer_size
+    END SUBROUTINE cxios_get_context_default_gatherer
+
+    FUNCTION cxios_is_defined_context_default_gatherer(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_gatherer
+
+
+    SUBROUTINE cxios_set_context_default_pool(context_hdl, default_pool, default_pool_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_size
+    END SUBROUTINE cxios_set_context_default_pool
+
+    SUBROUTINE cxios_get_context_default_pool(context_hdl, default_pool, default_pool_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_size
+    END SUBROUTINE cxios_get_context_default_pool
+
+    FUNCTION cxios_is_defined_context_default_pool(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_pool
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_pool
+
+
+    SUBROUTINE cxios_set_context_default_pool_gatherer(context_hdl, default_pool_gatherer, default_pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_gatherer_size
+    END SUBROUTINE cxios_set_context_default_pool_gatherer
+
+    SUBROUTINE cxios_get_context_default_pool_gatherer(context_hdl, default_pool_gatherer, default_pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_gatherer_size
+    END SUBROUTINE cxios_get_context_default_pool_gatherer
+
+    FUNCTION cxios_is_defined_context_default_pool_gatherer(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_pool_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_pool_gatherer
+
+
+    SUBROUTINE cxios_set_context_default_pool_reader(context_hdl, default_pool_reader, default_pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_reader_size
+    END SUBROUTINE cxios_set_context_default_pool_reader
+
+    SUBROUTINE cxios_get_context_default_pool_reader(context_hdl, default_pool_reader, default_pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_reader_size
+    END SUBROUTINE cxios_get_context_default_pool_reader
+
+    FUNCTION cxios_is_defined_context_default_pool_reader(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_pool_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_pool_reader
+
+
+    SUBROUTINE cxios_set_context_default_pool_writer(context_hdl, default_pool_writer, default_pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_writer_size
+    END SUBROUTINE cxios_set_context_default_pool_writer
+
+    SUBROUTINE cxios_get_context_default_pool_writer(context_hdl, default_pool_writer, default_pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_pool_writer_size
+    END SUBROUTINE cxios_get_context_default_pool_writer
+
+    FUNCTION cxios_is_defined_context_default_pool_writer(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_pool_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_pool_writer
+
+
+    SUBROUTINE cxios_set_context_default_reader(context_hdl, default_reader, default_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: default_reader_size
+    END SUBROUTINE cxios_set_context_default_reader
+
+    SUBROUTINE cxios_get_context_default_reader(context_hdl, default_reader, default_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: default_reader_size
+    END SUBROUTINE cxios_get_context_default_reader
+
+    FUNCTION cxios_is_defined_context_default_reader(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_reader
+
+
+    SUBROUTINE cxios_set_context_default_using_server2(context_hdl, default_using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: default_using_server2
+    END SUBROUTINE cxios_set_context_default_using_server2
+
+    SUBROUTINE cxios_get_context_default_using_server2(context_hdl, default_using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      LOGICAL (KIND=C_BOOL)             :: default_using_server2
+    END SUBROUTINE cxios_get_context_default_using_server2
+
+    FUNCTION cxios_is_defined_context_default_using_server2(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_using_server2
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_using_server2
+
+
+    SUBROUTINE cxios_set_context_default_writer(context_hdl, default_writer, default_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_writer_size
+    END SUBROUTINE cxios_set_context_default_writer
+
+    SUBROUTINE cxios_get_context_default_writer(context_hdl, default_writer, default_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: default_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: default_writer_size
+    END SUBROUTINE cxios_get_context_default_writer
+
+    FUNCTION cxios_is_defined_context_default_writer(context_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_context_default_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: context_hdl
+    END FUNCTION cxios_is_defined_context_default_writer
+
+
     SUBROUTINE cxios_set_context_output_dir(context_hdl, output_dir, output_dir_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/domain_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 2616)
@@ -31,4 +31,46 @@
 
 
+    SUBROUTINE cxios_set_domain_area_1d(domain_hdl, area_1d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_1d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_area_1d
+
+    SUBROUTINE cxios_get_domain_area_1d(domain_hdl, area_1d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_1d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_area_1d
+
+    FUNCTION cxios_is_defined_domain_area_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_area_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_area_1d
+
+
+    SUBROUTINE cxios_set_domain_area_2d(domain_hdl, area_2d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_2d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_area_2d
+
+    SUBROUTINE cxios_get_domain_area_2d(domain_hdl, area_2d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_2d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_area_2d
+
+    FUNCTION cxios_is_defined_domain_area_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_area_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_area_2d
+
+
     SUBROUTINE cxios_set_domain_bounds_lat_1d(domain_hdl, bounds_lat_1d, extent) BIND(C)
       USE ISO_C_BINDING
@@ -157,4 +199,42 @@
 
 
+    SUBROUTINE cxios_set_domain_chunking_weight_i(domain_hdl, chunking_weight_i) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight_i
+    END SUBROUTINE cxios_set_domain_chunking_weight_i
+
+    SUBROUTINE cxios_get_domain_chunking_weight_i(domain_hdl, chunking_weight_i) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight_i
+    END SUBROUTINE cxios_get_domain_chunking_weight_i
+
+    FUNCTION cxios_is_defined_domain_chunking_weight_i(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_chunking_weight_i
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_chunking_weight_i
+
+
+    SUBROUTINE cxios_set_domain_chunking_weight_j(domain_hdl, chunking_weight_j) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight_j
+    END SUBROUTINE cxios_set_domain_chunking_weight_j
+
+    SUBROUTINE cxios_get_domain_chunking_weight_j(domain_hdl, chunking_weight_j) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight_j
+    END SUBROUTINE cxios_get_domain_chunking_weight_j
+
+    FUNCTION cxios_is_defined_domain_chunking_weight_j(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_chunking_weight_j
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_chunking_weight_j
+
+
     SUBROUTINE cxios_set_domain_comment(domain_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
@@ -763,4 +843,25 @@
 
 
+    SUBROUTINE cxios_set_domain_nvertex_name(domain_hdl, nvertex_name, nvertex_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: nvertex_name
+      INTEGER  (kind = C_INT)     , VALUE        :: nvertex_name_size
+    END SUBROUTINE cxios_set_domain_nvertex_name
+
+    SUBROUTINE cxios_get_domain_nvertex_name(domain_hdl, nvertex_name, nvertex_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: nvertex_name
+      INTEGER  (kind = C_INT)     , VALUE        :: nvertex_name_size
+    END SUBROUTINE cxios_get_domain_nvertex_name
+
+    FUNCTION cxios_is_defined_domain_nvertex_name(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_nvertex_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_nvertex_name
+
+
     SUBROUTINE cxios_set_domain_prec(domain_hdl, prec) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 2616)
@@ -31,4 +31,46 @@
 
 
+    SUBROUTINE cxios_set_domaingroup_area_1d(domaingroup_hdl, area_1d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_1d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_area_1d
+
+    SUBROUTINE cxios_get_domaingroup_area_1d(domaingroup_hdl, area_1d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_1d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_area_1d
+
+    FUNCTION cxios_is_defined_domaingroup_area_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_area_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_area_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_area_2d(domaingroup_hdl, area_2d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_2d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_area_2d
+
+    SUBROUTINE cxios_get_domaingroup_area_2d(domaingroup_hdl, area_2d, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: area_2d
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_area_2d
+
+    FUNCTION cxios_is_defined_domaingroup_area_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_area_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_area_2d
+
+
     SUBROUTINE cxios_set_domaingroup_bounds_lat_1d(domaingroup_hdl, bounds_lat_1d, extent) BIND(C)
       USE ISO_C_BINDING
@@ -157,4 +199,42 @@
 
 
+    SUBROUTINE cxios_set_domaingroup_chunking_weight_i(domaingroup_hdl, chunking_weight_i) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight_i
+    END SUBROUTINE cxios_set_domaingroup_chunking_weight_i
+
+    SUBROUTINE cxios_get_domaingroup_chunking_weight_i(domaingroup_hdl, chunking_weight_i) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight_i
+    END SUBROUTINE cxios_get_domaingroup_chunking_weight_i
+
+    FUNCTION cxios_is_defined_domaingroup_chunking_weight_i(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_chunking_weight_i
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_chunking_weight_i
+
+
+    SUBROUTINE cxios_set_domaingroup_chunking_weight_j(domaingroup_hdl, chunking_weight_j) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_weight_j
+    END SUBROUTINE cxios_set_domaingroup_chunking_weight_j
+
+    SUBROUTINE cxios_get_domaingroup_chunking_weight_j(domaingroup_hdl, chunking_weight_j) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_weight_j
+    END SUBROUTINE cxios_get_domaingroup_chunking_weight_j
+
+    FUNCTION cxios_is_defined_domaingroup_chunking_weight_j(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_chunking_weight_j
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_chunking_weight_j
+
+
     SUBROUTINE cxios_set_domaingroup_comment(domaingroup_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
@@ -784,4 +864,25 @@
 
 
+    SUBROUTINE cxios_set_domaingroup_nvertex_name(domaingroup_hdl, nvertex_name, nvertex_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: nvertex_name
+      INTEGER  (kind = C_INT)     , VALUE        :: nvertex_name_size
+    END SUBROUTINE cxios_set_domaingroup_nvertex_name
+
+    SUBROUTINE cxios_get_domaingroup_nvertex_name(domaingroup_hdl, nvertex_name, nvertex_name_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: nvertex_name
+      INTEGER  (kind = C_INT)     , VALUE        :: nvertex_name_size
+    END SUBROUTINE cxios_get_domaingroup_nvertex_name
+
+    FUNCTION cxios_is_defined_domaingroup_nvertex_name(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_nvertex_name
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_nvertex_name
+
+
     SUBROUTINE cxios_set_domaingroup_prec(domaingroup_hdl, prec) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/field_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/field_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/field_interface_attr.F90	(revision 2616)
@@ -130,4 +130,23 @@
 
 
+    SUBROUTINE cxios_set_field_chunking_blocksize_target(field_hdl, chunking_blocksize_target) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_blocksize_target
+    END SUBROUTINE cxios_set_field_chunking_blocksize_target
+
+    SUBROUTINE cxios_get_field_chunking_blocksize_target(field_hdl, chunking_blocksize_target) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_blocksize_target
+    END SUBROUTINE cxios_get_field_chunking_blocksize_target
+
+    FUNCTION cxios_is_defined_field_chunking_blocksize_target(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_chunking_blocksize_target
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_chunking_blocksize_target
+
+
     SUBROUTINE cxios_set_field_comment(field_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
@@ -170,4 +189,65 @@
 
 
+    SUBROUTINE cxios_set_field_compression_params(field_hdl, compression_params, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: field_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: compression_params
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_field_compression_params
+
+    SUBROUTINE cxios_get_field_compression_params(field_hdl, compression_params, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: field_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: compression_params
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_field_compression_params
+
+    FUNCTION cxios_is_defined_field_compression_params(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_compression_params
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_compression_params
+
+
+    SUBROUTINE cxios_set_field_compression_type(field_hdl, compression_type, compression_type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: compression_type
+      INTEGER  (kind = C_INT)     , VALUE        :: compression_type_size
+    END SUBROUTINE cxios_set_field_compression_type
+
+    SUBROUTINE cxios_get_field_compression_type(field_hdl, compression_type, compression_type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: compression_type
+      INTEGER  (kind = C_INT)     , VALUE        :: compression_type_size
+    END SUBROUTINE cxios_get_field_compression_type
+
+    FUNCTION cxios_is_defined_field_compression_type(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_compression_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_compression_type
+
+
+    SUBROUTINE cxios_set_field_conversion_by_NetCDF(field_hdl, conversion_by_NetCDF) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: conversion_by_NetCDF
+    END SUBROUTINE cxios_set_field_conversion_by_NetCDF
+
+    SUBROUTINE cxios_get_field_conversion_by_NetCDF(field_hdl, conversion_by_NetCDF) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      LOGICAL (KIND=C_BOOL)             :: conversion_by_NetCDF
+    END SUBROUTINE cxios_get_field_conversion_by_NetCDF
+
+    FUNCTION cxios_is_defined_field_conversion_by_NetCDF(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_conversion_by_NetCDF
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_conversion_by_NetCDF
+
+
     SUBROUTINE cxios_set_field_default_value(field_hdl, default_value) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/fieldgroup_interface_attr.F90	(revision 2616)
@@ -130,4 +130,23 @@
 
 
+    SUBROUTINE cxios_set_fieldgroup_chunking_blocksize_target(fieldgroup_hdl, chunking_blocksize_target) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      REAL (KIND=C_DOUBLE)      , VALUE :: chunking_blocksize_target
+    END SUBROUTINE cxios_set_fieldgroup_chunking_blocksize_target
+
+    SUBROUTINE cxios_get_fieldgroup_chunking_blocksize_target(fieldgroup_hdl, chunking_blocksize_target) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      REAL (KIND=C_DOUBLE)             :: chunking_blocksize_target
+    END SUBROUTINE cxios_get_fieldgroup_chunking_blocksize_target
+
+    FUNCTION cxios_is_defined_fieldgroup_chunking_blocksize_target(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_chunking_blocksize_target
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_chunking_blocksize_target
+
+
     SUBROUTINE cxios_set_fieldgroup_comment(fieldgroup_hdl, comment, comment_size) BIND(C)
       USE ISO_C_BINDING
@@ -170,4 +189,65 @@
 
 
+    SUBROUTINE cxios_set_fieldgroup_compression_params(fieldgroup_hdl, compression_params, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: fieldgroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: compression_params
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_fieldgroup_compression_params
+
+    SUBROUTINE cxios_get_fieldgroup_compression_params(fieldgroup_hdl, compression_params, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: fieldgroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: compression_params
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_fieldgroup_compression_params
+
+    FUNCTION cxios_is_defined_fieldgroup_compression_params(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_compression_params
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_compression_params
+
+
+    SUBROUTINE cxios_set_fieldgroup_compression_type(fieldgroup_hdl, compression_type, compression_type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: compression_type
+      INTEGER  (kind = C_INT)     , VALUE        :: compression_type_size
+    END SUBROUTINE cxios_set_fieldgroup_compression_type
+
+    SUBROUTINE cxios_get_fieldgroup_compression_type(fieldgroup_hdl, compression_type, compression_type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: compression_type
+      INTEGER  (kind = C_INT)     , VALUE        :: compression_type_size
+    END SUBROUTINE cxios_get_fieldgroup_compression_type
+
+    FUNCTION cxios_is_defined_fieldgroup_compression_type(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_compression_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_compression_type
+
+
+    SUBROUTINE cxios_set_fieldgroup_conversion_by_NetCDF(fieldgroup_hdl, conversion_by_NetCDF) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: conversion_by_NetCDF
+    END SUBROUTINE cxios_set_fieldgroup_conversion_by_NetCDF
+
+    SUBROUTINE cxios_get_fieldgroup_conversion_by_NetCDF(fieldgroup_hdl, conversion_by_NetCDF) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      LOGICAL (KIND=C_BOOL)             :: conversion_by_NetCDF
+    END SUBROUTINE cxios_get_fieldgroup_conversion_by_NetCDF
+
+    FUNCTION cxios_is_defined_fieldgroup_conversion_by_NetCDF(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_conversion_by_NetCDF
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_conversion_by_NetCDF
+
+
     SUBROUTINE cxios_set_fieldgroup_default_value(fieldgroup_hdl, default_value) BIND(C)
       USE ISO_C_BINDING
Index: XIOS3/trunk/src/interface/fortran_attr/file_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/file_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/file_interface_attr.F90	(revision 2616)
@@ -191,4 +191,25 @@
 
 
+    SUBROUTINE cxios_set_file_gatherer(file_hdl, gatherer, gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: gatherer_size
+    END SUBROUTINE cxios_set_file_gatherer
+
+    SUBROUTINE cxios_get_file_gatherer(file_hdl, gatherer, gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: gatherer_size
+    END SUBROUTINE cxios_get_file_gatherer
+
+    FUNCTION cxios_is_defined_file_gatherer(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_gatherer
+
+
     SUBROUTINE cxios_set_file_min_digits(file_hdl, min_digits) BIND(C)
       USE ISO_C_BINDING
@@ -334,4 +355,67 @@
 
 
+    SUBROUTINE cxios_set_file_pool_gatherer(file_hdl, pool_gatherer, pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_gatherer_size
+    END SUBROUTINE cxios_set_file_pool_gatherer
+
+    SUBROUTINE cxios_get_file_pool_gatherer(file_hdl, pool_gatherer, pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_gatherer_size
+    END SUBROUTINE cxios_get_file_pool_gatherer
+
+    FUNCTION cxios_is_defined_file_pool_gatherer(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_pool_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_pool_gatherer
+
+
+    SUBROUTINE cxios_set_file_pool_reader(file_hdl, pool_reader, pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_reader_size
+    END SUBROUTINE cxios_set_file_pool_reader
+
+    SUBROUTINE cxios_get_file_pool_reader(file_hdl, pool_reader, pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_reader_size
+    END SUBROUTINE cxios_get_file_pool_reader
+
+    FUNCTION cxios_is_defined_file_pool_reader(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_pool_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_pool_reader
+
+
+    SUBROUTINE cxios_set_file_pool_writer(file_hdl, pool_writer, pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_writer_size
+    END SUBROUTINE cxios_set_file_pool_writer
+
+    SUBROUTINE cxios_get_file_pool_writer(file_hdl, pool_writer, pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_writer_size
+    END SUBROUTINE cxios_get_file_pool_writer
+
+    FUNCTION cxios_is_defined_file_pool_writer(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_pool_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_pool_writer
+
+
     SUBROUTINE cxios_set_file_read_metadata_par(file_hdl, read_metadata_par) BIND(C)
       USE ISO_C_BINDING
@@ -351,4 +435,25 @@
       INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
     END FUNCTION cxios_is_defined_file_read_metadata_par
+
+
+    SUBROUTINE cxios_set_file_reader(file_hdl, reader, reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: reader
+      INTEGER  (kind = C_INT)     , VALUE        :: reader_size
+    END SUBROUTINE cxios_set_file_reader
+
+    SUBROUTINE cxios_get_file_reader(file_hdl, reader, reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: reader
+      INTEGER  (kind = C_INT)     , VALUE        :: reader_size
+    END SUBROUTINE cxios_get_file_reader
+
+    FUNCTION cxios_is_defined_file_reader(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_reader
 
 
@@ -666,4 +771,23 @@
 
 
+    SUBROUTINE cxios_set_file_using_server2(file_hdl, using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: using_server2
+    END SUBROUTINE cxios_set_file_using_server2
+
+    SUBROUTINE cxios_get_file_using_server2(file_hdl, using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      LOGICAL (KIND=C_BOOL)             :: using_server2
+    END SUBROUTINE cxios_get_file_using_server2
+
+    FUNCTION cxios_is_defined_file_using_server2(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_using_server2
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_using_server2
+
+
     SUBROUTINE cxios_set_file_uuid_format(file_hdl, uuid_format, uuid_format_size) BIND(C)
       USE ISO_C_BINDING
@@ -707,4 +831,25 @@
     END FUNCTION cxios_is_defined_file_uuid_name
 
+
+    SUBROUTINE cxios_set_file_writer(file_hdl, writer, writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: writer
+      INTEGER  (kind = C_INT)     , VALUE        :: writer_size
+    END SUBROUTINE cxios_set_file_writer
+
+    SUBROUTINE cxios_get_file_writer(file_hdl, writer, writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: writer
+      INTEGER  (kind = C_INT)     , VALUE        :: writer_size
+    END SUBROUTINE cxios_get_file_writer
+
+    FUNCTION cxios_is_defined_file_writer(file_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_file_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: file_hdl
+    END FUNCTION cxios_is_defined_file_writer
+
   END INTERFACE
 
Index: XIOS3/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/filegroup_interface_attr.F90	(revision 2616)
@@ -191,4 +191,25 @@
 
 
+    SUBROUTINE cxios_set_filegroup_gatherer(filegroup_hdl, gatherer, gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: gatherer_size
+    END SUBROUTINE cxios_set_filegroup_gatherer
+
+    SUBROUTINE cxios_get_filegroup_gatherer(filegroup_hdl, gatherer, gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: gatherer_size
+    END SUBROUTINE cxios_get_filegroup_gatherer
+
+    FUNCTION cxios_is_defined_filegroup_gatherer(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_gatherer
+
+
     SUBROUTINE cxios_set_filegroup_group_ref(filegroup_hdl, group_ref, group_ref_size) BIND(C)
       USE ISO_C_BINDING
@@ -355,4 +376,67 @@
 
 
+    SUBROUTINE cxios_set_filegroup_pool_gatherer(filegroup_hdl, pool_gatherer, pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_gatherer_size
+    END SUBROUTINE cxios_set_filegroup_pool_gatherer
+
+    SUBROUTINE cxios_get_filegroup_pool_gatherer(filegroup_hdl, pool_gatherer, pool_gatherer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_gatherer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_gatherer_size
+    END SUBROUTINE cxios_get_filegroup_pool_gatherer
+
+    FUNCTION cxios_is_defined_filegroup_pool_gatherer(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_pool_gatherer
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_pool_gatherer
+
+
+    SUBROUTINE cxios_set_filegroup_pool_reader(filegroup_hdl, pool_reader, pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_reader_size
+    END SUBROUTINE cxios_set_filegroup_pool_reader
+
+    SUBROUTINE cxios_get_filegroup_pool_reader(filegroup_hdl, pool_reader, pool_reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_reader
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_reader_size
+    END SUBROUTINE cxios_get_filegroup_pool_reader
+
+    FUNCTION cxios_is_defined_filegroup_pool_reader(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_pool_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_pool_reader
+
+
+    SUBROUTINE cxios_set_filegroup_pool_writer(filegroup_hdl, pool_writer, pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_writer_size
+    END SUBROUTINE cxios_set_filegroup_pool_writer
+
+    SUBROUTINE cxios_get_filegroup_pool_writer(filegroup_hdl, pool_writer, pool_writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: pool_writer
+      INTEGER  (kind = C_INT)     , VALUE        :: pool_writer_size
+    END SUBROUTINE cxios_get_filegroup_pool_writer
+
+    FUNCTION cxios_is_defined_filegroup_pool_writer(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_pool_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_pool_writer
+
+
     SUBROUTINE cxios_set_filegroup_read_metadata_par(filegroup_hdl, read_metadata_par) BIND(C)
       USE ISO_C_BINDING
@@ -372,4 +456,25 @@
       INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
     END FUNCTION cxios_is_defined_filegroup_read_metadata_par
+
+
+    SUBROUTINE cxios_set_filegroup_reader(filegroup_hdl, reader, reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: reader
+      INTEGER  (kind = C_INT)     , VALUE        :: reader_size
+    END SUBROUTINE cxios_set_filegroup_reader
+
+    SUBROUTINE cxios_get_filegroup_reader(filegroup_hdl, reader, reader_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: reader
+      INTEGER  (kind = C_INT)     , VALUE        :: reader_size
+    END SUBROUTINE cxios_get_filegroup_reader
+
+    FUNCTION cxios_is_defined_filegroup_reader(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_reader
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_reader
 
 
@@ -687,4 +792,23 @@
 
 
+    SUBROUTINE cxios_set_filegroup_using_server2(filegroup_hdl, using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: using_server2
+    END SUBROUTINE cxios_set_filegroup_using_server2
+
+    SUBROUTINE cxios_get_filegroup_using_server2(filegroup_hdl, using_server2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      LOGICAL (KIND=C_BOOL)             :: using_server2
+    END SUBROUTINE cxios_get_filegroup_using_server2
+
+    FUNCTION cxios_is_defined_filegroup_using_server2(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_using_server2
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_using_server2
+
+
     SUBROUTINE cxios_set_filegroup_uuid_format(filegroup_hdl, uuid_format, uuid_format_size) BIND(C)
       USE ISO_C_BINDING
@@ -728,4 +852,25 @@
     END FUNCTION cxios_is_defined_filegroup_uuid_name
 
+
+    SUBROUTINE cxios_set_filegroup_writer(filegroup_hdl, writer, writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: writer
+      INTEGER  (kind = C_INT)     , VALUE        :: writer_size
+    END SUBROUTINE cxios_set_filegroup_writer
+
+    SUBROUTINE cxios_get_filegroup_writer(filegroup_hdl, writer, writer_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: writer
+      INTEGER  (kind = C_INT)     , VALUE        :: writer_size
+    END SUBROUTINE cxios_get_filegroup_writer
+
+    FUNCTION cxios_is_defined_filegroup_writer(filegroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_filegroup_writer
+      INTEGER (kind = C_INTPTR_T), VALUE :: filegroup_hdl
+    END FUNCTION cxios_is_defined_filegroup_writer
+
   END INTERFACE
 
Index: XIOS3/trunk/src/interface/fortran_attr/iaxis_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 2616)
@@ -12,8 +12,8 @@
 
   SUBROUTINE xios(set_axis_attr)  &
-    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -25,4 +25,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -52,16 +53,16 @@
       (axis_id,axis_hdl)
       CALL xios(set_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(set_axis_attr)
 
   SUBROUTINE xios(set_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -72,4 +73,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -97,16 +99,16 @@
 
       CALL xios(set_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(set_axis_attr_hdl)
 
   SUBROUTINE xios(set_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  &
-    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  &
-    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  &
-    , unit_, value_ )
+    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    , index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_  &
+    , prec_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
@@ -117,4 +119,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_
@@ -166,4 +169,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        CALL cxios_set_axis_chunking_weight &
+      (axis_hdl%daddr, chunking_weight_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_set_axis_comment &
@@ -281,8 +289,8 @@
 
   SUBROUTINE xios(get_axis_attr)  &
-    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -294,4 +302,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -321,16 +330,16 @@
       (axis_id,axis_hdl)
       CALL xios(get_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(get_axis_attr)
 
   SUBROUTINE xios(get_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -341,4 +350,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -366,16 +376,16 @@
 
       CALL xios(get_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(get_axis_attr_hdl)
 
   SUBROUTINE xios(get_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  &
-    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  &
-    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  &
-    , unit_, value_ )
+    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    , index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_  &
+    , prec_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
@@ -386,4 +396,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_
@@ -435,4 +446,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        CALL cxios_get_axis_chunking_weight &
+      (axis_hdl%daddr, chunking_weight_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_get_axis_comment &
@@ -550,8 +566,8 @@
 
   SUBROUTINE xios(is_defined_axis_attr)  &
-    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -568,4 +584,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name
       LOGICAL(KIND=C_BOOL) :: bounds_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -616,16 +634,16 @@
       (axis_id,axis_hdl)
       CALL xios(is_defined_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(is_defined_axis_attr)
 
   SUBROUTINE xios(is_defined_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-    , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-    , value )
+    ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    , unit, value )
 
     IMPLICIT NONE
@@ -641,4 +659,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name
       LOGICAL(KIND=C_BOOL) :: bounds_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -687,16 +707,16 @@
 
       CALL xios(is_defined_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index, label  &
-      , long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name, unit  &
-      , value )
+      ( axis_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, index  &
+      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      , unit, value )
 
   END SUBROUTINE xios(is_defined_axis_attr_hdl)
 
   SUBROUTINE xios(is_defined_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_, data_index_  &
-    , data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_, index_  &
-    , label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_, prec_, standard_name_  &
-    , unit_, value_ )
+    ( axis_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    , index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_, positive_  &
+    , prec_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
@@ -712,4 +732,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name_
       LOGICAL(KIND=C_BOOL) :: bounds_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
@@ -787,4 +809,10 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        chunking_weight__tmp = cxios_is_defined_axis_chunking_weight &
+      (axis_hdl%daddr)
+        chunking_weight_ = chunking_weight__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_axis_comment &
Index: XIOS3/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 2616)
@@ -12,7 +12,7 @@
 
   SUBROUTINE xios(set_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -25,4 +25,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -53,7 +54,7 @@
       (axisgroup_id,axisgroup_hdl)
       CALL xios(set_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -61,7 +62,7 @@
 
   SUBROUTINE xios(set_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -73,4 +74,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -99,7 +101,7 @@
 
       CALL xios(set_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -107,6 +109,6 @@
 
   SUBROUTINE xios(set_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  &
-    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
     , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  &
     , positive_, prec_, standard_name_, unit_, value_ )
@@ -119,4 +121,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_
@@ -169,4 +172,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        CALL cxios_set_axisgroup_chunking_weight &
+      (axisgroup_hdl%daddr, chunking_weight_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_set_axisgroup_comment &
@@ -289,7 +297,7 @@
 
   SUBROUTINE xios(get_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -302,4 +310,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -330,7 +339,7 @@
       (axisgroup_id,axisgroup_hdl)
       CALL xios(get_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -338,7 +347,7 @@
 
   SUBROUTINE xios(get_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -350,4 +359,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -376,7 +386,7 @@
 
       CALL xios(get_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -384,6 +394,6 @@
 
   SUBROUTINE xios(get_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  &
-    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
     , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  &
     , positive_, prec_, standard_name_, unit_, value_ )
@@ -396,4 +406,5 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_
@@ -446,4 +457,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        CALL cxios_get_axisgroup_chunking_weight &
+      (axisgroup_hdl%daddr, chunking_weight_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_get_axisgroup_comment &
@@ -566,7 +582,7 @@
 
   SUBROUTINE xios(is_defined_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_id, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -584,4 +600,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name
       LOGICAL(KIND=C_BOOL) :: bounds_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -634,7 +652,7 @@
       (axisgroup_id,axisgroup_hdl)
       CALL xios(is_defined_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -642,7 +660,7 @@
 
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-    , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-    , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+    ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+    , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+    , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
     , unit, value )
 
@@ -659,4 +677,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name
       LOGICAL(KIND=C_BOOL) :: bounds_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -707,7 +727,7 @@
 
       CALL xios(is_defined_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, comment, data_begin, data_index  &
-      , data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref, index  &
-      , label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
+      ( axisgroup_hdl, axis_ref, axis_type, begin, bounds, bounds_name, chunking_weight, comment, data_begin  &
+      , data_index, data_n, dim_name, formula, formula_bounds, formula_term, formula_term_bounds, group_ref  &
+      , index, label, long_name, mask, n, n_distributed_partition, n_glo, name, positive, prec, standard_name  &
       , unit, value )
 
@@ -715,6 +735,6 @@
 
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, comment_, data_begin_  &
-    , data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
+    ( axisgroup_hdl, axis_ref_, axis_type_, begin_, bounds_, bounds_name_, chunking_weight_, comment_  &
+    , data_begin_, data_index_, data_n_, dim_name_, formula_, formula_bounds_, formula_term_, formula_term_bounds_  &
     , group_ref_, index_, label_, long_name_, mask_, n_, n_distributed_partition_, n_glo_, name_  &
     , positive_, prec_, standard_name_, unit_, value_ )
@@ -732,4 +752,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_name_
       LOGICAL(KIND=C_BOOL) :: bounds_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
@@ -809,4 +831,10 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_)) THEN
+        chunking_weight__tmp = cxios_is_defined_axisgroup_chunking_weight &
+      (axisgroup_hdl%daddr)
+        chunking_weight_ = chunking_weight__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_axisgroup_comment &
Index: XIOS3/trunk/src/interface/fortran_attr/icontext_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/icontext_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/icontext_attr.F90	(revision 2616)
@@ -12,5 +12,6 @@
 
   SUBROUTINE xios(set_context_attr)  &
-    ( context_id, attached_mode, output_dir )
+    ( context_id, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -19,4 +20,13 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: attached_mode
       LOGICAL (KIND=C_BOOL) :: attached_mode_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_writer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_reader
+      LOGICAL  , OPTIONAL, INTENT(IN) :: default_using_server2
+      LOGICAL (KIND=C_BOOL) :: default_using_server2_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_writer
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: output_dir
 
@@ -24,10 +34,12 @@
       (context_id,context_hdl)
       CALL xios(set_context_attr_hdl_)   &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(set_context_attr)
 
   SUBROUTINE xios(set_context_attr_hdl)  &
-    ( context_hdl, attached_mode, output_dir )
+    ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -35,13 +47,25 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: attached_mode
       LOGICAL (KIND=C_BOOL) :: attached_mode_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_writer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_reader
+      LOGICAL  , OPTIONAL, INTENT(IN) :: default_using_server2
+      LOGICAL (KIND=C_BOOL) :: default_using_server2_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_writer
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: output_dir
 
       CALL xios(set_context_attr_hdl_)  &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(set_context_attr_hdl)
 
   SUBROUTINE xios(set_context_attr_hdl_)   &
-    ( context_hdl, attached_mode_, output_dir_ )
+    ( context_hdl, attached_mode_, default_gatherer_, default_pool_, default_pool_gatherer_, default_pool_reader_  &
+    , default_pool_writer_, default_reader_, default_using_server2_, default_writer_, output_dir_  &
+     )
 
     IMPLICIT NONE
@@ -49,4 +73,13 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: attached_mode_
       LOGICAL (KIND=C_BOOL) :: attached_mode__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_pool_writer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_reader_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: default_using_server2_
+      LOGICAL (KIND=C_BOOL) :: default_using_server2__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: default_writer_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: output_dir_
 
@@ -57,4 +90,45 @@
       ENDIF
 
+      IF (PRESENT(default_gatherer_)) THEN
+        CALL cxios_set_context_default_gatherer &
+      (context_hdl%daddr, default_gatherer_, len(default_gatherer_))
+      ENDIF
+
+      IF (PRESENT(default_pool_)) THEN
+        CALL cxios_set_context_default_pool &
+      (context_hdl%daddr, default_pool_, len(default_pool_))
+      ENDIF
+
+      IF (PRESENT(default_pool_gatherer_)) THEN
+        CALL cxios_set_context_default_pool_gatherer &
+      (context_hdl%daddr, default_pool_gatherer_, len(default_pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(default_pool_reader_)) THEN
+        CALL cxios_set_context_default_pool_reader &
+      (context_hdl%daddr, default_pool_reader_, len(default_pool_reader_))
+      ENDIF
+
+      IF (PRESENT(default_pool_writer_)) THEN
+        CALL cxios_set_context_default_pool_writer &
+      (context_hdl%daddr, default_pool_writer_, len(default_pool_writer_))
+      ENDIF
+
+      IF (PRESENT(default_reader_)) THEN
+        CALL cxios_set_context_default_reader &
+      (context_hdl%daddr, default_reader_, len(default_reader_))
+      ENDIF
+
+      IF (PRESENT(default_using_server2_)) THEN
+        default_using_server2__tmp = default_using_server2_
+        CALL cxios_set_context_default_using_server2 &
+      (context_hdl%daddr, default_using_server2__tmp)
+      ENDIF
+
+      IF (PRESENT(default_writer_)) THEN
+        CALL cxios_set_context_default_writer &
+      (context_hdl%daddr, default_writer_, len(default_writer_))
+      ENDIF
+
       IF (PRESENT(output_dir_)) THEN
         CALL cxios_set_context_output_dir &
@@ -65,5 +139,6 @@
 
   SUBROUTINE xios(get_context_attr)  &
-    ( context_id, attached_mode, output_dir )
+    ( context_id, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -72,4 +147,13 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: attached_mode
       LOGICAL (KIND=C_BOOL) :: attached_mode_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_writer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_reader
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: default_using_server2
+      LOGICAL (KIND=C_BOOL) :: default_using_server2_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_writer
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: output_dir
 
@@ -77,10 +161,12 @@
       (context_id,context_hdl)
       CALL xios(get_context_attr_hdl_)   &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(get_context_attr)
 
   SUBROUTINE xios(get_context_attr_hdl)  &
-    ( context_hdl, attached_mode, output_dir )
+    ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -88,13 +174,25 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: attached_mode
       LOGICAL (KIND=C_BOOL) :: attached_mode_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_writer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_reader
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: default_using_server2
+      LOGICAL (KIND=C_BOOL) :: default_using_server2_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_writer
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: output_dir
 
       CALL xios(get_context_attr_hdl_)  &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(get_context_attr_hdl)
 
   SUBROUTINE xios(get_context_attr_hdl_)   &
-    ( context_hdl, attached_mode_, output_dir_ )
+    ( context_hdl, attached_mode_, default_gatherer_, default_pool_, default_pool_gatherer_, default_pool_reader_  &
+    , default_pool_writer_, default_reader_, default_using_server2_, default_writer_, output_dir_  &
+     )
 
     IMPLICIT NONE
@@ -102,4 +200,13 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: attached_mode_
       LOGICAL (KIND=C_BOOL) :: attached_mode__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_pool_writer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_reader_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: default_using_server2_
+      LOGICAL (KIND=C_BOOL) :: default_using_server2__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: default_writer_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: output_dir_
 
@@ -110,4 +217,45 @@
       ENDIF
 
+      IF (PRESENT(default_gatherer_)) THEN
+        CALL cxios_get_context_default_gatherer &
+      (context_hdl%daddr, default_gatherer_, len(default_gatherer_))
+      ENDIF
+
+      IF (PRESENT(default_pool_)) THEN
+        CALL cxios_get_context_default_pool &
+      (context_hdl%daddr, default_pool_, len(default_pool_))
+      ENDIF
+
+      IF (PRESENT(default_pool_gatherer_)) THEN
+        CALL cxios_get_context_default_pool_gatherer &
+      (context_hdl%daddr, default_pool_gatherer_, len(default_pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(default_pool_reader_)) THEN
+        CALL cxios_get_context_default_pool_reader &
+      (context_hdl%daddr, default_pool_reader_, len(default_pool_reader_))
+      ENDIF
+
+      IF (PRESENT(default_pool_writer_)) THEN
+        CALL cxios_get_context_default_pool_writer &
+      (context_hdl%daddr, default_pool_writer_, len(default_pool_writer_))
+      ENDIF
+
+      IF (PRESENT(default_reader_)) THEN
+        CALL cxios_get_context_default_reader &
+      (context_hdl%daddr, default_reader_, len(default_reader_))
+      ENDIF
+
+      IF (PRESENT(default_using_server2_)) THEN
+        CALL cxios_get_context_default_using_server2 &
+      (context_hdl%daddr, default_using_server2__tmp)
+        default_using_server2_ = default_using_server2__tmp
+      ENDIF
+
+      IF (PRESENT(default_writer_)) THEN
+        CALL cxios_get_context_default_writer &
+      (context_hdl%daddr, default_writer_, len(default_writer_))
+      ENDIF
+
       IF (PRESENT(output_dir_)) THEN
         CALL cxios_get_context_output_dir &
@@ -118,5 +266,6 @@
 
   SUBROUTINE xios(is_defined_context_attr)  &
-    ( context_id, attached_mode, output_dir )
+    ( context_id, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -125,4 +274,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: attached_mode
       LOGICAL(KIND=C_BOOL) :: attached_mode_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_gatherer
+      LOGICAL(KIND=C_BOOL) :: default_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool
+      LOGICAL(KIND=C_BOOL) :: default_pool_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: default_pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_reader
+      LOGICAL(KIND=C_BOOL) :: default_pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_writer
+      LOGICAL(KIND=C_BOOL) :: default_pool_writer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_reader
+      LOGICAL(KIND=C_BOOL) :: default_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_using_server2
+      LOGICAL(KIND=C_BOOL) :: default_using_server2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_writer
+      LOGICAL(KIND=C_BOOL) :: default_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir
       LOGICAL(KIND=C_BOOL) :: output_dir_tmp
@@ -131,10 +296,12 @@
       (context_id,context_hdl)
       CALL xios(is_defined_context_attr_hdl_)   &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(is_defined_context_attr)
 
   SUBROUTINE xios(is_defined_context_attr_hdl)  &
-    ( context_hdl, attached_mode, output_dir )
+    ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+    , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
     IMPLICIT NONE
@@ -142,14 +309,33 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: attached_mode
       LOGICAL(KIND=C_BOOL) :: attached_mode_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_gatherer
+      LOGICAL(KIND=C_BOOL) :: default_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool
+      LOGICAL(KIND=C_BOOL) :: default_pool_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: default_pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_reader
+      LOGICAL(KIND=C_BOOL) :: default_pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_writer
+      LOGICAL(KIND=C_BOOL) :: default_pool_writer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_reader
+      LOGICAL(KIND=C_BOOL) :: default_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_using_server2
+      LOGICAL(KIND=C_BOOL) :: default_using_server2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_writer
+      LOGICAL(KIND=C_BOOL) :: default_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir
       LOGICAL(KIND=C_BOOL) :: output_dir_tmp
 
       CALL xios(is_defined_context_attr_hdl_)  &
-      ( context_hdl, attached_mode, output_dir )
+      ( context_hdl, attached_mode, default_gatherer, default_pool, default_pool_gatherer, default_pool_reader  &
+      , default_pool_writer, default_reader, default_using_server2, default_writer, output_dir )
 
   END SUBROUTINE xios(is_defined_context_attr_hdl)
 
   SUBROUTINE xios(is_defined_context_attr_hdl_)   &
-    ( context_hdl, attached_mode_, output_dir_ )
+    ( context_hdl, attached_mode_, default_gatherer_, default_pool_, default_pool_gatherer_, default_pool_reader_  &
+    , default_pool_writer_, default_reader_, default_using_server2_, default_writer_, output_dir_  &
+     )
 
     IMPLICIT NONE
@@ -157,4 +343,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: attached_mode_
       LOGICAL(KIND=C_BOOL) :: attached_mode__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_gatherer_
+      LOGICAL(KIND=C_BOOL) :: default_gatherer__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_
+      LOGICAL(KIND=C_BOOL) :: default_pool__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_gatherer_
+      LOGICAL(KIND=C_BOOL) :: default_pool_gatherer__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_reader_
+      LOGICAL(KIND=C_BOOL) :: default_pool_reader__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_pool_writer_
+      LOGICAL(KIND=C_BOOL) :: default_pool_writer__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_reader_
+      LOGICAL(KIND=C_BOOL) :: default_reader__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_using_server2_
+      LOGICAL(KIND=C_BOOL) :: default_using_server2__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: default_writer_
+      LOGICAL(KIND=C_BOOL) :: default_writer__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: output_dir_
       LOGICAL(KIND=C_BOOL) :: output_dir__tmp
@@ -166,4 +368,52 @@
       ENDIF
 
+      IF (PRESENT(default_gatherer_)) THEN
+        default_gatherer__tmp = cxios_is_defined_context_default_gatherer &
+      (context_hdl%daddr)
+        default_gatherer_ = default_gatherer__tmp
+      ENDIF
+
+      IF (PRESENT(default_pool_)) THEN
+        default_pool__tmp = cxios_is_defined_context_default_pool &
+      (context_hdl%daddr)
+        default_pool_ = default_pool__tmp
+      ENDIF
+
+      IF (PRESENT(default_pool_gatherer_)) THEN
+        default_pool_gatherer__tmp = cxios_is_defined_context_default_pool_gatherer &
+      (context_hdl%daddr)
+        default_pool_gatherer_ = default_pool_gatherer__tmp
+      ENDIF
+
+      IF (PRESENT(default_pool_reader_)) THEN
+        default_pool_reader__tmp = cxios_is_defined_context_default_pool_reader &
+      (context_hdl%daddr)
+        default_pool_reader_ = default_pool_reader__tmp
+      ENDIF
+
+      IF (PRESENT(default_pool_writer_)) THEN
+        default_pool_writer__tmp = cxios_is_defined_context_default_pool_writer &
+      (context_hdl%daddr)
+        default_pool_writer_ = default_pool_writer__tmp
+      ENDIF
+
+      IF (PRESENT(default_reader_)) THEN
+        default_reader__tmp = cxios_is_defined_context_default_reader &
+      (context_hdl%daddr)
+        default_reader_ = default_reader__tmp
+      ENDIF
+
+      IF (PRESENT(default_using_server2_)) THEN
+        default_using_server2__tmp = cxios_is_defined_context_default_using_server2 &
+      (context_hdl%daddr)
+        default_using_server2_ = default_using_server2__tmp
+      ENDIF
+
+      IF (PRESENT(default_writer_)) THEN
+        default_writer__tmp = cxios_is_defined_context_default_writer &
+      (context_hdl%daddr)
+        default_writer_ = default_writer__tmp
+      ENDIF
+
       IF (PRESENT(output_dir_)) THEN
         output_dir__tmp = cxios_is_defined_context_output_dir &
Index: XIOS3/trunk/src/interface/fortran_attr/idomain_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 2616)
@@ -12,9 +12,10 @@
 
   SUBROUTINE xios(set_domain_attr)  &
-    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -22,4 +23,6 @@
       CHARACTER(LEN=*), INTENT(IN) ::domain_id
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
@@ -28,4 +31,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
@@ -60,4 +65,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
@@ -68,22 +74,26 @@
       (domain_id,domain_hdl)
       CALL xios(set_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(set_domain_attr)
 
   SUBROUTINE xios(set_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
@@ -92,4 +102,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
@@ -124,4 +136,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
@@ -130,23 +143,26 @@
 
       CALL xios(set_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(set_domain_attr_hdl)
 
   SUBROUTINE xios(set_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
-    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    ( domain_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_  &
+    , bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_, data_dim_  &
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_, latvalue_2d_  &
+    , lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
+    , nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_ )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:)
@@ -155,4 +171,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_
@@ -187,4 +205,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo_
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name_
       INTEGER  , OPTIONAL, INTENT(IN) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius_
@@ -197,4 +216,14 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        CALL cxios_set_domain_area_1d &
+      (domain_hdl%daddr, area_1d_, SHAPE(area_1d_))
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        CALL cxios_set_domain_area_2d &
+      (domain_hdl%daddr, area_2d_, SHAPE(area_2d_))
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         CALL cxios_set_domain_bounds_lat_1d &
@@ -225,4 +254,14 @@
         CALL cxios_set_domain_bounds_lon_name &
       (domain_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_))
+      ENDIF
+
+      IF (PRESENT(chunking_weight_i_)) THEN
+        CALL cxios_set_domain_chunking_weight_i &
+      (domain_hdl%daddr, chunking_weight_i_)
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        CALL cxios_set_domain_chunking_weight_j &
+      (domain_hdl%daddr, chunking_weight_j_)
       ENDIF
 
@@ -381,4 +420,9 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        CALL cxios_set_domain_nvertex_name &
+      (domain_hdl%daddr, nvertex_name_, len(nvertex_name_))
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         CALL cxios_set_domain_prec &
@@ -404,9 +448,10 @@
 
   SUBROUTINE xios(get_domain_attr)  &
-    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -414,4 +459,6 @@
       CHARACTER(LEN=*), INTENT(IN) ::domain_id
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
@@ -420,4 +467,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
@@ -452,4 +501,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
@@ -460,22 +510,26 @@
       (domain_id,domain_hdl)
       CALL xios(get_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(get_domain_attr)
 
   SUBROUTINE xios(get_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
@@ -484,4 +538,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
@@ -516,4 +572,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
@@ -522,23 +579,26 @@
 
       CALL xios(get_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(get_domain_attr_hdl)
 
   SUBROUTINE xios(get_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
-    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    ( domain_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_  &
+    , bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_, data_dim_  &
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_, latvalue_2d_  &
+    , lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
+    , nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_ )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:)
@@ -547,4 +607,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_
@@ -579,4 +641,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name_
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius_
@@ -589,4 +652,14 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        CALL cxios_get_domain_area_1d &
+      (domain_hdl%daddr, area_1d_, SHAPE(area_1d_))
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        CALL cxios_get_domain_area_2d &
+      (domain_hdl%daddr, area_2d_, SHAPE(area_2d_))
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         CALL cxios_get_domain_bounds_lat_1d &
@@ -617,4 +690,14 @@
         CALL cxios_get_domain_bounds_lon_name &
       (domain_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_))
+      ENDIF
+
+      IF (PRESENT(chunking_weight_i_)) THEN
+        CALL cxios_get_domain_chunking_weight_i &
+      (domain_hdl%daddr, chunking_weight_i_)
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        CALL cxios_get_domain_chunking_weight_j &
+      (domain_hdl%daddr, chunking_weight_j_)
       ENDIF
 
@@ -773,4 +856,9 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        CALL cxios_get_domain_nvertex_name &
+      (domain_hdl%daddr, nvertex_name_, len(nvertex_name_))
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         CALL cxios_get_domain_prec &
@@ -796,9 +884,10 @@
 
   SUBROUTINE xios(is_defined_domain_attr)  &
-    ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -807,4 +896,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d
+      LOGICAL(KIND=C_BOOL) :: area_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d
+      LOGICAL(KIND=C_BOOL) :: area_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
@@ -819,4 +912,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -879,4 +976,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name
+      LOGICAL(KIND=C_BOOL) :: nvertex_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec
       LOGICAL(KIND=C_BOOL) :: prec_tmp
@@ -891,18 +990,20 @@
       (domain_id,domain_hdl)
       CALL xios(is_defined_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domain_attr)
 
   SUBROUTINE xios(is_defined_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-    , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+    , prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -910,4 +1011,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d
+      LOGICAL(KIND=C_BOOL) :: area_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d
+      LOGICAL(KIND=C_BOOL) :: area_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
@@ -922,4 +1027,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -982,4 +1091,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name
+      LOGICAL(KIND=C_BOOL) :: nvertex_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec
       LOGICAL(KIND=C_BOOL) :: prec_tmp
@@ -992,19 +1103,20 @@
 
       CALL xios(is_defined_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
-      , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domain_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name, long_name  &
+      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, nvertex_name  &
+      , prec, radius, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domain_attr_hdl)
 
   SUBROUTINE xios(is_defined_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
-    , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    ( domain_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_  &
+    , bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_, data_dim_  &
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_, latvalue_2d_  &
+    , lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
+    , nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_ )
 
     IMPLICIT NONE
@@ -1012,4 +1124,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area_
       LOGICAL(KIND=C_BOOL) :: area__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d_
+      LOGICAL(KIND=C_BOOL) :: area_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d_
+      LOGICAL(KIND=C_BOOL) :: area_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp
@@ -1024,4 +1140,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name_
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
@@ -1084,4 +1204,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_
       LOGICAL(KIND=C_BOOL) :: nvertex__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name_
+      LOGICAL(KIND=C_BOOL) :: nvertex_name__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec_
       LOGICAL(KIND=C_BOOL) :: prec__tmp
@@ -1099,4 +1221,16 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        area_1d__tmp = cxios_is_defined_domain_area_1d &
+      (domain_hdl%daddr)
+        area_1d_ = area_1d__tmp
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        area_2d__tmp = cxios_is_defined_domain_area_2d &
+      (domain_hdl%daddr)
+        area_2d_ = area_2d__tmp
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         bounds_lat_1d__tmp = cxios_is_defined_domain_bounds_lat_1d &
@@ -1135,4 +1269,16 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_i_)) THEN
+        chunking_weight_i__tmp = cxios_is_defined_domain_chunking_weight_i &
+      (domain_hdl%daddr)
+        chunking_weight_i_ = chunking_weight_i__tmp
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        chunking_weight_j__tmp = cxios_is_defined_domain_chunking_weight_j &
+      (domain_hdl%daddr)
+        chunking_weight_j_ = chunking_weight_j__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_domain_comment &
@@ -1315,4 +1461,10 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        nvertex_name__tmp = cxios_is_defined_domain_nvertex_name &
+      (domain_hdl%daddr)
+        nvertex_name_ = nvertex_name__tmp
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         prec__tmp = cxios_is_defined_domain_prec &
Index: XIOS3/trunk/src/interface/fortran_attr/idomaingroup_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 2616)
@@ -12,9 +12,10 @@
 
   SUBROUTINE xios(set_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -22,4 +23,6 @@
       CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
@@ -28,4 +31,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
@@ -61,4 +66,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
@@ -69,22 +75,26 @@
       (domaingroup_id,domaingroup_hdl)
       CALL xios(set_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(set_domaingroup_attr)
 
   SUBROUTINE xios(set_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
@@ -93,4 +103,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
@@ -126,4 +138,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
@@ -132,23 +145,27 @@
 
       CALL xios(set_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(set_domaingroup_attr_hdl)
 
   SUBROUTINE xios(set_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
-    , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    ( domaingroup_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_  &
+    , bounds_lon_1d_, bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_  &
+    , data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_  &
+    , latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_  &
+    , ni_, ni_glo_, nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_  &
+     )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_2d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:)
@@ -157,4 +174,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: bounds_lon_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_i_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_weight_j_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_
@@ -190,4 +209,5 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo_
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: nvertex_name_
       INTEGER  , OPTIONAL, INTENT(IN) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius_
@@ -200,4 +220,14 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        CALL cxios_set_domaingroup_area_1d &
+      (domaingroup_hdl%daddr, area_1d_, SHAPE(area_1d_))
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        CALL cxios_set_domaingroup_area_2d &
+      (domaingroup_hdl%daddr, area_2d_, SHAPE(area_2d_))
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         CALL cxios_set_domaingroup_bounds_lat_1d &
@@ -228,4 +258,14 @@
         CALL cxios_set_domaingroup_bounds_lon_name &
       (domaingroup_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_))
+      ENDIF
+
+      IF (PRESENT(chunking_weight_i_)) THEN
+        CALL cxios_set_domaingroup_chunking_weight_i &
+      (domaingroup_hdl%daddr, chunking_weight_i_)
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        CALL cxios_set_domaingroup_chunking_weight_j &
+      (domaingroup_hdl%daddr, chunking_weight_j_)
       ENDIF
 
@@ -389,4 +429,9 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        CALL cxios_set_domaingroup_nvertex_name &
+      (domaingroup_hdl%daddr, nvertex_name_, len(nvertex_name_))
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         CALL cxios_set_domaingroup_prec &
@@ -412,9 +457,10 @@
 
   SUBROUTINE xios(get_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -422,4 +468,6 @@
       CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
@@ -428,4 +476,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
@@ -461,4 +511,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
@@ -469,22 +520,26 @@
       (domaingroup_id,domaingroup_hdl)
       CALL xios(get_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(get_domaingroup_attr)
 
   SUBROUTINE xios(get_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
@@ -493,4 +548,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
@@ -526,4 +583,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
@@ -532,23 +590,27 @@
 
       CALL xios(get_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(get_domaingroup_attr_hdl)
 
   SUBROUTINE xios(get_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
-    , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    ( domaingroup_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_  &
+    , bounds_lon_1d_, bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_  &
+    , data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_  &
+    , latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_  &
+    , ni_, ni_glo_, nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_  &
+     )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_2d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:)
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:)
@@ -557,4 +619,6 @@
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: bounds_lon_name_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_i_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_weight_j_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_
@@ -590,4 +654,5 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: nvertex_name_
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius_
@@ -600,4 +665,14 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        CALL cxios_get_domaingroup_area_1d &
+      (domaingroup_hdl%daddr, area_1d_, SHAPE(area_1d_))
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        CALL cxios_get_domaingroup_area_2d &
+      (domaingroup_hdl%daddr, area_2d_, SHAPE(area_2d_))
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         CALL cxios_get_domaingroup_bounds_lat_1d &
@@ -628,4 +703,14 @@
         CALL cxios_get_domaingroup_bounds_lon_name &
       (domaingroup_hdl%daddr, bounds_lon_name_, len(bounds_lon_name_))
+      ENDIF
+
+      IF (PRESENT(chunking_weight_i_)) THEN
+        CALL cxios_get_domaingroup_chunking_weight_i &
+      (domaingroup_hdl%daddr, chunking_weight_i_)
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        CALL cxios_get_domaingroup_chunking_weight_j &
+      (domaingroup_hdl%daddr, chunking_weight_j_)
       ENDIF
 
@@ -789,4 +874,9 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        CALL cxios_get_domaingroup_nvertex_name &
+      (domaingroup_hdl%daddr, nvertex_name_, len(nvertex_name_))
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         CALL cxios_get_domaingroup_prec &
@@ -812,9 +902,10 @@
 
   SUBROUTINE xios(is_defined_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_id, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -823,4 +914,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d
+      LOGICAL(KIND=C_BOOL) :: area_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d
+      LOGICAL(KIND=C_BOOL) :: area_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
@@ -835,4 +930,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -897,4 +996,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name
+      LOGICAL(KIND=C_BOOL) :: nvertex_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec
       LOGICAL(KIND=C_BOOL) :: prec_tmp
@@ -909,18 +1010,20 @@
       (domaingroup_id,domaingroup_hdl)
       CALL xios(is_defined_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr)
 
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-    , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-    , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-    , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+    , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+    , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+    , nvertex_name, prec, radius, standard_name, type )
 
     IMPLICIT NONE
@@ -928,4 +1031,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d
+      LOGICAL(KIND=C_BOOL) :: area_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d
+      LOGICAL(KIND=C_BOOL) :: area_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
@@ -940,4 +1047,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
@@ -1002,4 +1113,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name
+      LOGICAL(KIND=C_BOOL) :: nvertex_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec
       LOGICAL(KIND=C_BOOL) :: prec_tmp
@@ -1012,19 +1125,21 @@
 
       CALL xios(is_defined_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d, bounds_lon_2d  &
-      , bounds_lon_name, comment, data_dim, data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni  &
-      , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
-      , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      ( domaingroup_hdl, area, area_1d, area_2d, bounds_lat_1d, bounds_lat_2d, bounds_lat_name, bounds_lon_1d  &
+      , bounds_lon_2d, bounds_lon_name, chunking_weight_i, chunking_weight_j, comment, data_dim, data_i_index  &
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, dim_i_name, dim_j_name, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d, latvalue_2d, lon_name  &
+      , long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex  &
+      , nvertex_name, prec, radius, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr_hdl)
 
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_, bounds_lon_1d_, bounds_lon_2d_  &
-    , bounds_lon_name_, comment_, data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_  &
-    , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
-    , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    ( domaingroup_hdl, area_, area_1d_, area_2d_, bounds_lat_1d_, bounds_lat_2d_, bounds_lat_name_  &
+    , bounds_lon_1d_, bounds_lon_2d_, bounds_lon_name_, chunking_weight_i_, chunking_weight_j_, comment_  &
+    , data_dim_, data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, dim_i_name_  &
+    , dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, lat_name_, latvalue_1d_  &
+    , latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_  &
+    , ni_, ni_glo_, nj_, nj_glo_, nvertex_, nvertex_name_, prec_, radius_, standard_name_, type_  &
+     )
 
     IMPLICIT NONE
@@ -1032,4 +1147,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area_
       LOGICAL(KIND=C_BOOL) :: area__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_1d_
+      LOGICAL(KIND=C_BOOL) :: area_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: area_2d_
+      LOGICAL(KIND=C_BOOL) :: area_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_
       LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp
@@ -1044,4 +1163,8 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_name_
       LOGICAL(KIND=C_BOOL) :: bounds_lon_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_i_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_i__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_weight_j_
+      LOGICAL(KIND=C_BOOL) :: chunking_weight_j__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
@@ -1106,4 +1229,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_
       LOGICAL(KIND=C_BOOL) :: nvertex__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_name_
+      LOGICAL(KIND=C_BOOL) :: nvertex_name__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: prec_
       LOGICAL(KIND=C_BOOL) :: prec__tmp
@@ -1121,4 +1246,16 @@
       ENDIF
 
+      IF (PRESENT(area_1d_)) THEN
+        area_1d__tmp = cxios_is_defined_domaingroup_area_1d &
+      (domaingroup_hdl%daddr)
+        area_1d_ = area_1d__tmp
+      ENDIF
+
+      IF (PRESENT(area_2d_)) THEN
+        area_2d__tmp = cxios_is_defined_domaingroup_area_2d &
+      (domaingroup_hdl%daddr)
+        area_2d_ = area_2d__tmp
+      ENDIF
+
       IF (PRESENT(bounds_lat_1d_)) THEN
         bounds_lat_1d__tmp = cxios_is_defined_domaingroup_bounds_lat_1d &
@@ -1157,4 +1294,16 @@
       ENDIF
 
+      IF (PRESENT(chunking_weight_i_)) THEN
+        chunking_weight_i__tmp = cxios_is_defined_domaingroup_chunking_weight_i &
+      (domaingroup_hdl%daddr)
+        chunking_weight_i_ = chunking_weight_i__tmp
+      ENDIF
+
+      IF (PRESENT(chunking_weight_j_)) THEN
+        chunking_weight_j__tmp = cxios_is_defined_domaingroup_chunking_weight_j &
+      (domaingroup_hdl%daddr)
+        chunking_weight_j_ = chunking_weight_j__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_domaingroup_comment &
@@ -1343,4 +1492,10 @@
       ENDIF
 
+      IF (PRESENT(nvertex_name_)) THEN
+        nvertex_name__tmp = cxios_is_defined_domaingroup_nvertex_name &
+      (domaingroup_hdl%daddr)
+        nvertex_name_ = nvertex_name__tmp
+      ENDIF
+
       IF (PRESENT(prec_)) THEN
         prec__tmp = cxios_is_defined_domaingroup_prec &
Index: XIOS3/trunk/src/interface/fortran_attr/ifield_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/ifield_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/ifield_attr.F90	(revision 2616)
@@ -13,8 +13,9 @@
   SUBROUTINE xios(set_field_attr)  &
     ( field_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -29,6 +30,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value
@@ -66,8 +72,9 @@
       CALL xios(set_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(set_field_attr)
@@ -75,8 +82,9 @@
   SUBROUTINE xios(set_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -90,6 +98,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value
@@ -125,8 +138,9 @@
       CALL xios(set_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(set_field_attr_hdl)
@@ -134,5 +148,6 @@
   SUBROUTINE xios(set_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -149,6 +164,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active_
       LOGICAL (KIND=C_BOOL) :: check_if_active__tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params_(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF_
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value_
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value_
@@ -214,4 +234,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        CALL cxios_set_field_chunking_blocksize_target &
+      (field_hdl%daddr, chunking_blocksize_target_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_set_field_comment &
@@ -222,4 +247,20 @@
         CALL cxios_set_field_compression_level &
       (field_hdl%daddr, compression_level_)
+      ENDIF
+
+      IF (PRESENT(compression_params_)) THEN
+        CALL cxios_set_field_compression_params &
+      (field_hdl%daddr, compression_params_, SHAPE(compression_params_))
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        CALL cxios_set_field_compression_type &
+      (field_hdl%daddr, compression_type_, len(compression_type_))
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        conversion_by_NetCDF__tmp = conversion_by_NetCDF_
+        CALL cxios_set_field_conversion_by_NetCDF &
+      (field_hdl%daddr, conversion_by_NetCDF__tmp)
       ENDIF
 
@@ -358,8 +399,9 @@
   SUBROUTINE xios(get_field_attr)  &
     ( field_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -374,6 +416,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value
@@ -411,8 +458,9 @@
       CALL xios(get_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(get_field_attr)
@@ -420,8 +468,9 @@
   SUBROUTINE xios(get_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -435,6 +484,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value
@@ -470,8 +524,9 @@
       CALL xios(get_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(get_field_attr_hdl)
@@ -479,5 +534,6 @@
   SUBROUTINE xios(get_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -494,6 +550,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active_
       LOGICAL (KIND=C_BOOL) :: check_if_active__tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params_(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF_
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value_
@@ -559,4 +620,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        CALL cxios_get_field_chunking_blocksize_target &
+      (field_hdl%daddr, chunking_blocksize_target_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_get_field_comment &
@@ -567,4 +633,20 @@
         CALL cxios_get_field_compression_level &
       (field_hdl%daddr, compression_level_)
+      ENDIF
+
+      IF (PRESENT(compression_params_)) THEN
+        CALL cxios_get_field_compression_params &
+      (field_hdl%daddr, compression_params_, SHAPE(compression_params_))
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        CALL cxios_get_field_compression_type &
+      (field_hdl%daddr, compression_type_, len(compression_type_))
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        CALL cxios_get_field_conversion_by_NetCDF &
+      (field_hdl%daddr, conversion_by_NetCDF__tmp)
+        conversion_by_NetCDF_ = conversion_by_NetCDF__tmp
       ENDIF
 
@@ -703,8 +785,9 @@
   SUBROUTINE xios(is_defined_field_attr)  &
     ( field_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -723,8 +806,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL(KIND=C_BOOL) :: check_if_active_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params
+      LOGICAL(KIND=C_BOOL) :: compression_params_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL(KIND=C_BOOL) :: compression_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL(KIND=C_BOOL) :: default_value_tmp
@@ -782,8 +873,9 @@
       CALL xios(is_defined_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(is_defined_field_attr)
@@ -791,8 +883,9 @@
   SUBROUTINE xios(is_defined_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-    , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-    , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+    , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+    , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+    , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
     IMPLICIT NONE
@@ -810,8 +903,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL(KIND=C_BOOL) :: check_if_active_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params
+      LOGICAL(KIND=C_BOOL) :: compression_params_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL(KIND=C_BOOL) :: compression_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL(KIND=C_BOOL) :: default_value_tmp
@@ -867,8 +968,9 @@
       CALL xios(is_defined_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode, check_if_active  &
-      , comment, compression_level, default_value, detect_missing_value, domain_ref, enabled, expr  &
-      , field_ref, freq_offset, freq_op, grid_path, grid_ref, 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 )
+      , chunking_blocksize_target, comment, compression_level, compression_params, compression_type  &
+      , conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled, expr, field_ref  &
+      , freq_offset, freq_op, grid_path, grid_ref, 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 )
 
   END SUBROUTINE xios(is_defined_field_attr_hdl)
@@ -876,5 +978,6 @@
   SUBROUTINE xios(is_defined_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -895,8 +998,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active_
       LOGICAL(KIND=C_BOOL) :: check_if_active__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target_
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_
       LOGICAL(KIND=C_BOOL) :: compression_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params_
+      LOGICAL(KIND=C_BOOL) :: compression_params__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type_
+      LOGICAL(KIND=C_BOOL) :: compression_type__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF_
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value_
       LOGICAL(KIND=C_BOOL) :: default_value__tmp
@@ -986,4 +1097,10 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        chunking_blocksize_target__tmp = cxios_is_defined_field_chunking_blocksize_target &
+      (field_hdl%daddr)
+        chunking_blocksize_target_ = chunking_blocksize_target__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_field_comment &
@@ -998,4 +1115,22 @@
       ENDIF
 
+      IF (PRESENT(compression_params_)) THEN
+        compression_params__tmp = cxios_is_defined_field_compression_params &
+      (field_hdl%daddr)
+        compression_params_ = compression_params__tmp
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        compression_type__tmp = cxios_is_defined_field_compression_type &
+      (field_hdl%daddr)
+        compression_type_ = compression_type__tmp
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        conversion_by_NetCDF__tmp = cxios_is_defined_field_conversion_by_NetCDF &
+      (field_hdl%daddr)
+        conversion_by_NetCDF_ = conversion_by_NetCDF__tmp
+      ENDIF
+
       IF (PRESENT(default_value_)) THEN
         default_value__tmp = cxios_is_defined_field_default_value &
Index: XIOS3/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/ifieldgroup_attr.F90	(revision 2616)
@@ -13,8 +13,9 @@
   SUBROUTINE xios(set_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -29,6 +30,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value
@@ -67,8 +73,9 @@
       CALL xios(set_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(set_fieldgroup_attr)
@@ -76,8 +83,9 @@
   SUBROUTINE xios(set_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -91,6 +99,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value
@@ -127,8 +140,9 @@
       CALL xios(set_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(set_fieldgroup_attr_hdl)
@@ -136,5 +150,6 @@
   SUBROUTINE xios(set_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -151,6 +166,11 @@
       LOGICAL  , OPTIONAL, INTENT(IN) :: check_if_active_
       LOGICAL (KIND=C_BOOL) :: check_if_active__tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: chunking_blocksize_target_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: comment_
       INTEGER  , OPTIONAL, INTENT(IN) :: compression_level_
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: compression_params_(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: compression_type_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: conversion_by_NetCDF_
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: default_value_
       LOGICAL  , OPTIONAL, INTENT(IN) :: detect_missing_value_
@@ -217,4 +237,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        CALL cxios_set_fieldgroup_chunking_blocksize_target &
+      (fieldgroup_hdl%daddr, chunking_blocksize_target_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_set_fieldgroup_comment &
@@ -225,4 +250,20 @@
         CALL cxios_set_fieldgroup_compression_level &
       (fieldgroup_hdl%daddr, compression_level_)
+      ENDIF
+
+      IF (PRESENT(compression_params_)) THEN
+        CALL cxios_set_fieldgroup_compression_params &
+      (fieldgroup_hdl%daddr, compression_params_, SHAPE(compression_params_))
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        CALL cxios_set_fieldgroup_compression_type &
+      (fieldgroup_hdl%daddr, compression_type_, len(compression_type_))
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        conversion_by_NetCDF__tmp = conversion_by_NetCDF_
+        CALL cxios_set_fieldgroup_conversion_by_NetCDF &
+      (fieldgroup_hdl%daddr, conversion_by_NetCDF__tmp)
       ENDIF
 
@@ -366,8 +407,9 @@
   SUBROUTINE xios(get_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -382,6 +424,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value
@@ -420,8 +467,9 @@
       CALL xios(get_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(get_fieldgroup_attr)
@@ -429,8 +477,9 @@
   SUBROUTINE xios(get_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -444,6 +493,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL (KIND=C_BOOL) :: check_if_active_tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value
@@ -480,8 +534,9 @@
       CALL xios(get_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(get_fieldgroup_attr_hdl)
@@ -489,5 +544,6 @@
   SUBROUTINE xios(get_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -504,6 +560,11 @@
       LOGICAL  , OPTIONAL, INTENT(OUT) :: check_if_active_
       LOGICAL (KIND=C_BOOL) :: check_if_active__tmp
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: chunking_blocksize_target_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: comment_
       INTEGER  , OPTIONAL, INTENT(OUT) :: compression_level_
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: compression_params_(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: compression_type_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF_
+      LOGICAL (KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: default_value_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: detect_missing_value_
@@ -570,4 +631,9 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        CALL cxios_get_fieldgroup_chunking_blocksize_target &
+      (fieldgroup_hdl%daddr, chunking_blocksize_target_)
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         CALL cxios_get_fieldgroup_comment &
@@ -578,4 +644,20 @@
         CALL cxios_get_fieldgroup_compression_level &
       (fieldgroup_hdl%daddr, compression_level_)
+      ENDIF
+
+      IF (PRESENT(compression_params_)) THEN
+        CALL cxios_get_fieldgroup_compression_params &
+      (fieldgroup_hdl%daddr, compression_params_, SHAPE(compression_params_))
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        CALL cxios_get_fieldgroup_compression_type &
+      (fieldgroup_hdl%daddr, compression_type_, len(compression_type_))
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        CALL cxios_get_fieldgroup_conversion_by_NetCDF &
+      (fieldgroup_hdl%daddr, conversion_by_NetCDF__tmp)
+        conversion_by_NetCDF_ = conversion_by_NetCDF__tmp
       ENDIF
 
@@ -719,8 +801,9 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -739,8 +822,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL(KIND=C_BOOL) :: check_if_active_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params
+      LOGICAL(KIND=C_BOOL) :: compression_params_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL(KIND=C_BOOL) :: compression_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL(KIND=C_BOOL) :: default_value_tmp
@@ -800,8 +891,9 @@
       CALL xios(is_defined_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr)
@@ -809,8 +901,9 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-    , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+    , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+    , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+    , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
     IMPLICIT NONE
@@ -828,8 +921,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active
       LOGICAL(KIND=C_BOOL) :: check_if_active_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment
       LOGICAL(KIND=C_BOOL) :: comment_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level
       LOGICAL(KIND=C_BOOL) :: compression_level_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params
+      LOGICAL(KIND=C_BOOL) :: compression_params_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type
+      LOGICAL(KIND=C_BOOL) :: compression_type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value
       LOGICAL(KIND=C_BOOL) :: default_value_tmp
@@ -887,8 +988,9 @@
       CALL xios(is_defined_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, build_workflow_graph, cell_methods, cell_methods_mode  &
-      , check_if_active, comment, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
+      , check_if_active, chunking_blocksize_target, comment, compression_level, compression_params  &
+      , compression_type, conversion_by_NetCDF, default_value, detect_missing_value, domain_ref, enabled  &
+      , expr, field_ref, freq_offset, freq_op, grid_path, grid_ref, group_ref, 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 )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)
@@ -896,5 +998,6 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, build_workflow_graph_, cell_methods_, cell_methods_mode_  &
-    , check_if_active_, comment_, compression_level_, default_value_, detect_missing_value_, domain_ref_  &
+    , check_if_active_, chunking_blocksize_target_, comment_, compression_level_, compression_params_  &
+    , compression_type_, conversion_by_NetCDF_, default_value_, detect_missing_value_, domain_ref_  &
     , enabled_, expr_, field_ref_, freq_offset_, freq_op_, grid_path_, grid_ref_, group_ref_, indexed_output_  &
     , level_, long_name_, name_, operation_, prec_, read_access_, scalar_ref_, scale_factor_, standard_name_  &
@@ -915,8 +1018,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: check_if_active_
       LOGICAL(KIND=C_BOOL) :: check_if_active__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: chunking_blocksize_target_
+      LOGICAL(KIND=C_BOOL) :: chunking_blocksize_target__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: comment_
       LOGICAL(KIND=C_BOOL) :: comment__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: compression_level_
       LOGICAL(KIND=C_BOOL) :: compression_level__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_params_
+      LOGICAL(KIND=C_BOOL) :: compression_params__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: compression_type_
+      LOGICAL(KIND=C_BOOL) :: compression_type__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: conversion_by_NetCDF_
+      LOGICAL(KIND=C_BOOL) :: conversion_by_NetCDF__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: default_value_
       LOGICAL(KIND=C_BOOL) :: default_value__tmp
@@ -1008,4 +1119,10 @@
       ENDIF
 
+      IF (PRESENT(chunking_blocksize_target_)) THEN
+        chunking_blocksize_target__tmp = cxios_is_defined_fieldgroup_chunking_blocksize_target &
+      (fieldgroup_hdl%daddr)
+        chunking_blocksize_target_ = chunking_blocksize_target__tmp
+      ENDIF
+
       IF (PRESENT(comment_)) THEN
         comment__tmp = cxios_is_defined_fieldgroup_comment &
@@ -1020,4 +1137,22 @@
       ENDIF
 
+      IF (PRESENT(compression_params_)) THEN
+        compression_params__tmp = cxios_is_defined_fieldgroup_compression_params &
+      (fieldgroup_hdl%daddr)
+        compression_params_ = compression_params__tmp
+      ENDIF
+
+      IF (PRESENT(compression_type_)) THEN
+        compression_type__tmp = cxios_is_defined_fieldgroup_compression_type &
+      (fieldgroup_hdl%daddr)
+        compression_type_ = compression_type__tmp
+      ENDIF
+
+      IF (PRESENT(conversion_by_NetCDF_)) THEN
+        conversion_by_NetCDF__tmp = cxios_is_defined_fieldgroup_conversion_by_NetCDF &
+      (fieldgroup_hdl%daddr)
+        conversion_by_NetCDF_ = conversion_by_NetCDF__tmp
+      ENDIF
+
       IF (PRESENT(default_value_)) THEN
         default_value__tmp = cxios_is_defined_fieldgroup_default_value &
Index: XIOS3/trunk/src/interface/fortran_attr/ifile_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/ifile_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/ifile_attr.F90	(revision 2616)
@@ -13,8 +13,9 @@
   SUBROUTINE xios(set_file_attr)  &
     ( file_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -33,4 +34,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode
@@ -40,6 +42,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset
@@ -57,6 +63,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer
 
       CALL xios(get_file_handle) &
@@ -64,8 +73,9 @@
       CALL xios(set_file_attr_hdl_)   &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(set_file_attr)
@@ -73,8 +83,9 @@
   SUBROUTINE xios(set_file_attr_hdl)  &
     ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -92,4 +103,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode
@@ -99,6 +111,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset
@@ -116,13 +132,17 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer
 
       CALL xios(set_file_attr_hdl_)  &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(set_file_attr_hdl)
@@ -130,8 +150,9 @@
   SUBROUTINE xios(set_file_attr_hdl_)   &
     ( file_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_, description_  &
-    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  &
-    , read_metadata_par_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
-    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
-    , time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ )
+    , enabled_, format_, gatherer_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  &
+    , par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_, reader_, record_offset_  &
+    , split_end_offset_, split_freq_, split_freq_format_, split_last_date_, split_start_offset_  &
+    , sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_, time_units_  &
+    , timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_ )
 
     IMPLICIT NONE
@@ -149,4 +170,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer_
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: mode_
@@ -156,6 +178,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer_
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par_
       LOGICAL (KIND=C_BOOL) :: read_metadata_par__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader_
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset_
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset_
@@ -173,6 +199,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2_
+      LOGICAL (KIND=C_BOOL) :: using_server2__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer_
 
       IF (PRESENT(append_)) THEN
@@ -224,4 +253,9 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        CALL cxios_set_file_gatherer &
+      (file_hdl%daddr, gatherer_, len(gatherer_))
+      ENDIF
+
       IF (PRESENT(min_digits_)) THEN
         CALL cxios_set_file_min_digits &
@@ -257,4 +291,19 @@
         CALL cxios_set_file_par_access &
       (file_hdl%daddr, par_access_, len(par_access_))
+      ENDIF
+
+      IF (PRESENT(pool_gatherer_)) THEN
+        CALL cxios_set_file_pool_gatherer &
+      (file_hdl%daddr, pool_gatherer_, len(pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        CALL cxios_set_file_pool_reader &
+      (file_hdl%daddr, pool_reader_, len(pool_reader_))
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        CALL cxios_set_file_pool_writer &
+      (file_hdl%daddr, pool_writer_, len(pool_writer_))
       ENDIF
 
@@ -265,4 +314,9 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        CALL cxios_set_file_reader &
+      (file_hdl%daddr, reader_, len(reader_))
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         CALL cxios_set_file_record_offset &
@@ -340,4 +394,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        using_server2__tmp = using_server2_
+        CALL cxios_set_file_using_server2 &
+      (file_hdl%daddr, using_server2__tmp)
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         CALL cxios_set_file_uuid_format &
@@ -350,12 +410,18 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        CALL cxios_set_file_writer &
+      (file_hdl%daddr, writer_, len(writer_))
+      ENDIF
+
   END SUBROUTINE xios(set_file_attr_hdl_)
 
   SUBROUTINE xios(get_file_attr)  &
     ( file_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -374,4 +440,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode
@@ -381,6 +448,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset
@@ -398,6 +469,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer
 
       CALL xios(get_file_handle) &
@@ -405,8 +479,9 @@
       CALL xios(get_file_attr_hdl_)   &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(get_file_attr)
@@ -414,8 +489,9 @@
   SUBROUTINE xios(get_file_attr_hdl)  &
     ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -433,4 +509,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode
@@ -440,6 +517,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset
@@ -457,13 +538,17 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer
 
       CALL xios(get_file_attr_hdl_)  &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(get_file_attr_hdl)
@@ -471,8 +556,9 @@
   SUBROUTINE xios(get_file_attr_hdl_)   &
     ( file_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_, description_  &
-    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  &
-    , read_metadata_par_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
-    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
-    , time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ )
+    , enabled_, format_, gatherer_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  &
+    , par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_, reader_, record_offset_  &
+    , split_end_offset_, split_freq_, split_freq_format_, split_last_date_, split_start_offset_  &
+    , sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_, time_units_  &
+    , timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_ )
 
     IMPLICIT NONE
@@ -490,4 +576,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer_
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: mode_
@@ -497,6 +584,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par_
       LOGICAL (KIND=C_BOOL) :: read_metadata_par__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader_
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset_
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset_
@@ -514,6 +605,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2_
+      LOGICAL (KIND=C_BOOL) :: using_server2__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer_
 
       IF (PRESENT(append_)) THEN
@@ -565,4 +659,9 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        CALL cxios_get_file_gatherer &
+      (file_hdl%daddr, gatherer_, len(gatherer_))
+      ENDIF
+
       IF (PRESENT(min_digits_)) THEN
         CALL cxios_get_file_min_digits &
@@ -598,4 +697,19 @@
         CALL cxios_get_file_par_access &
       (file_hdl%daddr, par_access_, len(par_access_))
+      ENDIF
+
+      IF (PRESENT(pool_gatherer_)) THEN
+        CALL cxios_get_file_pool_gatherer &
+      (file_hdl%daddr, pool_gatherer_, len(pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        CALL cxios_get_file_pool_reader &
+      (file_hdl%daddr, pool_reader_, len(pool_reader_))
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        CALL cxios_get_file_pool_writer &
+      (file_hdl%daddr, pool_writer_, len(pool_writer_))
       ENDIF
 
@@ -606,4 +720,9 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        CALL cxios_get_file_reader &
+      (file_hdl%daddr, reader_, len(reader_))
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         CALL cxios_get_file_record_offset &
@@ -681,4 +800,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        CALL cxios_get_file_using_server2 &
+      (file_hdl%daddr, using_server2__tmp)
+        using_server2_ = using_server2__tmp
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         CALL cxios_get_file_uuid_format &
@@ -691,12 +816,18 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        CALL cxios_get_file_writer &
+      (file_hdl%daddr, writer_, len(writer_))
+      ENDIF
+
   END SUBROUTINE xios(get_file_attr_hdl_)
 
   SUBROUTINE xios(is_defined_file_attr)  &
     ( file_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -721,4 +852,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format
       LOGICAL(KIND=C_BOOL) :: format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer
+      LOGICAL(KIND=C_BOOL) :: gatherer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
       LOGICAL(KIND=C_BOOL) :: min_digits_tmp
@@ -735,6 +868,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
       LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader
+      LOGICAL(KIND=C_BOOL) :: pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer
+      LOGICAL(KIND=C_BOOL) :: pool_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL(KIND=C_BOOL) :: read_metadata_par_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader
+      LOGICAL(KIND=C_BOOL) :: reader_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset
       LOGICAL(KIND=C_BOOL) :: record_offset_tmp
@@ -767,8 +908,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL(KIND=C_BOOL) :: using_server2_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format
       LOGICAL(KIND=C_BOOL) :: uuid_format_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name
       LOGICAL(KIND=C_BOOL) :: uuid_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer
+      LOGICAL(KIND=C_BOOL) :: writer_tmp
 
       CALL xios(get_file_handle) &
@@ -776,8 +921,9 @@
       CALL xios(is_defined_file_attr_hdl_)   &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(is_defined_file_attr)
@@ -785,8 +931,9 @@
   SUBROUTINE xios(is_defined_file_attr_hdl)  &
     ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-    , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-    , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-    , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -810,4 +957,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format
       LOGICAL(KIND=C_BOOL) :: format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer
+      LOGICAL(KIND=C_BOOL) :: gatherer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits
       LOGICAL(KIND=C_BOOL) :: min_digits_tmp
@@ -824,6 +973,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
       LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader
+      LOGICAL(KIND=C_BOOL) :: pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer
+      LOGICAL(KIND=C_BOOL) :: pool_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL(KIND=C_BOOL) :: read_metadata_par_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader
+      LOGICAL(KIND=C_BOOL) :: reader_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset
       LOGICAL(KIND=C_BOOL) :: record_offset_tmp
@@ -856,15 +1013,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL(KIND=C_BOOL) :: using_server2_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format
       LOGICAL(KIND=C_BOOL) :: uuid_format_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name
       LOGICAL(KIND=C_BOOL) :: uuid_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer
+      LOGICAL(KIND=C_BOOL) :: writer_tmp
 
       CALL xios(is_defined_file_attr_hdl_)  &
       ( file_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, min_digits, mode, name, name_suffix, output_freq, output_level, par_access  &
-      , read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format, split_last_date  &
-      , split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format, time_stamp_name  &
-      , time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(is_defined_file_attr_hdl)
@@ -872,8 +1034,9 @@
   SUBROUTINE xios(is_defined_file_attr_hdl_)   &
     ( file_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_, description_  &
-    , enabled_, format_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_, par_access_  &
-    , read_metadata_par_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
-    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
-    , time_units_, timeseries_, ts_prefix_, type_, uuid_format_, uuid_name_ )
+    , enabled_, format_, gatherer_, min_digits_, mode_, name_, name_suffix_, output_freq_, output_level_  &
+    , par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_, reader_, record_offset_  &
+    , split_end_offset_, split_freq_, split_freq_format_, split_last_date_, split_start_offset_  &
+    , sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_, time_units_  &
+    , timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_ )
 
     IMPLICIT NONE
@@ -897,4 +1060,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format_
       LOGICAL(KIND=C_BOOL) :: format__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer_
+      LOGICAL(KIND=C_BOOL) :: gatherer__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: min_digits_
       LOGICAL(KIND=C_BOOL) :: min_digits__tmp
@@ -911,6 +1076,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access_
       LOGICAL(KIND=C_BOOL) :: par_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer_
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader_
+      LOGICAL(KIND=C_BOOL) :: pool_reader__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer_
+      LOGICAL(KIND=C_BOOL) :: pool_writer__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par_
       LOGICAL(KIND=C_BOOL) :: read_metadata_par__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader_
+      LOGICAL(KIND=C_BOOL) :: reader__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset_
       LOGICAL(KIND=C_BOOL) :: record_offset__tmp
@@ -943,8 +1116,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type_
       LOGICAL(KIND=C_BOOL) :: type__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2_
+      LOGICAL(KIND=C_BOOL) :: using_server2__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format_
       LOGICAL(KIND=C_BOOL) :: uuid_format__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name_
       LOGICAL(KIND=C_BOOL) :: uuid_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer_
+      LOGICAL(KIND=C_BOOL) :: writer__tmp
 
       IF (PRESENT(append_)) THEN
@@ -1002,4 +1179,10 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        gatherer__tmp = cxios_is_defined_file_gatherer &
+      (file_hdl%daddr)
+        gatherer_ = gatherer__tmp
+      ENDIF
+
       IF (PRESENT(min_digits_)) THEN
         min_digits__tmp = cxios_is_defined_file_min_digits &
@@ -1044,4 +1227,22 @@
       ENDIF
 
+      IF (PRESENT(pool_gatherer_)) THEN
+        pool_gatherer__tmp = cxios_is_defined_file_pool_gatherer &
+      (file_hdl%daddr)
+        pool_gatherer_ = pool_gatherer__tmp
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        pool_reader__tmp = cxios_is_defined_file_pool_reader &
+      (file_hdl%daddr)
+        pool_reader_ = pool_reader__tmp
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        pool_writer__tmp = cxios_is_defined_file_pool_writer &
+      (file_hdl%daddr)
+        pool_writer_ = pool_writer__tmp
+      ENDIF
+
       IF (PRESENT(read_metadata_par_)) THEN
         read_metadata_par__tmp = cxios_is_defined_file_read_metadata_par &
@@ -1050,4 +1251,10 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        reader__tmp = cxios_is_defined_file_reader &
+      (file_hdl%daddr)
+        reader_ = reader__tmp
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         record_offset__tmp = cxios_is_defined_file_record_offset &
@@ -1140,4 +1347,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        using_server2__tmp = cxios_is_defined_file_using_server2 &
+      (file_hdl%daddr)
+        using_server2_ = using_server2__tmp
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         uuid_format__tmp = cxios_is_defined_file_uuid_format &
@@ -1152,4 +1365,10 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        writer__tmp = cxios_is_defined_file_writer &
+      (file_hdl%daddr)
+        writer_ = writer__tmp
+      ENDIF
+
   END SUBROUTINE xios(is_defined_file_attr_hdl_)
 
Index: XIOS3/trunk/src/interface/fortran_attr/ifilegroup_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/ifilegroup_attr.F90	(revision 2614)
+++ XIOS3/trunk/src/interface/fortran_attr/ifilegroup_attr.F90	(revision 2616)
@@ -13,8 +13,9 @@
   SUBROUTINE xios(set_filegroup_attr)  &
     ( filegroup_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -33,4 +34,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits
@@ -41,6 +43,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset
@@ -58,6 +64,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer
 
       CALL xios(get_filegroup_handle) &
@@ -65,8 +74,9 @@
       CALL xios(set_filegroup_attr_hdl_)   &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(set_filegroup_attr)
@@ -74,8 +84,9 @@
   SUBROUTINE xios(set_filegroup_attr_hdl)  &
     ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -93,4 +104,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits
@@ -101,6 +113,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset
@@ -118,13 +134,17 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer
 
       CALL xios(set_filegroup_attr_hdl_)  &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(set_filegroup_attr_hdl)
@@ -132,9 +152,10 @@
   SUBROUTINE xios(set_filegroup_attr_hdl_)   &
     ( filegroup_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_  &
-    , description_, enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_  &
-    , output_level_, par_access_, read_metadata_par_, record_offset_, split_end_offset_, split_freq_  &
-    , split_freq_format_, split_last_date_, split_start_offset_, sync_freq_, time_counter_, time_counter_name_  &
-    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  &
-    , uuid_name_ )
+    , description_, enabled_, format_, gatherer_, group_ref_, min_digits_, mode_, name_, name_suffix_  &
+    , output_freq_, output_level_, par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_  &
+    , reader_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
+    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
+    , time_units_, timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_  &
+     )
 
     IMPLICIT NONE
@@ -152,4 +173,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: format_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: gatherer_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
       INTEGER  , OPTIONAL, INTENT(IN) :: min_digits_
@@ -160,6 +182,10 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: output_level_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: par_access_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: pool_writer_
       LOGICAL  , OPTIONAL, INTENT(IN) :: read_metadata_par_
       LOGICAL (KIND=C_BOOL) :: read_metadata_par__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: reader_
       INTEGER  , OPTIONAL, INTENT(IN) :: record_offset_
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: split_end_offset_
@@ -177,6 +203,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: ts_prefix_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: using_server2_
+      LOGICAL (KIND=C_BOOL) :: using_server2__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: uuid_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: writer_
 
       IF (PRESENT(append_)) THEN
@@ -228,4 +257,9 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        CALL cxios_set_filegroup_gatherer &
+      (filegroup_hdl%daddr, gatherer_, len(gatherer_))
+      ENDIF
+
       IF (PRESENT(group_ref_)) THEN
         CALL cxios_set_filegroup_group_ref &
@@ -266,4 +300,19 @@
         CALL cxios_set_filegroup_par_access &
       (filegroup_hdl%daddr, par_access_, len(par_access_))
+      ENDIF
+
+      IF (PRESENT(pool_gatherer_)) THEN
+        CALL cxios_set_filegroup_pool_gatherer &
+      (filegroup_hdl%daddr, pool_gatherer_, len(pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        CALL cxios_set_filegroup_pool_reader &
+      (filegroup_hdl%daddr, pool_reader_, len(pool_reader_))
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        CALL cxios_set_filegroup_pool_writer &
+      (filegroup_hdl%daddr, pool_writer_, len(pool_writer_))
       ENDIF
 
@@ -274,4 +323,9 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        CALL cxios_set_filegroup_reader &
+      (filegroup_hdl%daddr, reader_, len(reader_))
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         CALL cxios_set_filegroup_record_offset &
@@ -349,4 +403,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        using_server2__tmp = using_server2_
+        CALL cxios_set_filegroup_using_server2 &
+      (filegroup_hdl%daddr, using_server2__tmp)
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         CALL cxios_set_filegroup_uuid_format &
@@ -359,12 +419,18 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        CALL cxios_set_filegroup_writer &
+      (filegroup_hdl%daddr, writer_, len(writer_))
+      ENDIF
+
   END SUBROUTINE xios(set_filegroup_attr_hdl_)
 
   SUBROUTINE xios(get_filegroup_attr)  &
     ( filegroup_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -383,4 +449,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits
@@ -391,6 +458,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset
@@ -408,6 +479,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer
 
       CALL xios(get_filegroup_handle) &
@@ -415,8 +489,9 @@
       CALL xios(get_filegroup_attr_hdl_)   &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(get_filegroup_attr)
@@ -424,8 +499,9 @@
   SUBROUTINE xios(get_filegroup_attr_hdl)  &
     ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -443,4 +519,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits
@@ -451,6 +528,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL (KIND=C_BOOL) :: read_metadata_par_tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset
@@ -468,13 +549,17 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL (KIND=C_BOOL) :: using_server2_tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer
 
       CALL xios(get_filegroup_attr_hdl_)  &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(get_filegroup_attr_hdl)
@@ -482,9 +567,10 @@
   SUBROUTINE xios(get_filegroup_attr_hdl_)   &
     ( filegroup_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_  &
-    , description_, enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_  &
-    , output_level_, par_access_, read_metadata_par_, record_offset_, split_end_offset_, split_freq_  &
-    , split_freq_format_, split_last_date_, split_start_offset_, sync_freq_, time_counter_, time_counter_name_  &
-    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  &
-    , uuid_name_ )
+    , description_, enabled_, format_, gatherer_, group_ref_, min_digits_, mode_, name_, name_suffix_  &
+    , output_freq_, output_level_, par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_  &
+    , reader_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
+    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
+    , time_units_, timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_  &
+     )
 
     IMPLICIT NONE
@@ -502,4 +588,5 @@
       LOGICAL (KIND=C_BOOL) :: enabled__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: format_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: gatherer_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
       INTEGER  , OPTIONAL, INTENT(OUT) :: min_digits_
@@ -510,6 +597,10 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: output_level_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: par_access_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_gatherer_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_reader_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: pool_writer_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: read_metadata_par_
       LOGICAL (KIND=C_BOOL) :: read_metadata_par__tmp
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: reader_
       INTEGER  , OPTIONAL, INTENT(OUT) :: record_offset_
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: split_end_offset_
@@ -527,6 +618,9 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: ts_prefix_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: using_server2_
+      LOGICAL (KIND=C_BOOL) :: using_server2__tmp
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_format_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: uuid_name_
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: writer_
 
       IF (PRESENT(append_)) THEN
@@ -578,4 +672,9 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        CALL cxios_get_filegroup_gatherer &
+      (filegroup_hdl%daddr, gatherer_, len(gatherer_))
+      ENDIF
+
       IF (PRESENT(group_ref_)) THEN
         CALL cxios_get_filegroup_group_ref &
@@ -616,4 +715,19 @@
         CALL cxios_get_filegroup_par_access &
       (filegroup_hdl%daddr, par_access_, len(par_access_))
+      ENDIF
+
+      IF (PRESENT(pool_gatherer_)) THEN
+        CALL cxios_get_filegroup_pool_gatherer &
+      (filegroup_hdl%daddr, pool_gatherer_, len(pool_gatherer_))
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        CALL cxios_get_filegroup_pool_reader &
+      (filegroup_hdl%daddr, pool_reader_, len(pool_reader_))
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        CALL cxios_get_filegroup_pool_writer &
+      (filegroup_hdl%daddr, pool_writer_, len(pool_writer_))
       ENDIF
 
@@ -624,4 +738,9 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        CALL cxios_get_filegroup_reader &
+      (filegroup_hdl%daddr, reader_, len(reader_))
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         CALL cxios_get_filegroup_record_offset &
@@ -699,4 +818,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        CALL cxios_get_filegroup_using_server2 &
+      (filegroup_hdl%daddr, using_server2__tmp)
+        using_server2_ = using_server2__tmp
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         CALL cxios_get_filegroup_uuid_format &
@@ -709,12 +834,18 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        CALL cxios_get_filegroup_writer &
+      (filegroup_hdl%daddr, writer_, len(writer_))
+      ENDIF
+
   END SUBROUTINE xios(get_filegroup_attr_hdl_)
 
   SUBROUTINE xios(is_defined_filegroup_attr)  &
     ( filegroup_id, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -739,4 +870,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format
       LOGICAL(KIND=C_BOOL) :: format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer
+      LOGICAL(KIND=C_BOOL) :: gatherer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
@@ -755,6 +888,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
       LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader
+      LOGICAL(KIND=C_BOOL) :: pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer
+      LOGICAL(KIND=C_BOOL) :: pool_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL(KIND=C_BOOL) :: read_metadata_par_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader
+      LOGICAL(KIND=C_BOOL) :: reader_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset
       LOGICAL(KIND=C_BOOL) :: record_offset_tmp
@@ -787,8 +928,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL(KIND=C_BOOL) :: using_server2_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format
       LOGICAL(KIND=C_BOOL) :: uuid_format_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name
       LOGICAL(KIND=C_BOOL) :: uuid_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer
+      LOGICAL(KIND=C_BOOL) :: writer_tmp
 
       CALL xios(get_filegroup_handle) &
@@ -796,8 +941,9 @@
       CALL xios(is_defined_filegroup_attr_hdl_)   &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(is_defined_filegroup_attr)
@@ -805,8 +951,9 @@
   SUBROUTINE xios(is_defined_filegroup_attr_hdl)  &
     ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-    , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-    , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-    , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-    , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+    , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+    , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+    , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+    , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+    , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
     IMPLICIT NONE
@@ -830,4 +977,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format
       LOGICAL(KIND=C_BOOL) :: format_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer
+      LOGICAL(KIND=C_BOOL) :: gatherer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
@@ -846,6 +995,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access
       LOGICAL(KIND=C_BOOL) :: par_access_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader
+      LOGICAL(KIND=C_BOOL) :: pool_reader_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer
+      LOGICAL(KIND=C_BOOL) :: pool_writer_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par
       LOGICAL(KIND=C_BOOL) :: read_metadata_par_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader
+      LOGICAL(KIND=C_BOOL) :: reader_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset
       LOGICAL(KIND=C_BOOL) :: record_offset_tmp
@@ -878,15 +1035,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2
+      LOGICAL(KIND=C_BOOL) :: using_server2_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format
       LOGICAL(KIND=C_BOOL) :: uuid_format_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name
       LOGICAL(KIND=C_BOOL) :: uuid_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer
+      LOGICAL(KIND=C_BOOL) :: writer_tmp
 
       CALL xios(is_defined_filegroup_attr_hdl_)  &
       ( filegroup_hdl, append, comment, compression_level, convention, convention_str, cyclic, description  &
-      , enabled, format, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
-      , par_access, read_metadata_par, record_offset, split_end_offset, split_freq, split_freq_format  &
-      , split_last_date, split_start_offset, sync_freq, time_counter, time_counter_name, time_stamp_format  &
-      , time_stamp_name, time_units, timeseries, ts_prefix, type, uuid_format, uuid_name )
+      , enabled, format, gatherer, group_ref, min_digits, mode, name, name_suffix, output_freq, output_level  &
+      , par_access, pool_gatherer, pool_reader, pool_writer, read_metadata_par, reader, record_offset  &
+      , split_end_offset, split_freq, split_freq_format, split_last_date, split_start_offset, sync_freq  &
+      , time_counter, time_counter_name, time_stamp_format, time_stamp_name, time_units, timeseries  &
+      , ts_prefix, type, using_server2, uuid_format, uuid_name, writer )
 
   END SUBROUTINE xios(is_defined_filegroup_attr_hdl)
@@ -894,9 +1056,10 @@
   SUBROUTINE xios(is_defined_filegroup_attr_hdl_)   &
     ( filegroup_hdl, append_, comment_, compression_level_, convention_, convention_str_, cyclic_  &
-    , description_, enabled_, format_, group_ref_, min_digits_, mode_, name_, name_suffix_, output_freq_  &
-    , output_level_, par_access_, read_metadata_par_, record_offset_, split_end_offset_, split_freq_  &
-    , split_freq_format_, split_last_date_, split_start_offset_, sync_freq_, time_counter_, time_counter_name_  &
-    , time_stamp_format_, time_stamp_name_, time_units_, timeseries_, ts_prefix_, type_, uuid_format_  &
-    , uuid_name_ )
+    , description_, enabled_, format_, gatherer_, group_ref_, min_digits_, mode_, name_, name_suffix_  &
+    , output_freq_, output_level_, par_access_, pool_gatherer_, pool_reader_, pool_writer_, read_metadata_par_  &
+    , reader_, record_offset_, split_end_offset_, split_freq_, split_freq_format_, split_last_date_  &
+    , split_start_offset_, sync_freq_, time_counter_, time_counter_name_, time_stamp_format_, time_stamp_name_  &
+    , time_units_, timeseries_, ts_prefix_, type_, using_server2_, uuid_format_, uuid_name_, writer_  &
+     )
 
     IMPLICIT NONE
@@ -920,4 +1083,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: format_
       LOGICAL(KIND=C_BOOL) :: format__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: gatherer_
+      LOGICAL(KIND=C_BOOL) :: gatherer__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
       LOGICAL(KIND=C_BOOL) :: group_ref__tmp
@@ -936,6 +1101,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: par_access_
       LOGICAL(KIND=C_BOOL) :: par_access__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_gatherer_
+      LOGICAL(KIND=C_BOOL) :: pool_gatherer__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_reader_
+      LOGICAL(KIND=C_BOOL) :: pool_reader__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: pool_writer_
+      LOGICAL(KIND=C_BOOL) :: pool_writer__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: read_metadata_par_
       LOGICAL(KIND=C_BOOL) :: read_metadata_par__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: reader_
+      LOGICAL(KIND=C_BOOL) :: reader__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: record_offset_
       LOGICAL(KIND=C_BOOL) :: record_offset__tmp
@@ -968,8 +1141,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: type_
       LOGICAL(KIND=C_BOOL) :: type__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: using_server2_
+      LOGICAL(KIND=C_BOOL) :: using_server2__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_format_
       LOGICAL(KIND=C_BOOL) :: uuid_format__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: uuid_name_
       LOGICAL(KIND=C_BOOL) :: uuid_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: writer_
+      LOGICAL(KIND=C_BOOL) :: writer__tmp
 
       IF (PRESENT(append_)) THEN
@@ -1027,4 +1204,10 @@
       ENDIF
 
+      IF (PRESENT(gatherer_)) THEN
+        gatherer__tmp = cxios_is_defined_filegroup_gatherer &
+      (filegroup_hdl%daddr)
+        gatherer_ = gatherer__tmp
+      ENDIF
+
       IF (PRESENT(group_ref_)) THEN
         group_ref__tmp = cxios_is_defined_filegroup_group_ref &
@@ -1075,4 +1258,22 @@
       ENDIF
 
+      IF (PRESENT(pool_gatherer_)) THEN
+        pool_gatherer__tmp = cxios_is_defined_filegroup_pool_gatherer &
+      (filegroup_hdl%daddr)
+        pool_gatherer_ = pool_gatherer__tmp
+      ENDIF
+
+      IF (PRESENT(pool_reader_)) THEN
+        pool_reader__tmp = cxios_is_defined_filegroup_pool_reader &
+      (filegroup_hdl%daddr)
+        pool_reader_ = pool_reader__tmp
+      ENDIF
+
+      IF (PRESENT(pool_writer_)) THEN
+        pool_writer__tmp = cxios_is_defined_filegroup_pool_writer &
+      (filegroup_hdl%daddr)
+        pool_writer_ = pool_writer__tmp
+      ENDIF
+
       IF (PRESENT(read_metadata_par_)) THEN
         read_metadata_par__tmp = cxios_is_defined_filegroup_read_metadata_par &
@@ -1081,4 +1282,10 @@
       ENDIF
 
+      IF (PRESENT(reader_)) THEN
+        reader__tmp = cxios_is_defined_filegroup_reader &
+      (filegroup_hdl%daddr)
+        reader_ = reader__tmp
+      ENDIF
+
       IF (PRESENT(record_offset_)) THEN
         record_offset__tmp = cxios_is_defined_filegroup_record_offset &
@@ -1171,4 +1378,10 @@
       ENDIF
 
+      IF (PRESENT(using_server2_)) THEN
+        using_server2__tmp = cxios_is_defined_filegroup_using_server2 &
+      (filegroup_hdl%daddr)
+        using_server2_ = using_server2__tmp
+      ENDIF
+
       IF (PRESENT(uuid_format_)) THEN
         uuid_format__tmp = cxios_is_defined_filegroup_uuid_format &
@@ -1183,4 +1396,10 @@
       ENDIF
 
+      IF (PRESENT(writer_)) THEN
+        writer__tmp = cxios_is_defined_filegroup_writer &
+      (filegroup_hdl%daddr)
+        writer_ = writer__tmp
+      ENDIF
+
   END SUBROUTINE xios(is_defined_filegroup_attr_hdl_)
 
Index: XIOS3/trunk/src/interface/fortran_attr/iredistribute_axis_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/iredistribute_axis_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/iredistribute_axis_attr.F90	(revision 2616)
@@ -0,0 +1,206 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE iredistribute_axis_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE iredistribute_axis
+  USE redistribute_axis_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_redistribute_axis_attr)  &
+    ( redistribute_axis_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis))  :: redistribute_axis_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_axis_id
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(get_redistribute_axis_handle) &
+      (redistribute_axis_id,redistribute_axis_hdl)
+      CALL xios(set_redistribute_axis_attr_hdl_)   &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_axis_attr)
+
+  SUBROUTINE xios(set_redistribute_axis_attr_hdl)  &
+    ( redistribute_axis_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(set_redistribute_axis_attr_hdl_)  &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_axis_attr_hdl)
+
+  SUBROUTINE xios(set_redistribute_axis_attr_hdl_)   &
+    ( redistribute_axis_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_set_redistribute_axis_index &
+      (redistribute_axis_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        mask__tmp = mask_
+        CALL cxios_set_redistribute_axis_mask &
+      (redistribute_axis_hdl%daddr, mask__tmp, SHAPE(mask_))
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_set_redistribute_axis_type &
+      (redistribute_axis_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(set_redistribute_axis_attr_hdl_)
+
+  SUBROUTINE xios(get_redistribute_axis_attr)  &
+    ( redistribute_axis_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis))  :: redistribute_axis_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_axis_id
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_axis_handle) &
+      (redistribute_axis_id,redistribute_axis_hdl)
+      CALL xios(get_redistribute_axis_attr_hdl_)   &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_axis_attr)
+
+  SUBROUTINE xios(get_redistribute_axis_attr_hdl)  &
+    ( redistribute_axis_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_axis_attr_hdl_)  &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_axis_attr_hdl)
+
+  SUBROUTINE xios(get_redistribute_axis_attr_hdl_)   &
+    ( redistribute_axis_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_get_redistribute_axis_index &
+      (redistribute_axis_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        CALL cxios_get_redistribute_axis_mask &
+      (redistribute_axis_hdl%daddr, mask__tmp, SHAPE(mask_))
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_get_redistribute_axis_type &
+      (redistribute_axis_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(get_redistribute_axis_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_redistribute_axis_attr)  &
+    ( redistribute_axis_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis))  :: redistribute_axis_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_axis_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(get_redistribute_axis_handle) &
+      (redistribute_axis_id,redistribute_axis_hdl)
+      CALL xios(is_defined_redistribute_axis_attr_hdl_)   &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_axis_attr)
+
+  SUBROUTINE xios(is_defined_redistribute_axis_attr_hdl)  &
+    ( redistribute_axis_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(is_defined_redistribute_axis_attr_hdl_)  &
+      ( redistribute_axis_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_axis_attr_hdl)
+
+  SUBROUTINE xios(is_defined_redistribute_axis_attr_hdl_)   &
+    ( redistribute_axis_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_axis)) , INTENT(IN) :: redistribute_axis_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index_
+      LOGICAL(KIND=C_BOOL) :: index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL(KIND=C_BOOL) :: type__tmp
+
+      IF (PRESENT(index_)) THEN
+        index__tmp = cxios_is_defined_redistribute_axis_index &
+      (redistribute_axis_hdl%daddr)
+        index_ = index__tmp
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        mask__tmp = cxios_is_defined_redistribute_axis_mask &
+      (redistribute_axis_hdl%daddr)
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        type__tmp = cxios_is_defined_redistribute_axis_type &
+      (redistribute_axis_hdl%daddr)
+        type_ = type__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_redistribute_axis_attr_hdl_)
+
+END MODULE iredistribute_axis_attr
Index: XIOS3/trunk/src/interface/fortran_attr/iredistribute_domain_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/iredistribute_domain_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/iredistribute_domain_attr.F90	(revision 2616)
@@ -0,0 +1,206 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE iredistribute_domain_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE iredistribute_domain
+  USE redistribute_domain_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_redistribute_domain_attr)  &
+    ( redistribute_domain_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain))  :: redistribute_domain_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_domain_id
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(get_redistribute_domain_handle) &
+      (redistribute_domain_id,redistribute_domain_hdl)
+      CALL xios(set_redistribute_domain_attr_hdl_)   &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_domain_attr)
+
+  SUBROUTINE xios(set_redistribute_domain_attr_hdl)  &
+    ( redistribute_domain_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(set_redistribute_domain_attr_hdl_)  &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_domain_attr_hdl)
+
+  SUBROUTINE xios(set_redistribute_domain_attr_hdl_)   &
+    ( redistribute_domain_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_set_redistribute_domain_index &
+      (redistribute_domain_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        mask__tmp = mask_
+        CALL cxios_set_redistribute_domain_mask &
+      (redistribute_domain_hdl%daddr, mask__tmp, SHAPE(mask_))
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_set_redistribute_domain_type &
+      (redistribute_domain_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(set_redistribute_domain_attr_hdl_)
+
+  SUBROUTINE xios(get_redistribute_domain_attr)  &
+    ( redistribute_domain_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain))  :: redistribute_domain_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_domain_id
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_domain_handle) &
+      (redistribute_domain_id,redistribute_domain_hdl)
+      CALL xios(get_redistribute_domain_attr_hdl_)   &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_domain_attr)
+
+  SUBROUTINE xios(get_redistribute_domain_attr_hdl)  &
+    ( redistribute_domain_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_domain_attr_hdl_)  &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_domain_attr_hdl)
+
+  SUBROUTINE xios(get_redistribute_domain_attr_hdl_)   &
+    ( redistribute_domain_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_get_redistribute_domain_index &
+      (redistribute_domain_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        CALL cxios_get_redistribute_domain_mask &
+      (redistribute_domain_hdl%daddr, mask__tmp, SHAPE(mask_))
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_get_redistribute_domain_type &
+      (redistribute_domain_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(get_redistribute_domain_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_redistribute_domain_attr)  &
+    ( redistribute_domain_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain))  :: redistribute_domain_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_domain_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(get_redistribute_domain_handle) &
+      (redistribute_domain_id,redistribute_domain_hdl)
+      CALL xios(is_defined_redistribute_domain_attr_hdl_)   &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_domain_attr)
+
+  SUBROUTINE xios(is_defined_redistribute_domain_attr_hdl)  &
+    ( redistribute_domain_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(is_defined_redistribute_domain_attr_hdl_)  &
+      ( redistribute_domain_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_domain_attr_hdl)
+
+  SUBROUTINE xios(is_defined_redistribute_domain_attr_hdl_)   &
+    ( redistribute_domain_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_domain)) , INTENT(IN) :: redistribute_domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index_
+      LOGICAL(KIND=C_BOOL) :: index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL(KIND=C_BOOL) :: type__tmp
+
+      IF (PRESENT(index_)) THEN
+        index__tmp = cxios_is_defined_redistribute_domain_index &
+      (redistribute_domain_hdl%daddr)
+        index_ = index__tmp
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        mask__tmp = cxios_is_defined_redistribute_domain_mask &
+      (redistribute_domain_hdl%daddr)
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        type__tmp = cxios_is_defined_redistribute_domain_type &
+      (redistribute_domain_hdl%daddr)
+        type_ = type__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_redistribute_domain_attr_hdl_)
+
+END MODULE iredistribute_domain_attr
Index: XIOS3/trunk/src/interface/fortran_attr/iredistribute_scalar_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/iredistribute_scalar_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/iredistribute_scalar_attr.F90	(revision 2616)
@@ -0,0 +1,206 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "xios_fortran_prefix.hpp"
+
+MODULE iredistribute_scalar_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE iredistribute_scalar
+  USE redistribute_scalar_interface_attr
+
+CONTAINS
+
+  SUBROUTINE xios(set_redistribute_scalar_attr)  &
+    ( redistribute_scalar_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar))  :: redistribute_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_scalar_id
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(get_redistribute_scalar_handle) &
+      (redistribute_scalar_id,redistribute_scalar_hdl)
+      CALL xios(set_redistribute_scalar_attr_hdl_)   &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_scalar_attr)
+
+  SUBROUTINE xios(set_redistribute_scalar_attr_hdl)  &
+    ( redistribute_scalar_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
+
+      CALL xios(set_redistribute_scalar_attr_hdl_)  &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(set_redistribute_scalar_attr_hdl)
+
+  SUBROUTINE xios(set_redistribute_scalar_attr_hdl_)   &
+    ( redistribute_scalar_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      INTEGER  , OPTIONAL, INTENT(IN) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_set_redistribute_scalar_index &
+      (redistribute_scalar_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        mask__tmp = mask_
+        CALL cxios_set_redistribute_scalar_mask &
+      (redistribute_scalar_hdl%daddr, mask__tmp, SHAPE(mask_))
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_set_redistribute_scalar_type &
+      (redistribute_scalar_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(set_redistribute_scalar_attr_hdl_)
+
+  SUBROUTINE xios(get_redistribute_scalar_attr)  &
+    ( redistribute_scalar_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar))  :: redistribute_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_scalar_id
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_scalar_handle) &
+      (redistribute_scalar_id,redistribute_scalar_hdl)
+      CALL xios(get_redistribute_scalar_attr_hdl_)   &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_scalar_attr)
+
+  SUBROUTINE xios(get_redistribute_scalar_attr_hdl)  &
+    ( redistribute_scalar_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
+
+      CALL xios(get_redistribute_scalar_attr_hdl_)  &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(get_redistribute_scalar_attr_hdl)
+
+  SUBROUTINE xios(get_redistribute_scalar_attr_hdl_)   &
+    ( redistribute_scalar_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      INTEGER  , OPTIONAL, INTENT(OUT) :: index_(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+
+      IF (PRESENT(index_)) THEN
+        CALL cxios_get_redistribute_scalar_index &
+      (redistribute_scalar_hdl%daddr, index_, SHAPE(index_))
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(SIZE(mask_,1)))
+        CALL cxios_get_redistribute_scalar_mask &
+      (redistribute_scalar_hdl%daddr, mask__tmp, SHAPE(mask_))
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        CALL cxios_get_redistribute_scalar_type &
+      (redistribute_scalar_hdl%daddr, type_, len(type_))
+      ENDIF
+
+  END SUBROUTINE xios(get_redistribute_scalar_attr_hdl_)
+
+  SUBROUTINE xios(is_defined_redistribute_scalar_attr)  &
+    ( redistribute_scalar_id, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar))  :: redistribute_scalar_hdl
+      CHARACTER(LEN=*), INTENT(IN) ::redistribute_scalar_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(get_redistribute_scalar_handle) &
+      (redistribute_scalar_id,redistribute_scalar_hdl)
+      CALL xios(is_defined_redistribute_scalar_attr_hdl_)   &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_scalar_attr)
+
+  SUBROUTINE xios(is_defined_redistribute_scalar_attr_hdl)  &
+    ( redistribute_scalar_hdl, index, mask, type )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index
+      LOGICAL(KIND=C_BOOL) :: index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
+      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type
+      LOGICAL(KIND=C_BOOL) :: type_tmp
+
+      CALL xios(is_defined_redistribute_scalar_attr_hdl_)  &
+      ( redistribute_scalar_hdl, index, mask, type )
+
+  END SUBROUTINE xios(is_defined_redistribute_scalar_attr_hdl)
+
+  SUBROUTINE xios(is_defined_redistribute_scalar_attr_hdl_)   &
+    ( redistribute_scalar_hdl, index_, mask_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(redistribute_scalar)) , INTENT(IN) :: redistribute_scalar_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: index_
+      LOGICAL(KIND=C_BOOL) :: index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
+      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: type_
+      LOGICAL(KIND=C_BOOL) :: type__tmp
+
+      IF (PRESENT(index_)) THEN
+        index__tmp = cxios_is_defined_redistribute_scalar_index &
+      (redistribute_scalar_hdl%daddr)
+        index_ = index__tmp
+      ENDIF
+
+      IF (PRESENT(mask_)) THEN
+        mask__tmp = cxios_is_defined_redistribute_scalar_mask &
+      (redistribute_scalar_hdl%daddr)
+        mask_ = mask__tmp
+      ENDIF
+
+      IF (PRESENT(type_)) THEN
+        type__tmp = cxios_is_defined_redistribute_scalar_type &
+      (redistribute_scalar_hdl%daddr)
+        type_ = type__tmp
+      ENDIF
+
+  END SUBROUTINE xios(is_defined_redistribute_scalar_attr_hdl_)
+
+END MODULE iredistribute_scalar_attr
Index: XIOS3/trunk/src/interface/fortran_attr/redistribute_axis_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/redistribute_axis_interface_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/redistribute_axis_interface_attr.F90	(revision 2616)
@@ -0,0 +1,76 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE redistribute_axis_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_redistribute_axis_index(redistribute_axis_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_axis_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_axis_index
+
+    SUBROUTINE cxios_get_redistribute_axis_index(redistribute_axis_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_axis_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_axis_index
+
+    FUNCTION cxios_is_defined_redistribute_axis_index(redistribute_axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_axis_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_axis_hdl
+    END FUNCTION cxios_is_defined_redistribute_axis_index
+
+
+    SUBROUTINE cxios_set_redistribute_axis_mask(redistribute_axis_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_axis_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_axis_mask
+
+    SUBROUTINE cxios_get_redistribute_axis_mask(redistribute_axis_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_axis_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_axis_mask
+
+    FUNCTION cxios_is_defined_redistribute_axis_mask(redistribute_axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_axis_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_axis_hdl
+    END FUNCTION cxios_is_defined_redistribute_axis_mask
+
+
+    SUBROUTINE cxios_set_redistribute_axis_type(redistribute_axis_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_axis_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_set_redistribute_axis_type
+
+    SUBROUTINE cxios_get_redistribute_axis_type(redistribute_axis_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_axis_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_get_redistribute_axis_type
+
+    FUNCTION cxios_is_defined_redistribute_axis_type(redistribute_axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_axis_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_axis_hdl
+    END FUNCTION cxios_is_defined_redistribute_axis_type
+
+  END INTERFACE
+
+END MODULE redistribute_axis_interface_attr
Index: XIOS3/trunk/src/interface/fortran_attr/redistribute_domain_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/redistribute_domain_interface_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/redistribute_domain_interface_attr.F90	(revision 2616)
@@ -0,0 +1,76 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE redistribute_domain_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_redistribute_domain_index(redistribute_domain_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_domain_index
+
+    SUBROUTINE cxios_get_redistribute_domain_index(redistribute_domain_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_domain_index
+
+    FUNCTION cxios_is_defined_redistribute_domain_index(redistribute_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_domain_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_domain_hdl
+    END FUNCTION cxios_is_defined_redistribute_domain_index
+
+
+    SUBROUTINE cxios_set_redistribute_domain_mask(redistribute_domain_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_domain_mask
+
+    SUBROUTINE cxios_get_redistribute_domain_mask(redistribute_domain_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_domain_mask
+
+    FUNCTION cxios_is_defined_redistribute_domain_mask(redistribute_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_domain_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_domain_hdl
+    END FUNCTION cxios_is_defined_redistribute_domain_mask
+
+
+    SUBROUTINE cxios_set_redistribute_domain_type(redistribute_domain_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_domain_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_set_redistribute_domain_type
+
+    SUBROUTINE cxios_get_redistribute_domain_type(redistribute_domain_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_domain_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_get_redistribute_domain_type
+
+    FUNCTION cxios_is_defined_redistribute_domain_type(redistribute_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_domain_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_domain_hdl
+    END FUNCTION cxios_is_defined_redistribute_domain_type
+
+  END INTERFACE
+
+END MODULE redistribute_domain_interface_attr
Index: XIOS3/trunk/src/interface/fortran_attr/redistribute_scalar_interface_attr.F90
===================================================================
--- XIOS3/trunk/src/interface/fortran_attr/redistribute_scalar_interface_attr.F90	(revision 2616)
+++ XIOS3/trunk/src/interface/fortran_attr/redistribute_scalar_interface_attr.F90	(revision 2616)
@@ -0,0 +1,76 @@
+! * ************************************************************************** *
+! *               Interface auto generated - do not modify                     *
+! * ************************************************************************** *
+#include "../fortran/xios_fortran_prefix.hpp"
+
+MODULE redistribute_scalar_interface_attr
+  USE, INTRINSIC :: ISO_C_BINDING
+
+  INTERFACE
+    ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_redistribute_scalar_index(redistribute_scalar_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_scalar_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_scalar_index
+
+    SUBROUTINE cxios_get_redistribute_scalar_index(redistribute_scalar_hdl, index, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_scalar_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: index
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_scalar_index
+
+    FUNCTION cxios_is_defined_redistribute_scalar_index(redistribute_scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_scalar_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_scalar_hdl
+    END FUNCTION cxios_is_defined_redistribute_scalar_index
+
+
+    SUBROUTINE cxios_set_redistribute_scalar_mask(redistribute_scalar_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_scalar_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_redistribute_scalar_mask
+
+    SUBROUTINE cxios_get_redistribute_scalar_mask(redistribute_scalar_hdl, mask, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: redistribute_scalar_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_redistribute_scalar_mask
+
+    FUNCTION cxios_is_defined_redistribute_scalar_mask(redistribute_scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_scalar_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_scalar_hdl
+    END FUNCTION cxios_is_defined_redistribute_scalar_mask
+
+
+    SUBROUTINE cxios_set_redistribute_scalar_type(redistribute_scalar_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_set_redistribute_scalar_type
+
+    SUBROUTINE cxios_get_redistribute_scalar_type(redistribute_scalar_hdl, type, type_size) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_scalar_hdl
+      CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: type
+      INTEGER  (kind = C_INT)     , VALUE        :: type_size
+    END SUBROUTINE cxios_get_redistribute_scalar_type
+
+    FUNCTION cxios_is_defined_redistribute_scalar_type(redistribute_scalar_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_redistribute_scalar_type
+      INTEGER (kind = C_INTPTR_T), VALUE :: redistribute_scalar_hdl
+    END FUNCTION cxios_is_defined_redistribute_scalar_type
+
+  END INTERFACE
+
+END MODULE redistribute_scalar_interface_attr
