Index: /XIOS/trunk/inputs/REMAP/iodef.xml
===================================================================
--- /XIOS/trunk/inputs/REMAP/iodef.xml	(revision 665)
+++ /XIOS/trunk/inputs/REMAP/iodef.xml	(revision 666)
@@ -27,5 +27,5 @@
    <domain_definition>
      <domain id="src_domain" />
-     <domain id="dst_domain" >
+     <domain id="dst_domain" domain_ref="src_domain">
        <interpolate_from_file_domain file="weight.nc" />
      </domain>
Index: /XIOS/trunk/src/config/axis_attribute.conf
===================================================================
--- /XIOS/trunk/src/config/axis_attribute.conf	(revision 665)
+++ /XIOS/trunk/src/config/axis_attribute.conf	(revision 666)
@@ -5,8 +5,5 @@
 DECLARE_ATTRIBUTE(StdString, unit)
 
-DECLARE_ATTRIBUTE(int,       size)
-DECLARE_ATTRIBUTE(int,       zoom_begin)
-DECLARE_ATTRIBUTE(int,       zoom_end)
-DECLARE_ATTRIBUTE(int,       zoom_size)
+DECLARE_ATTRIBUTE(int,       n_glo)
 DECLARE_ENUM2(positive, up, down)
 
@@ -22,6 +19,6 @@
 
 /*LOCAL */
-DECLARE_ATTRIBUTE(int,       ibegin)
-DECLARE_ATTRIBUTE(int,       ni)
+DECLARE_ATTRIBUTE(int,       begin)
+DECLARE_ATTRIBUTE(int,       n)
 
 /* LOCAL */
Index: /XIOS/trunk/src/config/domain_attribute.conf
===================================================================
--- /XIOS/trunk/src/config/domain_attribute.conf	(revision 665)
+++ /XIOS/trunk/src/config/domain_attribute.conf	(revision 666)
@@ -37,11 +37,8 @@
 
 /* LOCAL */
-DECLARE_ATTRIBUTE(int             , data_n_index)
 DECLARE_ARRAY(int, 1 , data_i_index)
 DECLARE_ARRAY(int, 1,  data_j_index)
 
 /* LOCAL */
-//DECLARE_ARRAY(double, 1, lonvalue)
-//DECLARE_ARRAY(double, 1, latvalue)
 DECLARE_ARRAY(double, 1, lonvalue_1d)
 DECLARE_ARRAY(double, 1, latvalue_1d)
@@ -50,6 +47,4 @@
 
 DECLARE_ATTRIBUTE(int, nvertex)
-//DECLARE_ARRAY(double, 2, bounds_lon)
-//DECLARE_ARRAY(double, 2, bounds_lat)
 DECLARE_ARRAY(double, 2, bounds_lon_1d)
 DECLARE_ARRAY(double, 2, bounds_lat_1d)
Index: /XIOS/trunk/src/distribution_client.cpp
===================================================================
--- /XIOS/trunk/src/distribution_client.cpp	(revision 665)
+++ /XIOS/trunk/src/distribution_client.cpp	(revision 666)
@@ -99,5 +99,5 @@
   for (int k = 0; k < axisSize; ++k)
   {
-    int n = axisList[k]->ni;
+    int n = axisList[k]->n;
     nIndexAxis_[k].resize(n);
     for (int i = 0; i < n; ++i)
@@ -221,8 +221,8 @@
     else // So it's an axis
     {
-      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->ni.getValue();
-      nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->size.getValue();
+      nLocal_.at(indexMap_[idx]) = axisList[axisIndex]->n.getValue();
+      nGlob_.at(indexMap_[idx]) = axisList[axisIndex]->n_glo.getValue();
       nBeginLocal_.at(indexMap_[idx]) = 0;
-      nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->ibegin.getValue();
+      nBeginGlobal_.at(indexMap_[idx]) = axisList[axisIndex]->begin.getValue();
       nZoomBegin_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin;
       nZoomEnd_.at((indexMap_[idx])) = axisList[axisIndex]->global_zoom_begin + axisList[axisIndex]->global_zoom_size-1;
@@ -636,5 +636,5 @@
 {
    int tempI = dataIndex + dataBegin;
-   return ((tempI-1)%ni);
+   return ((tempI)%ni);
 }
 
Index: /XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp
===================================================================
--- /XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 665)
+++ /XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 666)
@@ -44,4 +44,27 @@
 
 
+  void cxios_set_axis_begin(axis_Ptr axis_hdl, int begin)
+  {
+    CTimer::get("XIOS").resume();
+    axis_hdl->begin.setValue(begin);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_begin(axis_Ptr axis_hdl, int* begin)
+  {
+    CTimer::get("XIOS").resume();
+    *begin = axis_hdl->begin.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_begin(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->begin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axis_bounds(axis_Ptr axis_hdl, double* bounds, int extent1, int extent2)
   {
@@ -140,27 +163,4 @@
 
 
-  void cxios_set_axis_ibegin(axis_Ptr axis_hdl, int ibegin)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->ibegin.setValue(ibegin);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_ibegin(axis_Ptr axis_hdl, int* ibegin)
-  {
-    CTimer::get("XIOS").resume();
-    *ibegin = axis_hdl->ibegin.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_ibegin(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->ibegin.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size)
   {
@@ -214,4 +214,50 @@
 
 
+  void cxios_set_axis_n(axis_Ptr axis_hdl, int n)
+  {
+    CTimer::get("XIOS").resume();
+    axis_hdl->n.setValue(n);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_n(axis_Ptr axis_hdl, int* n)
+  {
+    CTimer::get("XIOS").resume();
+    *n = axis_hdl->n.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_n(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axis_n_glo(axis_Ptr axis_hdl, int n_glo)
+  {
+    CTimer::get("XIOS").resume();
+    axis_hdl->n_glo.setValue(n_glo);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axis_n_glo(axis_Ptr axis_hdl, int* n_glo)
+  {
+    CTimer::get("XIOS").resume();
+    *n_glo = axis_hdl->n_glo.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axis_n_glo(axis_Ptr axis_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axis_hdl->n_glo.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size)
   {
@@ -240,27 +286,4 @@
 
 
-  void cxios_set_axis_ni(axis_Ptr axis_hdl, int ni)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->ni.setValue(ni);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_ni(axis_Ptr axis_hdl, int* ni)
-  {
-    CTimer::get("XIOS").resume();
-    *ni = axis_hdl->ni.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_ni(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->ni.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size)
   {
@@ -289,27 +312,4 @@
 
 
-  void cxios_set_axis_size(axis_Ptr axis_hdl, int size)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->size.setValue(size);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_size(axis_Ptr axis_hdl, int* size)
-  {
-    CTimer::get("XIOS").resume();
-    *size = axis_hdl->size.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_size(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->size.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axis_standard_name(axis_Ptr axis_hdl, const char * standard_name, int standard_name_size)
   {
@@ -387,72 +387,3 @@
      return isDefined;
   }
-
-
-  void cxios_set_axis_zoom_begin(axis_Ptr axis_hdl, int zoom_begin)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->zoom_begin.setValue(zoom_begin);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_zoom_begin(axis_Ptr axis_hdl, int* zoom_begin)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_begin = axis_hdl->zoom_begin.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_zoom_begin(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->zoom_begin.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_axis_zoom_end(axis_Ptr axis_hdl, int zoom_end)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->zoom_end.setValue(zoom_end);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_zoom_end(axis_Ptr axis_hdl, int* zoom_end)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_end = axis_hdl->zoom_end.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_zoom_end(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->zoom_end.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_axis_zoom_size(axis_Ptr axis_hdl, int zoom_size)
-  {
-    CTimer::get("XIOS").resume();
-    axis_hdl->zoom_size.setValue(zoom_size);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axis_zoom_size(axis_Ptr axis_hdl, int* zoom_size)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_size = axis_hdl->zoom_size.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axis_zoom_size(axis_Ptr axis_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axis_hdl->zoom_size.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
 }
Index: /XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp
===================================================================
--- /XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 665)
+++ /XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 666)
@@ -44,4 +44,27 @@
 
 
+  void cxios_set_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int begin)
+  {
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->begin.setValue(begin);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_begin(axisgroup_Ptr axisgroup_hdl, int* begin)
+  {
+    CTimer::get("XIOS").resume();
+    *begin = axisgroup_hdl->begin.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_begin(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->begin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axisgroup_bounds(axisgroup_Ptr axisgroup_hdl, double* bounds, int extent1, int extent2)
   {
@@ -166,27 +189,4 @@
 
 
-  void cxios_set_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int ibegin)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->ibegin.setValue(ibegin);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl, int* ibegin)
-  {
-    CTimer::get("XIOS").resume();
-    *ibegin = axisgroup_hdl->ibegin.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->ibegin.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size)
   {
@@ -240,4 +240,50 @@
 
 
+  void cxios_set_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int n)
+  {
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->n.setValue(n);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_n(axisgroup_Ptr axisgroup_hdl, int* n)
+  {
+    CTimer::get("XIOS").resume();
+    *n = axisgroup_hdl->n.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_n(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int n_glo)
+  {
+    CTimer::get("XIOS").resume();
+    axisgroup_hdl->n_glo.setValue(n_glo);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl, int* n_glo)
+  {
+    CTimer::get("XIOS").resume();
+    *n_glo = axisgroup_hdl->n_glo.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_axisgroup_n_glo(axisgroup_Ptr axisgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = axisgroup_hdl->n_glo.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size)
   {
@@ -266,27 +312,4 @@
 
 
-  void cxios_set_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int ni)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->ni.setValue(ni);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_ni(axisgroup_Ptr axisgroup_hdl, int* ni)
-  {
-    CTimer::get("XIOS").resume();
-    *ni = axisgroup_hdl->ni.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_ni(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->ni.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size)
   {
@@ -315,27 +338,4 @@
 
 
-  void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->size.setValue(size);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int* size)
-  {
-    CTimer::get("XIOS").resume();
-    *size = axisgroup_hdl->size.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_size(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->size.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, const char * standard_name, int standard_name_size)
   {
@@ -413,72 +413,3 @@
      return isDefined;
   }
-
-
-  void cxios_set_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int zoom_begin)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->zoom_begin.setValue(zoom_begin);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl, int* zoom_begin)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_begin = axisgroup_hdl->zoom_begin.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_zoom_begin(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->zoom_begin.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int zoom_end)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->zoom_end.setValue(zoom_end);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl, int* zoom_end)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_end = axisgroup_hdl->zoom_end.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_zoom_end(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->zoom_end.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int zoom_size)
-  {
-    CTimer::get("XIOS").resume();
-    axisgroup_hdl->zoom_size.setValue(zoom_size);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl, int* zoom_size)
-  {
-    CTimer::get("XIOS").resume();
-    *zoom_size = axisgroup_hdl->zoom_size.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_axisgroup_zoom_size(axisgroup_Ptr axisgroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = axisgroup_hdl->zoom_size.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
 }
Index: /XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp
===================================================================
--- /XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 665)
+++ /XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 666)
@@ -262,27 +262,4 @@
 
 
-  void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index)
-  {
-    CTimer::get("XIOS").resume();
-    domain_hdl->data_n_index.setValue(data_n_index);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_data_n_index(domain_Ptr domain_hdl, int* data_n_index)
-  {
-    CTimer::get("XIOS").resume();
-    *data_n_index = domain_hdl->data_n_index.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_data_n_index(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->data_n_index.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
   {
Index: /XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp
===================================================================
--- /XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 665)
+++ /XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 666)
@@ -262,27 +262,4 @@
 
 
-  void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index)
-  {
-    CTimer::get("XIOS").resume();
-    domaingroup_hdl->data_n_index.setValue(data_n_index);
-    CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int* data_n_index)
-  {
-    CTimer::get("XIOS").resume();
-    *data_n_index = domaingroup_hdl->data_n_index.getInheritedValue();
-    CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->data_n_index.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
   void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni)
   {
Index: /XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 666)
@@ -31,4 +31,23 @@
 
 
+    SUBROUTINE cxios_set_axis_begin(axis_hdl, begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: begin
+    END SUBROUTINE cxios_set_axis_begin
+
+    SUBROUTINE cxios_get_axis_begin(axis_hdl, begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)             :: begin
+    END SUBROUTINE cxios_get_axis_begin
+
+    FUNCTION cxios_is_defined_axis_begin(axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_begin
+
+
     SUBROUTINE cxios_set_axis_bounds(axis_hdl, bounds, extent1, extent2) BIND(C)
       USE ISO_C_BINDING
@@ -111,23 +130,4 @@
       INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
     END FUNCTION cxios_is_defined_axis_data_n
-
-
-    SUBROUTINE cxios_set_axis_ibegin(axis_hdl, ibegin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: ibegin
-    END SUBROUTINE cxios_set_axis_ibegin
-
-    SUBROUTINE cxios_get_axis_ibegin(axis_hdl, ibegin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: ibegin
-    END SUBROUTINE cxios_get_axis_ibegin
-
-    FUNCTION cxios_is_defined_axis_ibegin(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_ibegin
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_ibegin
 
 
@@ -174,4 +174,42 @@
 
 
+    SUBROUTINE cxios_set_axis_n(axis_hdl, n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: n
+    END SUBROUTINE cxios_set_axis_n
+
+    SUBROUTINE cxios_get_axis_n(axis_hdl, n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)             :: n
+    END SUBROUTINE cxios_get_axis_n
+
+    FUNCTION cxios_is_defined_axis_n(axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_n
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_n
+
+
+    SUBROUTINE cxios_set_axis_n_glo(axis_hdl, n_glo) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: n_glo
+    END SUBROUTINE cxios_set_axis_n_glo
+
+    SUBROUTINE cxios_get_axis_n_glo(axis_hdl, n_glo) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)             :: n_glo
+    END SUBROUTINE cxios_get_axis_n_glo
+
+    FUNCTION cxios_is_defined_axis_n_glo(axis_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_n_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_n_glo
+
+
     SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C)
       USE ISO_C_BINDING
@@ -195,23 +233,4 @@
 
 
-    SUBROUTINE cxios_set_axis_ni(axis_hdl, ni) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: ni
-    END SUBROUTINE cxios_set_axis_ni
-
-    SUBROUTINE cxios_get_axis_ni(axis_hdl, ni) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: ni
-    END SUBROUTINE cxios_get_axis_ni
-
-    FUNCTION cxios_is_defined_axis_ni(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_ni
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_ni
-
-
     SUBROUTINE cxios_set_axis_positive(axis_hdl, positive, positive_size) BIND(C)
       USE ISO_C_BINDING
@@ -235,23 +254,4 @@
 
 
-    SUBROUTINE cxios_set_axis_size(axis_hdl, size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: size
-    END SUBROUTINE cxios_set_axis_size
-
-    SUBROUTINE cxios_get_axis_size(axis_hdl, size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: size
-    END SUBROUTINE cxios_get_axis_size
-
-    FUNCTION cxios_is_defined_axis_size(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_size
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_size
-
-
     SUBROUTINE cxios_set_axis_standard_name(axis_hdl, standard_name, standard_name_size) BIND(C)
       USE ISO_C_BINDING
@@ -316,61 +316,4 @@
     END FUNCTION cxios_is_defined_axis_value
 
-
-    SUBROUTINE cxios_set_axis_zoom_begin(axis_hdl, zoom_begin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_begin
-    END SUBROUTINE cxios_set_axis_zoom_begin
-
-    SUBROUTINE cxios_get_axis_zoom_begin(axis_hdl, zoom_begin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: zoom_begin
-    END SUBROUTINE cxios_get_axis_zoom_begin
-
-    FUNCTION cxios_is_defined_axis_zoom_begin(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_begin
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_zoom_begin
-
-
-    SUBROUTINE cxios_set_axis_zoom_end(axis_hdl, zoom_end) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_end
-    END SUBROUTINE cxios_set_axis_zoom_end
-
-    SUBROUTINE cxios_get_axis_zoom_end(axis_hdl, zoom_end) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: zoom_end
-    END SUBROUTINE cxios_get_axis_zoom_end
-
-    FUNCTION cxios_is_defined_axis_zoom_end(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_end
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_zoom_end
-
-
-    SUBROUTINE cxios_set_axis_zoom_size(axis_hdl, zoom_size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_size
-    END SUBROUTINE cxios_set_axis_zoom_size
-
-    SUBROUTINE cxios_get_axis_zoom_size(axis_hdl, zoom_size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-      INTEGER (KIND=C_INT)             :: zoom_size
-    END SUBROUTINE cxios_get_axis_zoom_size
-
-    FUNCTION cxios_is_defined_axis_zoom_size(axis_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_zoom_size
-      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
-    END FUNCTION cxios_is_defined_axis_zoom_size
-
   END INTERFACE
 
Index: /XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 666)
@@ -31,4 +31,23 @@
 
 
+    SUBROUTINE cxios_set_axisgroup_begin(axisgroup_hdl, begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: begin
+    END SUBROUTINE cxios_set_axisgroup_begin
+
+    SUBROUTINE cxios_get_axisgroup_begin(axisgroup_hdl, begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)             :: begin
+    END SUBROUTINE cxios_get_axisgroup_begin
+
+    FUNCTION cxios_is_defined_axisgroup_begin(axisgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_begin
+
+
     SUBROUTINE cxios_set_axisgroup_bounds(axisgroup_hdl, bounds, extent1, extent2) BIND(C)
       USE ISO_C_BINDING
@@ -134,23 +153,4 @@
 
 
-    SUBROUTINE cxios_set_axisgroup_ibegin(axisgroup_hdl, ibegin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: ibegin
-    END SUBROUTINE cxios_set_axisgroup_ibegin
-
-    SUBROUTINE cxios_get_axisgroup_ibegin(axisgroup_hdl, ibegin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: ibegin
-    END SUBROUTINE cxios_get_axisgroup_ibegin
-
-    FUNCTION cxios_is_defined_axisgroup_ibegin(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_ibegin
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_ibegin
-
-
     SUBROUTINE cxios_set_axisgroup_long_name(axisgroup_hdl, long_name, long_name_size) BIND(C)
       USE ISO_C_BINDING
@@ -195,4 +195,42 @@
 
 
+    SUBROUTINE cxios_set_axisgroup_n(axisgroup_hdl, n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: n
+    END SUBROUTINE cxios_set_axisgroup_n
+
+    SUBROUTINE cxios_get_axisgroup_n(axisgroup_hdl, n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)             :: n
+    END SUBROUTINE cxios_get_axisgroup_n
+
+    FUNCTION cxios_is_defined_axisgroup_n(axisgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_n
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_n
+
+
+    SUBROUTINE cxios_set_axisgroup_n_glo(axisgroup_hdl, n_glo) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: n_glo
+    END SUBROUTINE cxios_set_axisgroup_n_glo
+
+    SUBROUTINE cxios_get_axisgroup_n_glo(axisgroup_hdl, n_glo) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)             :: n_glo
+    END SUBROUTINE cxios_get_axisgroup_n_glo
+
+    FUNCTION cxios_is_defined_axisgroup_n_glo(axisgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_n_glo
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_n_glo
+
+
     SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C)
       USE ISO_C_BINDING
@@ -216,23 +254,4 @@
 
 
-    SUBROUTINE cxios_set_axisgroup_ni(axisgroup_hdl, ni) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: ni
-    END SUBROUTINE cxios_set_axisgroup_ni
-
-    SUBROUTINE cxios_get_axisgroup_ni(axisgroup_hdl, ni) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: ni
-    END SUBROUTINE cxios_get_axisgroup_ni
-
-    FUNCTION cxios_is_defined_axisgroup_ni(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_ni
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_ni
-
-
     SUBROUTINE cxios_set_axisgroup_positive(axisgroup_hdl, positive, positive_size) BIND(C)
       USE ISO_C_BINDING
@@ -256,23 +275,4 @@
 
 
-    SUBROUTINE cxios_set_axisgroup_size(axisgroup_hdl, size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: size
-    END SUBROUTINE cxios_set_axisgroup_size
-
-    SUBROUTINE cxios_get_axisgroup_size(axisgroup_hdl, size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: size
-    END SUBROUTINE cxios_get_axisgroup_size
-
-    FUNCTION cxios_is_defined_axisgroup_size(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_size
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_size
-
-
     SUBROUTINE cxios_set_axisgroup_standard_name(axisgroup_hdl, standard_name, standard_name_size) BIND(C)
       USE ISO_C_BINDING
@@ -337,61 +337,4 @@
     END FUNCTION cxios_is_defined_axisgroup_value
 
-
-    SUBROUTINE cxios_set_axisgroup_zoom_begin(axisgroup_hdl, zoom_begin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_begin
-    END SUBROUTINE cxios_set_axisgroup_zoom_begin
-
-    SUBROUTINE cxios_get_axisgroup_zoom_begin(axisgroup_hdl, zoom_begin) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: zoom_begin
-    END SUBROUTINE cxios_get_axisgroup_zoom_begin
-
-    FUNCTION cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_begin
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_zoom_begin
-
-
-    SUBROUTINE cxios_set_axisgroup_zoom_end(axisgroup_hdl, zoom_end) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_end
-    END SUBROUTINE cxios_set_axisgroup_zoom_end
-
-    SUBROUTINE cxios_get_axisgroup_zoom_end(axisgroup_hdl, zoom_end) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: zoom_end
-    END SUBROUTINE cxios_get_axisgroup_zoom_end
-
-    FUNCTION cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_end
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_zoom_end
-
-
-    SUBROUTINE cxios_set_axisgroup_zoom_size(axisgroup_hdl, zoom_size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: zoom_size
-    END SUBROUTINE cxios_set_axisgroup_zoom_size
-
-    SUBROUTINE cxios_get_axisgroup_zoom_size(axisgroup_hdl, zoom_size) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-      INTEGER (KIND=C_INT)             :: zoom_size
-    END SUBROUTINE cxios_get_axisgroup_zoom_size
-
-    FUNCTION cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_zoom_size
-      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
-    END FUNCTION cxios_is_defined_axisgroup_zoom_size
-
   END INTERFACE
 
Index: /XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 666)
@@ -228,23 +228,4 @@
 
 
-    SUBROUTINE cxios_set_domain_data_n_index(domain_hdl, data_n_index) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: data_n_index
-    END SUBROUTINE cxios_set_domain_data_n_index
-
-    SUBROUTINE cxios_get_domain_data_n_index(domain_hdl, data_n_index) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-      INTEGER (KIND=C_INT)             :: data_n_index
-    END SUBROUTINE cxios_get_domain_data_n_index
-
-    FUNCTION cxios_is_defined_domain_data_n_index(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_data_n_index
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_data_n_index
-
-
     SUBROUTINE cxios_set_domain_data_ni(domain_hdl, data_ni) BIND(C)
       USE ISO_C_BINDING
Index: /XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 666)
@@ -228,23 +228,4 @@
 
 
-    SUBROUTINE cxios_set_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-      INTEGER (KIND=C_INT)      , VALUE :: data_n_index
-    END SUBROUTINE cxios_set_domaingroup_data_n_index
-
-    SUBROUTINE cxios_get_domaingroup_data_n_index(domaingroup_hdl, data_n_index) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-      INTEGER (KIND=C_INT)             :: data_n_index
-    END SUBROUTINE cxios_get_domaingroup_data_n_index
-
-    FUNCTION cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_data_n_index
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_data_n_index
-
-
     SUBROUTINE cxios_set_domaingroup_data_ni(domaingroup_hdl, data_ni) BIND(C)
       USE ISO_C_BINDING
Index: /XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 666)
@@ -12,6 +12,6 @@
 
   SUBROUTINE xios(set_axis_attr)  &
-    ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  &
-    , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -19,88 +19,78 @@
       CHARACTER(LEN=*), INTENT(IN) ::axis_id
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
       INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
-      INTEGER  , OPTIONAL, INTENT(IN) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size
 
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(set_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(set_axis_attr)
 
   SUBROUTINE xios(set_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-    , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
       INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
-      INTEGER  , OPTIONAL, INTENT(IN) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size
 
       CALL xios(set_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(set_axis_attr_hdl)
 
   SUBROUTINE xios(set_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  &
-    , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  &
-     )
+    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  &
+    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_
-      INTEGER  , OPTIONAL, INTENT(IN) :: size_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin_
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end_
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size_
 
       IF (PRESENT(axis_ref_)) THEN
@@ -108,4 +98,8 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        CALL cxios_set_axis_begin(axis_hdl%daddr, begin_)
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         CALL cxios_set_axis_bounds(axis_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2))
@@ -122,8 +116,4 @@
       IF (PRESENT(data_n_)) THEN
         CALL cxios_set_axis_data_n(axis_hdl%daddr, data_n_)
-      ENDIF
-
-      IF (PRESENT(ibegin_)) THEN
-        CALL cxios_set_axis_ibegin(axis_hdl%daddr, ibegin_)
       ENDIF
 
@@ -138,20 +128,20 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        CALL cxios_set_axis_n(axis_hdl%daddr, n_)
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        CALL cxios_set_axis_n_glo(axis_hdl%daddr, n_glo_)
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         CALL cxios_set_axis_name(axis_hdl%daddr, name_, len(name_))
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        CALL cxios_set_axis_ni(axis_hdl%daddr, ni_)
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         CALL cxios_set_axis_positive(axis_hdl%daddr, positive_, len(positive_))
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        CALL cxios_set_axis_size(axis_hdl%daddr, size_)
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         CALL cxios_set_axis_standard_name(axis_hdl%daddr, standard_name_, len(standard_name_))
@@ -166,21 +156,9 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        CALL cxios_set_axis_zoom_begin(axis_hdl%daddr, zoom_begin_)
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        CALL cxios_set_axis_zoom_end(axis_hdl%daddr, zoom_end_)
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        CALL cxios_set_axis_zoom_size(axis_hdl%daddr, zoom_size_)
-      ENDIF
-
   END SUBROUTINE xios(set_axis_attr_hdl_)
 
   SUBROUTINE xios(get_axis_attr)  &
-    ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  &
-    , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -188,88 +166,78 @@
       CHARACTER(LEN=*), INTENT(IN) ::axis_id
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size
 
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(get_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(get_axis_attr)
 
   SUBROUTINE xios(get_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-    , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size
 
       CALL xios(get_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(get_axis_attr_hdl)
 
   SUBROUTINE xios(get_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  &
-    , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  &
-     )
+    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  &
+    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size_
 
       IF (PRESENT(axis_ref_)) THEN
@@ -277,4 +245,8 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        CALL cxios_get_axis_begin(axis_hdl%daddr, begin_)
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         CALL cxios_get_axis_bounds(axis_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2))
@@ -291,8 +263,4 @@
       IF (PRESENT(data_n_)) THEN
         CALL cxios_get_axis_data_n(axis_hdl%daddr, data_n_)
-      ENDIF
-
-      IF (PRESENT(ibegin_)) THEN
-        CALL cxios_get_axis_ibegin(axis_hdl%daddr, ibegin_)
       ENDIF
 
@@ -307,20 +275,20 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        CALL cxios_get_axis_n(axis_hdl%daddr, n_)
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        CALL cxios_get_axis_n_glo(axis_hdl%daddr, n_glo_)
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         CALL cxios_get_axis_name(axis_hdl%daddr, name_, len(name_))
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        CALL cxios_get_axis_ni(axis_hdl%daddr, ni_)
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         CALL cxios_get_axis_positive(axis_hdl%daddr, positive_, len(positive_))
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        CALL cxios_get_axis_size(axis_hdl%daddr, size_)
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         CALL cxios_get_axis_standard_name(axis_hdl%daddr, standard_name_, len(standard_name_))
@@ -335,21 +303,9 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        CALL cxios_get_axis_zoom_begin(axis_hdl%daddr, zoom_begin_)
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        CALL cxios_get_axis_zoom_end(axis_hdl%daddr, zoom_end_)
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        CALL cxios_get_axis_zoom_size(axis_hdl%daddr, zoom_size_)
-      ENDIF
-
   END SUBROUTINE xios(get_axis_attr_hdl_)
 
   SUBROUTINE xios(is_defined_axis_attr)  &
-    ( axis_id, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni  &
-    , positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_id, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -358,4 +314,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin
+      LOGICAL(KIND=C_BOOL) :: begin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds
       LOGICAL(KIND=C_BOOL) :: bounds_tmp
@@ -366,18 +324,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n
       LOGICAL(KIND=C_BOOL) :: data_n_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
-      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask
       LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n
+      LOGICAL(KIND=C_BOOL) :: n_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo
+      LOGICAL(KIND=C_BOOL) :: n_glo_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
-      LOGICAL(KIND=C_BOOL) :: ni_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive
       LOGICAL(KIND=C_BOOL) :: positive_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size
-      LOGICAL(KIND=C_BOOL) :: size_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
@@ -386,21 +342,15 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value
       LOGICAL(KIND=C_BOOL) :: value_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
-      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
-      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
-      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
 
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(is_defined_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(is_defined_axis_attr)
 
   SUBROUTINE xios(is_defined_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-    , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+    , name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -408,4 +358,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin
+      LOGICAL(KIND=C_BOOL) :: begin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds
       LOGICAL(KIND=C_BOOL) :: bounds_tmp
@@ -416,18 +368,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n
       LOGICAL(KIND=C_BOOL) :: data_n_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
-      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask
       LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n
+      LOGICAL(KIND=C_BOOL) :: n_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo
+      LOGICAL(KIND=C_BOOL) :: n_glo_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
-      LOGICAL(KIND=C_BOOL) :: ni_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive
       LOGICAL(KIND=C_BOOL) :: positive_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size
-      LOGICAL(KIND=C_BOOL) :: size_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
@@ -436,21 +386,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value
       LOGICAL(KIND=C_BOOL) :: value_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
-      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
-      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
-      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
 
       CALL xios(is_defined_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, bounds, data_begin, data_index, data_n, ibegin, long_name, mask, name  &
-      , ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, long_name, mask, n, n_glo  &
+      , name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(is_defined_axis_attr_hdl)
 
   SUBROUTINE xios(is_defined_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_  &
-    , name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_  &
-     )
+    ( axis_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, long_name_, mask_  &
+    , n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
@@ -458,4 +401,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
       LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_
+      LOGICAL(KIND=C_BOOL) :: begin__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_
       LOGICAL(KIND=C_BOOL) :: bounds__tmp
@@ -466,18 +411,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_
       LOGICAL(KIND=C_BOOL) :: data_n__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_
-      LOGICAL(KIND=C_BOOL) :: ibegin__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL(KIND=C_BOOL) :: long_name__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
       LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_
+      LOGICAL(KIND=C_BOOL) :: n__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo_
+      LOGICAL(KIND=C_BOOL) :: n_glo__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_
-      LOGICAL(KIND=C_BOOL) :: ni__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive_
       LOGICAL(KIND=C_BOOL) :: positive__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size_
-      LOGICAL(KIND=C_BOOL) :: size__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
       LOGICAL(KIND=C_BOOL) :: standard_name__tmp
@@ -486,10 +429,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value_
       LOGICAL(KIND=C_BOOL) :: value__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_
-      LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_
-      LOGICAL(KIND=C_BOOL) :: zoom_end__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_
-      LOGICAL(KIND=C_BOOL) :: zoom_size__tmp
 
       IF (PRESENT(axis_ref_)) THEN
@@ -498,4 +435,9 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        begin__tmp = cxios_is_defined_axis_begin(axis_hdl%daddr)
+        begin_ = begin__tmp
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         bounds__tmp = cxios_is_defined_axis_bounds(axis_hdl%daddr)
@@ -518,9 +460,4 @@
       ENDIF
 
-      IF (PRESENT(ibegin_)) THEN
-        ibegin__tmp = cxios_is_defined_axis_ibegin(axis_hdl%daddr)
-        ibegin_ = ibegin__tmp
-      ENDIF
-
       IF (PRESENT(long_name_)) THEN
         long_name__tmp = cxios_is_defined_axis_long_name(axis_hdl%daddr)
@@ -533,4 +470,14 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        n__tmp = cxios_is_defined_axis_n(axis_hdl%daddr)
+        n_ = n__tmp
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        n_glo__tmp = cxios_is_defined_axis_n_glo(axis_hdl%daddr)
+        n_glo_ = n_glo__tmp
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         name__tmp = cxios_is_defined_axis_name(axis_hdl%daddr)
@@ -538,9 +485,4 @@
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        ni__tmp = cxios_is_defined_axis_ni(axis_hdl%daddr)
-        ni_ = ni__tmp
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         positive__tmp = cxios_is_defined_axis_positive(axis_hdl%daddr)
@@ -548,9 +490,4 @@
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        size__tmp = cxios_is_defined_axis_size(axis_hdl%daddr)
-        size_ = size__tmp
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         standard_name__tmp = cxios_is_defined_axis_standard_name(axis_hdl%daddr)
@@ -568,19 +505,4 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        zoom_begin__tmp = cxios_is_defined_axis_zoom_begin(axis_hdl%daddr)
-        zoom_begin_ = zoom_begin__tmp
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        zoom_end__tmp = cxios_is_defined_axis_zoom_end(axis_hdl%daddr)
-        zoom_end_ = zoom_end__tmp
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        zoom_size__tmp = cxios_is_defined_axis_zoom_size(axis_hdl%daddr)
-        zoom_size_ = zoom_size__tmp
-      ENDIF
-
   END SUBROUTINE xios(is_defined_axis_attr_hdl_)
 
Index: /XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 666)
@@ -12,7 +12,6 @@
 
   SUBROUTINE xios(set_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -20,4 +19,5 @@
       CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -25,35 +25,30 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
-      INTEGER  , OPTIONAL, INTENT(IN) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size
 
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(set_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(set_axisgroup_attr)
 
   SUBROUTINE xios(set_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
@@ -61,34 +56,29 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
-      INTEGER  , OPTIONAL, INTENT(IN) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size
 
       CALL xios(set_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(set_axisgroup_attr_hdl)
 
   SUBROUTINE xios(set_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  &
-    , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  &
+    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(IN) :: begin_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_(:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_
@@ -96,18 +86,14 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_n_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
-      INTEGER  , OPTIONAL, INTENT(IN) :: ibegin_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_
+      INTEGER  , OPTIONAL, INTENT(IN) :: n_glo_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
-      INTEGER  , OPTIONAL, INTENT(IN) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_
-      INTEGER  , OPTIONAL, INTENT(IN) :: size_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: unit_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: value_(:)
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_begin_
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_end_
-      INTEGER  , OPTIONAL, INTENT(IN) :: zoom_size_
 
       IF (PRESENT(axis_ref_)) THEN
@@ -115,4 +101,8 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        CALL cxios_set_axisgroup_begin(axisgroup_hdl%daddr, begin_)
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         CALL cxios_set_axisgroup_bounds(axisgroup_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2))
@@ -133,8 +123,4 @@
       IF (PRESENT(group_ref_)) THEN
         CALL cxios_set_axisgroup_group_ref(axisgroup_hdl%daddr, group_ref_, len(group_ref_))
-      ENDIF
-
-      IF (PRESENT(ibegin_)) THEN
-        CALL cxios_set_axisgroup_ibegin(axisgroup_hdl%daddr, ibegin_)
       ENDIF
 
@@ -149,20 +135,20 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        CALL cxios_set_axisgroup_n(axisgroup_hdl%daddr, n_)
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        CALL cxios_set_axisgroup_n_glo(axisgroup_hdl%daddr, n_glo_)
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         CALL cxios_set_axisgroup_name(axisgroup_hdl%daddr, name_, len(name_))
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        CALL cxios_set_axisgroup_ni(axisgroup_hdl%daddr, ni_)
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         CALL cxios_set_axisgroup_positive(axisgroup_hdl%daddr, positive_, len(positive_))
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        CALL cxios_set_axisgroup_size(axisgroup_hdl%daddr, size_)
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         CALL cxios_set_axisgroup_standard_name(axisgroup_hdl%daddr, standard_name_, len(standard_name_))
@@ -177,22 +163,9 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        CALL cxios_set_axisgroup_zoom_begin(axisgroup_hdl%daddr, zoom_begin_)
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        CALL cxios_set_axisgroup_zoom_end(axisgroup_hdl%daddr, zoom_end_)
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        CALL cxios_set_axisgroup_zoom_size(axisgroup_hdl%daddr, zoom_size_)
-      ENDIF
-
   END SUBROUTINE xios(set_axisgroup_attr_hdl_)
 
   SUBROUTINE xios(get_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -200,4 +173,5 @@
       CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -205,35 +179,30 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size
 
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(get_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(get_axisgroup_attr)
 
   SUBROUTINE xios(get_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
@@ -241,34 +210,29 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size
 
       CALL xios(get_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(get_axisgroup_attr_hdl)
 
   SUBROUTINE xios(get_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  &
-    , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  &
+    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: begin_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_(:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_
@@ -276,18 +240,14 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ibegin_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:)
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: n_glo_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: size_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: unit_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: value_(:)
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_begin_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_end_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: zoom_size_
 
       IF (PRESENT(axis_ref_)) THEN
@@ -295,4 +255,8 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        CALL cxios_get_axisgroup_begin(axisgroup_hdl%daddr, begin_)
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         CALL cxios_get_axisgroup_bounds(axisgroup_hdl%daddr, bounds_, size(bounds_,1), size(bounds_,2))
@@ -313,8 +277,4 @@
       IF (PRESENT(group_ref_)) THEN
         CALL cxios_get_axisgroup_group_ref(axisgroup_hdl%daddr, group_ref_, len(group_ref_))
-      ENDIF
-
-      IF (PRESENT(ibegin_)) THEN
-        CALL cxios_get_axisgroup_ibegin(axisgroup_hdl%daddr, ibegin_)
       ENDIF
 
@@ -329,20 +289,20 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        CALL cxios_get_axisgroup_n(axisgroup_hdl%daddr, n_)
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        CALL cxios_get_axisgroup_n_glo(axisgroup_hdl%daddr, n_glo_)
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         CALL cxios_get_axisgroup_name(axisgroup_hdl%daddr, name_, len(name_))
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        CALL cxios_get_axisgroup_ni(axisgroup_hdl%daddr, ni_)
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         CALL cxios_get_axisgroup_positive(axisgroup_hdl%daddr, positive_, len(positive_))
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        CALL cxios_get_axisgroup_size(axisgroup_hdl%daddr, size_)
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         CALL cxios_get_axisgroup_standard_name(axisgroup_hdl%daddr, standard_name_, len(standard_name_))
@@ -357,22 +317,9 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        CALL cxios_get_axisgroup_zoom_begin(axisgroup_hdl%daddr, zoom_begin_)
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        CALL cxios_get_axisgroup_zoom_end(axisgroup_hdl%daddr, zoom_end_)
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        CALL cxios_get_axisgroup_zoom_size(axisgroup_hdl%daddr, zoom_size_)
-      ENDIF
-
   END SUBROUTINE xios(get_axisgroup_attr_hdl_)
 
   SUBROUTINE xios(is_defined_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_id, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -381,4 +328,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin
+      LOGICAL(KIND=C_BOOL) :: begin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds
       LOGICAL(KIND=C_BOOL) :: bounds_tmp
@@ -391,18 +340,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
-      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask
       LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n
+      LOGICAL(KIND=C_BOOL) :: n_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo
+      LOGICAL(KIND=C_BOOL) :: n_glo_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
-      LOGICAL(KIND=C_BOOL) :: ni_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive
       LOGICAL(KIND=C_BOOL) :: positive_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size
-      LOGICAL(KIND=C_BOOL) :: size_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
@@ -411,23 +358,15 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value
       LOGICAL(KIND=C_BOOL) :: value_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
-      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
-      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
-      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
 
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(is_defined_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(is_defined_axisgroup_attr)
 
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-    , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-     )
+    ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+    , mask, n, n_glo, name, positive, standard_name, unit, value )
 
     IMPLICIT NONE
@@ -435,4 +374,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin
+      LOGICAL(KIND=C_BOOL) :: begin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds
       LOGICAL(KIND=C_BOOL) :: bounds_tmp
@@ -445,18 +386,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin
-      LOGICAL(KIND=C_BOOL) :: ibegin_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask
       LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n
+      LOGICAL(KIND=C_BOOL) :: n_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo
+      LOGICAL(KIND=C_BOOL) :: n_glo_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni
-      LOGICAL(KIND=C_BOOL) :: ni_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive
       LOGICAL(KIND=C_BOOL) :: positive_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size
-      LOGICAL(KIND=C_BOOL) :: size_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
@@ -465,22 +404,14 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value
       LOGICAL(KIND=C_BOOL) :: value_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin
-      LOGICAL(KIND=C_BOOL) :: zoom_begin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end
-      LOGICAL(KIND=C_BOOL) :: zoom_end_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size
-      LOGICAL(KIND=C_BOOL) :: zoom_size_tmp
 
       CALL xios(is_defined_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, bounds, data_begin, data_index, data_n, group_ref, ibegin, long_name  &
-      , mask, name, ni, positive, size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size  &
-       )
+      ( axisgroup_hdl, axis_ref, begin, bounds, data_begin, data_index, data_n, group_ref, long_name  &
+      , mask, n, n_glo, name, positive, standard_name, unit, value )
 
   END SUBROUTINE xios(is_defined_axisgroup_attr_hdl)
 
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, bounds_, data_begin_, data_index_, data_n_, group_ref_, ibegin_  &
-    , long_name_, mask_, name_, ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, begin_, bounds_, data_begin_, data_index_, data_n_, group_ref_, long_name_  &
+    , mask_, n_, n_glo_, name_, positive_, standard_name_, unit_, value_ )
 
     IMPLICIT NONE
@@ -488,4 +419,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
       LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: begin_
+      LOGICAL(KIND=C_BOOL) :: begin__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_
       LOGICAL(KIND=C_BOOL) :: bounds__tmp
@@ -498,18 +431,16 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
       LOGICAL(KIND=C_BOOL) :: group_ref__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ibegin_
-      LOGICAL(KIND=C_BOOL) :: ibegin__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL(KIND=C_BOOL) :: long_name__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
       LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_
+      LOGICAL(KIND=C_BOOL) :: n__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: n_glo_
+      LOGICAL(KIND=C_BOOL) :: n_glo__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: ni_
-      LOGICAL(KIND=C_BOOL) :: ni__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: positive_
       LOGICAL(KIND=C_BOOL) :: positive__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: size_
-      LOGICAL(KIND=C_BOOL) :: size__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
       LOGICAL(KIND=C_BOOL) :: standard_name__tmp
@@ -518,10 +449,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: value_
       LOGICAL(KIND=C_BOOL) :: value__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_begin_
-      LOGICAL(KIND=C_BOOL) :: zoom_begin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_end_
-      LOGICAL(KIND=C_BOOL) :: zoom_end__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: zoom_size_
-      LOGICAL(KIND=C_BOOL) :: zoom_size__tmp
 
       IF (PRESENT(axis_ref_)) THEN
@@ -530,4 +455,9 @@
       ENDIF
 
+      IF (PRESENT(begin_)) THEN
+        begin__tmp = cxios_is_defined_axisgroup_begin(axisgroup_hdl%daddr)
+        begin_ = begin__tmp
+      ENDIF
+
       IF (PRESENT(bounds_)) THEN
         bounds__tmp = cxios_is_defined_axisgroup_bounds(axisgroup_hdl%daddr)
@@ -555,9 +485,4 @@
       ENDIF
 
-      IF (PRESENT(ibegin_)) THEN
-        ibegin__tmp = cxios_is_defined_axisgroup_ibegin(axisgroup_hdl%daddr)
-        ibegin_ = ibegin__tmp
-      ENDIF
-
       IF (PRESENT(long_name_)) THEN
         long_name__tmp = cxios_is_defined_axisgroup_long_name(axisgroup_hdl%daddr)
@@ -570,4 +495,14 @@
       ENDIF
 
+      IF (PRESENT(n_)) THEN
+        n__tmp = cxios_is_defined_axisgroup_n(axisgroup_hdl%daddr)
+        n_ = n__tmp
+      ENDIF
+
+      IF (PRESENT(n_glo_)) THEN
+        n_glo__tmp = cxios_is_defined_axisgroup_n_glo(axisgroup_hdl%daddr)
+        n_glo_ = n_glo__tmp
+      ENDIF
+
       IF (PRESENT(name_)) THEN
         name__tmp = cxios_is_defined_axisgroup_name(axisgroup_hdl%daddr)
@@ -575,9 +510,4 @@
       ENDIF
 
-      IF (PRESENT(ni_)) THEN
-        ni__tmp = cxios_is_defined_axisgroup_ni(axisgroup_hdl%daddr)
-        ni_ = ni__tmp
-      ENDIF
-
       IF (PRESENT(positive_)) THEN
         positive__tmp = cxios_is_defined_axisgroup_positive(axisgroup_hdl%daddr)
@@ -585,9 +515,4 @@
       ENDIF
 
-      IF (PRESENT(size_)) THEN
-        size__tmp = cxios_is_defined_axisgroup_size(axisgroup_hdl%daddr)
-        size_ = size__tmp
-      ENDIF
-
       IF (PRESENT(standard_name_)) THEN
         standard_name__tmp = cxios_is_defined_axisgroup_standard_name(axisgroup_hdl%daddr)
@@ -605,19 +530,4 @@
       ENDIF
 
-      IF (PRESENT(zoom_begin_)) THEN
-        zoom_begin__tmp = cxios_is_defined_axisgroup_zoom_begin(axisgroup_hdl%daddr)
-        zoom_begin_ = zoom_begin__tmp
-      ENDIF
-
-      IF (PRESENT(zoom_end_)) THEN
-        zoom_end__tmp = cxios_is_defined_axisgroup_zoom_end(axisgroup_hdl%daddr)
-        zoom_end_ = zoom_end__tmp
-      ENDIF
-
-      IF (PRESENT(zoom_size_)) THEN
-        zoom_size__tmp = cxios_is_defined_axisgroup_zoom_size(axisgroup_hdl%daddr)
-        zoom_size_ = zoom_size__tmp
-      ENDIF
-
   END SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)
 
Index: /XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 666)
@@ -13,7 +13,7 @@
   SUBROUTINE xios(set_domain_attr)  &
     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -30,5 +30,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj
@@ -60,7 +59,7 @@
       CALL xios(set_domain_attr_hdl_)   &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(set_domain_attr)
@@ -68,7 +67,7 @@
   SUBROUTINE xios(set_domain_attr_hdl)  &
     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -84,5 +83,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj
@@ -113,7 +111,7 @@
       CALL xios(set_domain_attr_hdl_)  &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(set_domain_attr_hdl)
@@ -121,8 +119,8 @@
   SUBROUTINE xios(set_domain_attr_hdl_)   &
     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
-    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
-    , nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  &
+    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  &
+    , standard_name_, type_ )
 
     IMPLICIT NONE
@@ -138,5 +136,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index_(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin_
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_
@@ -205,8 +202,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        CALL cxios_set_domain_data_n_index(domain_hdl%daddr, data_n_index_)
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         CALL cxios_set_domain_data_ni(domain_hdl%daddr, data_ni_)
@@ -309,7 +302,7 @@
   SUBROUTINE xios(get_domain_attr)  &
     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -326,5 +319,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj
@@ -356,7 +348,7 @@
       CALL xios(get_domain_attr_hdl_)   &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(get_domain_attr)
@@ -364,7 +356,7 @@
   SUBROUTINE xios(get_domain_attr_hdl)  &
     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -380,5 +372,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj
@@ -409,7 +400,7 @@
       CALL xios(get_domain_attr_hdl_)  &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(get_domain_attr_hdl)
@@ -417,8 +408,8 @@
   SUBROUTINE xios(get_domain_attr_hdl_)   &
     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
-    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
-    , nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  &
+    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  &
+    , standard_name_, type_ )
 
     IMPLICIT NONE
@@ -434,5 +425,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index_(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj_
@@ -501,8 +491,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        CALL cxios_get_domain_data_n_index(domain_hdl%daddr, data_n_index_)
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         CALL cxios_get_domain_data_ni(domain_hdl%daddr, data_ni_)
@@ -605,7 +591,7 @@
   SUBROUTINE xios(is_defined_domain_attr)  &
     ( domain_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -632,6 +618,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
       LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
-      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
       LOGICAL(KIND=C_BOOL) :: data_ni_tmp
@@ -684,7 +668,7 @@
       CALL xios(is_defined_domain_attr_hdl_)   &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domain_attr)
@@ -692,7 +676,7 @@
   SUBROUTINE xios(is_defined_domain_attr_hdl)  &
     ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-    , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-    , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-    , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+    , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+    , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+    , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
     IMPLICIT NONE
@@ -718,6 +702,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
       LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
-      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
       LOGICAL(KIND=C_BOOL) :: data_ni_tmp
@@ -769,7 +751,7 @@
       CALL xios(is_defined_domain_attr_hdl_)  &
       ( domain_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim, data_i_index  &
-      , data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref, domain_ref  &
-      , i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d  &
-      , mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
+      , data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref, i_index  &
+      , ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d, lonvalue_2d, mask_1d  &
+      , mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type )
 
   END SUBROUTINE xios(is_defined_domain_attr_hdl)
@@ -777,8 +759,8 @@
   SUBROUTINE xios(is_defined_domain_attr_hdl_)   &
     ( domain_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
-    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
-    , nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_, long_name_  &
+    , lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_  &
+    , standard_name_, type_ )
 
     IMPLICIT NONE
@@ -804,6 +786,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_
       LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_
-      LOGICAL(KIND=C_BOOL) :: data_n_index__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_
       LOGICAL(KIND=C_BOOL) :: data_ni__tmp
@@ -903,9 +883,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        data_n_index__tmp = cxios_is_defined_domain_data_n_index(domain_hdl%daddr)
-        data_n_index_ = data_n_index__tmp
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         data_ni__tmp = cxios_is_defined_domain_data_ni(domain_hdl%daddr)
Index: /XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90
===================================================================
--- /XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 665)
+++ /XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 666)
@@ -13,8 +13,8 @@
   SUBROUTINE xios(set_domaingroup_attr)  &
     ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -31,5 +31,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj
@@ -62,8 +61,8 @@
       CALL xios(set_domaingroup_attr_hdl_)   &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(set_domaingroup_attr)
@@ -71,8 +70,8 @@
   SUBROUTINE xios(set_domaingroup_attr_hdl)  &
     ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -88,5 +87,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj
@@ -118,8 +116,8 @@
       CALL xios(set_domaingroup_attr_hdl_)  &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(set_domaingroup_attr_hdl)
@@ -127,8 +125,8 @@
   SUBROUTINE xios(set_domaingroup_attr_hdl_)   &
     ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  &
-    , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
-    , nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
+    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
+    , nvertex_, standard_name_, type_ )
 
     IMPLICIT NONE
@@ -144,5 +142,4 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: data_j_index_(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_jbegin_
-      INTEGER  , OPTIONAL, INTENT(IN) :: data_n_index_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_ni_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_nj_
@@ -212,8 +209,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        CALL cxios_set_domaingroup_data_n_index(domaingroup_hdl%daddr, data_n_index_)
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         CALL cxios_set_domaingroup_data_ni(domaingroup_hdl%daddr, data_ni_)
@@ -320,8 +313,8 @@
   SUBROUTINE xios(get_domaingroup_attr)  &
     ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -338,5 +331,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj
@@ -369,8 +361,8 @@
       CALL xios(get_domaingroup_attr_hdl_)   &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(get_domaingroup_attr)
@@ -378,8 +370,8 @@
   SUBROUTINE xios(get_domaingroup_attr_hdl)  &
     ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -395,5 +387,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj
@@ -425,8 +416,8 @@
       CALL xios(get_domaingroup_attr_hdl_)  &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(get_domaingroup_attr_hdl)
@@ -434,8 +425,8 @@
   SUBROUTINE xios(get_domaingroup_attr_hdl_)   &
     ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  &
-    , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
-    , nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
+    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
+    , nvertex_, standard_name_, type_ )
 
     IMPLICIT NONE
@@ -451,5 +442,4 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_j_index_(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_jbegin_
-      INTEGER  , OPTIONAL, INTENT(OUT) :: data_n_index_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_ni_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_nj_
@@ -519,8 +509,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        CALL cxios_get_domaingroup_data_n_index(domaingroup_hdl%daddr, data_n_index_)
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         CALL cxios_get_domaingroup_data_ni(domaingroup_hdl%daddr, data_ni_)
@@ -627,8 +613,8 @@
   SUBROUTINE xios(is_defined_domaingroup_attr)  &
     ( domaingroup_id, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -655,6 +641,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
       LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
-      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
       LOGICAL(KIND=C_BOOL) :: data_ni_tmp
@@ -709,8 +693,8 @@
       CALL xios(is_defined_domaingroup_attr_hdl_)   &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr)
@@ -718,8 +702,8 @@
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  &
     ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-    , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-    , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-    , type )
+    , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+    , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+    , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+     )
 
     IMPLICIT NONE
@@ -745,6 +729,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin
       LOGICAL(KIND=C_BOOL) :: data_jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index
-      LOGICAL(KIND=C_BOOL) :: data_n_index_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni
       LOGICAL(KIND=C_BOOL) :: data_ni_tmp
@@ -798,8 +780,8 @@
       CALL xios(is_defined_domaingroup_attr_hdl_)  &
       ( domaingroup_hdl, area, bounds_lat_1d, bounds_lat_2d, bounds_lon_1d, bounds_lon_2d, data_dim  &
-      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_n_index, data_ni, data_nj, domain_group_ref  &
-      , domain_ref, group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name  &
-      , lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name  &
-      , type )
+      , data_i_index, data_ibegin, data_j_index, data_jbegin, data_ni, data_nj, domain_group_ref, domain_ref  &
+      , group_ref, i_index, ibegin, j_index, jbegin, latvalue_1d, latvalue_2d, long_name, lonvalue_1d  &
+      , lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo, nj, nj_glo, nvertex, standard_name, type  &
+       )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr_hdl)
@@ -807,8 +789,8 @@
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   &
     ( domaingroup_hdl, area_, bounds_lat_1d_, bounds_lat_2d_, bounds_lon_1d_, bounds_lon_2d_, data_dim_  &
-    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_n_index_, data_ni_, data_nj_  &
-    , domain_group_ref_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_  &
-    , latvalue_2d_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_  &
-    , nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    , data_i_index_, data_ibegin_, data_j_index_, data_jbegin_, data_ni_, data_nj_, domain_group_ref_  &
+    , domain_ref_, group_ref_, i_index_, ibegin_, j_index_, jbegin_, latvalue_1d_, latvalue_2d_  &
+    , long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_  &
+    , nvertex_, standard_name_, type_ )
 
     IMPLICIT NONE
@@ -834,6 +816,4 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_jbegin_
       LOGICAL(KIND=C_BOOL) :: data_jbegin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_index_
-      LOGICAL(KIND=C_BOOL) :: data_n_index__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_ni_
       LOGICAL(KIND=C_BOOL) :: data_ni__tmp
@@ -935,9 +915,4 @@
       ENDIF
 
-      IF (PRESENT(data_n_index_)) THEN
-        data_n_index__tmp = cxios_is_defined_domaingroup_data_n_index(domaingroup_hdl%daddr)
-        data_n_index_ = data_n_index__tmp
-      ENDIF
-
       IF (PRESENT(data_ni_)) THEN
         data_ni__tmp = cxios_is_defined_domaingroup_data_ni(domaingroup_hdl%daddr)
Index: /XIOS/trunk/src/node/axis.cpp
===================================================================
--- /XIOS/trunk/src/node/axis.cpp	(revision 665)
+++ /XIOS/trunk/src/node/axis.cpp	(revision 666)
@@ -76,31 +76,31 @@
    void CAxis::checkAttributes(void)
    {
-      if (this->size.isEmpty())
+      if (this->n_glo.isEmpty())
          ERROR("CAxis::checkAttributes(void)",
-               << "Attribute <size> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be specified");
-      StdSize size = this->size.getValue();
-
-      isDistributed_ = !this->ibegin.isEmpty() || !this->ni.isEmpty();
-
-      if (!this->ibegin.isEmpty())
-      {
-        StdSize ibegin = this->ibegin.getValue();
+               << "Attribute <n_glo> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be specified");
+      StdSize size = this->n_glo.getValue();
+
+      isDistributed_ = !this->begin.isEmpty() || !this->n.isEmpty();
+
+      if (!this->begin.isEmpty())
+      {
+        StdSize ibegin = this->begin.getValue();
         if ((ibegin < 0) || (ibegin > size-1))
           ERROR("CAxis::checkAttributes(void)",
                 << "Attribute <ibegin> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size-1");
       }
-      else this->ibegin.setValue(0);
-
-      if (!this->ni.isEmpty())
-      {
-        StdSize ni = this->ni.getValue();
+      else this->begin.setValue(0);
+
+      if (!this->n.isEmpty())
+      {
+        StdSize ni = this->n.getValue();
         if ((ni < 0) || (ni > size))
           ERROR("CAxis::checkAttributes(void)",
                 << "Attribute <ni> of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be non-negative and smaller than size");
       }
-      else this->ni.setValue(size);
+      else this->n.setValue(size);
 
       StdSize true_size = value.numElements();
-      if (this->ni.getValue() != true_size)
+      if (this->n.getValue() != true_size)
          ERROR("CAxis::checkAttributes(void)",
                << "The array \'value\' of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] has a different size that the one defined by the \'size\' attribute");
@@ -121,5 +121,5 @@
       }
       else if (data_n.isEmpty())
-        data_n.setValue(ni.getValue());
+        data_n.setValue(n.getValue());
 
       if (data_index.isEmpty())
@@ -127,5 +127,5 @@
         int dn = data_n.getValue();
         data_index.resize(dn);
-        for (int i = 0; i < dn; ++i) data_index(i) = (i+1);
+        for (int i = 0; i < dn; ++i) data_index(i) = i;
       }
    }
@@ -133,45 +133,24 @@
    void CAxis::checkZoom(void)
    {
-     if (0 == global_zoom_size) global_zoom_size = this->size.getValue();
+     if (0 == global_zoom_size) global_zoom_size = this->n_glo.getValue();
    }
 
    void CAxis::checkMask()
    {
-      int begin_mask = 0,
-          end_mask = ni.getValue()-1;
-
-      if (!zoom_begin.isEmpty())
-      {
-         int zoom_end = zoom_begin.getValue() + zoom_size.getValue() - 1;
-
-         begin_mask = std::max(ibegin.getValue(), zoom_begin.getValue());
-         end_mask   = std::min(ibegin.getValue() + ni.getValue()-1, zoom_end);
-
-         begin_mask -= ibegin.getValue();
-         end_mask   -= ibegin.getValue();
-      }
-
-
       if (!mask.isEmpty())
       {
-         if (mask.extent(0) != ni)
+         if (mask.extent(0) != n)
             ERROR("CAxis::checkMask(void)",
                   << "the mask has not the same size than the local axis" << endl
-                  << "Local size is " << ni << "x" << endl
+                  << "Local size is " << n << "x" << endl
                   << "Mask size is " << mask.extent(0) << "x");
-         for (int i = 0; i < ni; ++i)
-         {
-           if (i < begin_mask && i > end_mask)  mask(i) = false;
-         }
       }
       else // (!mask.hasValue())
       { // Si aucun masque n'est dÃ©fini,
         // on en crÃ©e un nouveau qui valide l'intÃ©gralitÃ© du domaine.
-         mask.resize(ni);
-         for (int i = 0; i < ni.getValue(); ++i)
+         mask.resize(n);
+         for (int i = 0; i < n.getValue(); ++i)
          {
-               if (i >= begin_mask && i <= end_mask)
-                 mask(i) = true;
-               else  mask(i) = false;
+           mask(i) = true;
          }
       }
@@ -182,8 +161,8 @@
     if (!bounds.isEmpty())
     {
-      if (bounds.extent(0) != ni || bounds.extent(1) != 2)
+      if (bounds.extent(0) != n || bounds.extent(1) != 2)
           ERROR("CAxis::checkAttributes(void)",
                 << "The bounds array of the axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] must be of dimension axis size x 2" << endl
-                << "Axis size is " << ni << endl
+                << "Axis size is " << n << endl
                 << "Bounds size is "<< bounds.extent(0) << " x " << bounds.extent(1));
       hasBounds_ = true;
@@ -255,5 +234,5 @@
   void CAxis::sendValue()
   {
-     if (ni.getValue() == size.getValue())
+     if (n.getValue() == n_glo.getValue())
      {
        sendNonDistributedValue();
@@ -272,7 +251,8 @@
     int nbServer = client->serverSize;
     int range, clientSize = client->clientSize;
+    size_t ni = this->n.getValue();
+    size_t ibegin = this->begin.getValue();
 
     CArray<size_t,1> globalIndexAxis(ni);
-    size_t ibegin = this->ibegin.getValue();
     int zoom_end = global_zoom_begin+global_zoom_size-1;
     std::vector<size_t> globalAxisZoom;
@@ -285,5 +265,5 @@
 
     std::vector<int> nGlobDomain(1);
-    nGlobDomain[0] = size.getValue();
+    nGlobDomain[0] = n_glo.getValue();
 
     size_t globalSizeIndex = 1, indexBegin, indexEnd;
@@ -348,7 +328,7 @@
     int zoom_end = global_zoom_begin+global_zoom_size-1;
     int nb =0;
-    for (size_t idx = 0; idx < ni; ++idx)
-    {
-      size_t globalIndex = ibegin + idx;
+    for (size_t idx = 0; idx < n; ++idx)
+    {
+      size_t globalIndex = begin + idx;
       if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nb;
     }
@@ -356,7 +336,7 @@
     CArray<double,1> val(nb);
     nb = 0;
-    for (size_t idx = 0; idx < ni; ++idx)
-    {
-      size_t globalIndex = ibegin + idx;
+    for (size_t idx = 0; idx < n; ++idx)
+    {
+      size_t globalIndex = begin + idx;
       if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end)
       {
@@ -424,5 +404,5 @@
       {
         idx = static_cast<int>(it->second[n]);
-        ind = idx - ibegin;
+        ind = idx - begin;
 
         val(n) = value(ind);
@@ -602,5 +582,5 @@
     }
 
-    if (size == ni)
+    if (n_glo == n)
     {
       zoom_begin_srv = global_zoom_begin;
Index: /XIOS/trunk/src/node/domain.cpp
===================================================================
--- /XIOS/trunk/src/node/domain.cpp	(revision 665)
+++ /XIOS/trunk/src/node/domain.cpp	(revision 666)
@@ -138,7 +138,4 @@
      checkLocalIDomain();
      checkLocalJDomain();
-
-     ibegin_client = ibegin; ni_client = ni; iend_client = ibegin + ni - 1;
-     jbegin_client = jbegin; nj_client = nj; jend_client = jbegin + nj - 1;
 
      if (i_index.isEmpty())
@@ -340,5 +337,5 @@
             data_i_index.resize(dni) ;
             data_j_index.resize(dni) ;
-            data_n_index.setValue(dni);
+
             for (int i = 0; i < dni; ++i)
             {
@@ -353,6 +350,4 @@
             data_j_index.resize(dni) ;
 
-            data_n_index.setValue(dni);
-
             for(int count = 0, j = 0; j  < data_nj.getValue(); ++j)
             {
@@ -367,33 +362,12 @@
    }
 
-   void CDomain::completeLonClient()
+   //----------------------------------------------------------------
+   void CDomain::completeLonLatClient(void)
    {
      int i,j,k ;
      CArray<double,1> lonvalue_temp(ni*nj) ;
      CArray<double,2> bounds_lon_temp(nvertex,ni*nj);
-
-     if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
-       ERROR("CDomain::completeLonLatClient(void)",
-            <<"Only one longitude value can be used but both lonvalue_1d and lonvalue_2d are defined! "<<endl
-            <<"Define only one longitude value: lonvalue_1d or lonvalue_2d ");
-
-     if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty())
-     {
-       if (lonvalue_1d.numElements() != i_index.numElements())
-         ERROR("CDomain::completeLonLatClient(void)",
-               <<"lonvalue_1d has not the same size as the local domain"<<endl
-               <<"Local size is "<<i_index.numElements()<<endl
-               <<"lonvalue_1d size is "<<lonvalue_1d.numElements());
-     }
-
-     if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
-     {
-        if ((lonvalue_2d.extent(0) != ni) ||
-            (lonvalue_2d.extent(1) != nj))
-           ERROR("CDomain::completeLonLatClient(void)",
-                 <<"the lonvalue has not the same size as the local domain"<<endl
-                 <<"Local size is "<<ni<<"x"<<nj<<endl
-                 <<"Lonvalue size is "<<lonvalue_2d.extent(0)<<"x"<<lonvalue_2d.extent(1));
-     }
+     CArray<double,1> latvalue_temp(ni*nj) ;
+     CArray<double,2> bounds_lat_temp(nvertex,ni*nj);
 
      if (!lonvalue_2d.isEmpty())
@@ -403,8 +377,13 @@
           {
             lonvalue_temp(i+j*ni) = lonvalue_2d(i,j);
+            latvalue_temp(i+j*ni) = latvalue_2d(i,j);
             if (hasBounds)
             {
               k=j*ni+i;
-              for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j);
+              for(int n=0;n<nvertex;++n)
+              {
+                bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j);
+                bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j);
+              }
             }
           }
@@ -415,5 +394,5 @@
        if (type_attr::rectilinear == type)
        {
-         if (ni == lonvalue_1d.numElements())
+         if ((ni == lonvalue_1d.numElements()) && (nj == latvalue_1d.numElements()))
          {
            for(j=0;j<nj;++j)
@@ -422,7 +401,12 @@
                k=j*ni+i;
                lonvalue_temp(k) = lonvalue_1d(i);
+               latvalue_temp(k) = latvalue_1d(j);
                if (hasBounds)
                {
-                 for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_1d(n,i);
+                 for(int n=0;n<nvertex;++n)
+                 {
+                   bounds_lon_temp(n,k) = bounds_lon_1d(n,i);
+                   bounds_lat_temp(n,k) = bounds_lat_1d(n,j);
+                 }
                }
              }
@@ -430,117 +414,16 @@
           else
             ERROR("CDomain::completeLonClient(void)",
-                 <<"The lonvalue_1d has not the same size as the local domain"<<endl
-                 <<"Local size is "<<ni<<endl
-                 <<"Lonvalue_1d size is "<<lonvalue_1d.numElements());
+                 <<"lonvalue_1d and latvalue_1d has not the same size as the local domain"<<endl
+                 <<"Local size is "<<ni<<"x " << nj<< endl
+                 <<"lonvalue_1d size is "<<lonvalue_1d.numElements()
+                 <<"latvalue_1d size is "<<latvalue_1d.numElements());
        }
        else if (type==type_attr::curvilinear || type==type_attr::unstructured)
        {
          lonvalue_temp=lonvalue_1d;
+         latvalue_temp=latvalue_1d;
          if (hasBounds)
          {
            bounds_lon_temp=bounds_lon_1d;
-         }
-       }
-     }
-
-     StdSize dm = zoom_ni_client * zoom_nj_client;
-
-      // Make sure that this attribute is non-empty for every client.
-     if (0 != dm)
-     {
-       lonvalue_client.resize(dm);
-       if (hasBounds) bounds_lon_client.resize(nvertex, dm);
-     }
-
-
-     for (i = 0; i < zoom_ni_client; ++i)
-     {
-       for (j = 0; j < zoom_nj_client; ++j)
-       {
-         lonvalue_client(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
-         if (hasBounds)
-         {
-           for(int n=0;n<nvertex;n++)
-           {
-             bounds_lon_client(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
-           }
-         }
-       }
-     }
-   }
-
-   void CDomain::completeLatClient()
-   {
-     int i,j,k;
-     CArray<double,1> latvalue_temp(ni*nj) ;
-     CArray<double,2> bounds_lat_temp(nvertex,ni*nj);
-
-     if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
-       ERROR("CDomain::completeLonLatClient(void)",
-            <<"Only one longitude value can be used but both latvalue_1d and latvalue_2d are defined! "<<endl
-            <<"Define only one longitude value: latvalue_1d or latvalue_2d ");
-
-     if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty())
-     {
-       if (latvalue_1d.numElements() != i_index.numElements())
-         ERROR("CDomain::completeLonLatClient(void)",
-               <<"the latvalue_1d has not the same size as the local domain"<<endl
-               <<"Local size is "<<i_index.numElements()<<endl
-               <<"Mask size is "<<latvalue_1d.numElements());
-     }
-
-     if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
-     {
-        if ((latvalue_2d.extent(0) != ni) ||
-            (latvalue_2d.extent(1) != nj))
-           ERROR("CDomain::completeLonLatClient(void)",
-                 <<"the mask has not the same size as the local domain"<<endl
-                 <<"Local size is "<<ni<<"x"<<nj<<endl
-                 <<"Mask size is "<<latvalue_2d.extent(0)<<"x"<<latvalue_2d.extent(1));
-     }
-
-     if (!latvalue_2d.isEmpty())
-     {
-        for (j = 0; j < nj; ++j)
-          for (i = 0; i < ni; ++i)
-          {
-            latvalue_temp(i+j*ni) = latvalue_2d(i,j);
-            if (hasBounds)
-            {
-              k=j*ni+i;
-              for(int n=0;n<nvertex;n++) bounds_lat_temp(n,k) = bounds_lat_2d(n,i,j);
-            }
-          }
-     }
-
-     if (!latvalue_1d.isEmpty())
-     {
-       if (type_attr::rectilinear == type)
-       {
-
-         if (nj == latvalue_1d.numElements())
-         {
-           for(j=0;j<nj;++j)
-             for(i=0;i<ni;++i)
-             {
-               k=j*ni+i;
-               latvalue_temp(k) = latvalue_1d(j);
-               if (hasBounds)
-               {
-                 for(int n=0;n<nvertex;n++) bounds_lat_temp(n,k) = bounds_lat_1d(n,j);
-               }
-             }
-          }
-          else
-            ERROR("CDomain::completeLonClient(void)",
-                 <<"The latvalue_1d has not the same size as the local domain"<<endl
-                 <<"Local size is "<<nj<<endl
-                 <<"Latvalue_1d size is "<<latvalue_1d.numElements());
-       }
-       else if (type==type_attr::curvilinear || type==type_attr::unstructured)
-       {
-         latvalue_temp=latvalue_1d;
-         if (hasBounds)
-         {
            bounds_lat_temp=bounds_lat_1d;
          }
@@ -548,52 +431,54 @@
      }
 
-     StdSize dm = zoom_ni_client * zoom_nj_client;
+    int i_ind,j_ind;
+    int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1;
+    int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1;
+
+    int globalIndexCountZoom = 0;
+    int nbIndex = i_index.numElements();
+    for (i = 0; i < nbIndex; ++i)
+    {
+      i_ind=i_index(i);
+      j_ind=j_index(i);
+
+      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
+      {
+        ++globalIndexCountZoom;
+      }
+    }
 
       // Make sure that this attribute is non-empty for every client.
-     if (0 != dm)
-     {
-       latvalue_client.resize(dm);
-       if (hasBounds) bounds_lat_client.resize(nvertex,dm);
-     }
-
-     for (i = 0; i < zoom_ni_client; i++)
-     {
-       for (j = 0; j < zoom_nj_client; j++)
+     if (0 != globalIndexCountZoom)
+     {
+       lonvalue_client.resize(globalIndexCountZoom);
+       latvalue_client.resize(globalIndexCountZoom);
+       if (hasBounds)
        {
-         latvalue_client(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
+         bounds_lon_client.resize(nvertex,globalIndexCountZoom);
+         bounds_lat_client.resize(nvertex,globalIndexCountZoom);
+       }
+     }
+
+     int nCountZoom = 0;
+     for (i = 0; i < nbIndex; ++i)
+     {
+       i_ind=i_index(i);
+       j_ind=j_index(i);
+
+       if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
+       {
+         lonvalue_client(nCountZoom) = lonvalue_temp(i);
+         latvalue_client(nCountZoom) = latvalue_temp(i);
          if (hasBounds)
          {
-           for(int n=0;n<nvertex;n++)
+           for (int n = 0; n < nvertex; ++n)
            {
-             bounds_lat_client(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
+             bounds_lon_client(n,nCountZoom) = bounds_lon_temp(n,i);
+             bounds_lat_client(n,nCountZoom) = bounds_lat_temp(n,i);
            }
          }
+         ++nCountZoom;
        }
      }
-   }
-
-   //----------------------------------------------------------------
-   void CDomain::completeLonLatClient(void)
-   {
-     completeLonClient();
-     completeLatClient();
-   }
-
-
-   //----------------------------------------------------------------
-   void CDomain::checkZoom(void)
-   {
-      int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
-      zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ;
-      zoom_iend_client = iend_client < global_zoom_iend ? iend_client : global_zoom_iend ;
-      zoom_ni_client=zoom_iend_client-zoom_ibegin_client+1 ;
-      if (zoom_ni_client<0) zoom_ni_client=0 ;
-
-
-      int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
-      zoom_jbegin_client = jbegin_client > global_zoom_jbegin ? jbegin_client : global_zoom_jbegin ;
-      zoom_jend_client = jend_client < global_zoom_jend ? jend_client : global_zoom_jend ;
-      zoom_nj_client=zoom_jend_client-zoom_jbegin_client+1 ;
-      if (zoom_nj_client<0) zoom_nj_client=0;
    }
 
@@ -691,4 +576,54 @@
      hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) ||
                  (!latvalue_2d.isEmpty() && !lonvalue_2d.isEmpty());
+     if (hasLonLat)
+     {
+       if (!lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
+         ERROR("CDomain::completeLonLatClient(void)",
+              <<"Only one longitude value can be used but both lonvalue_1d and lonvalue_2d are defined! "<<endl
+              <<"Define only one longitude value: lonvalue_1d or lonvalue_2d ");
+
+       if (!lonvalue_1d.isEmpty() && lonvalue_2d.isEmpty())
+       {
+         if (lonvalue_1d.numElements() != i_index.numElements())
+           ERROR("CDomain::completeLonLatClient(void)",
+                 <<"lonvalue_1d has not the same size as the local domain"<<endl
+                 <<"Local size is "<<i_index.numElements()<<endl
+                 <<"lonvalue_1d size is "<<lonvalue_1d.numElements());
+       }
+
+       if (lonvalue_1d.isEmpty() && !lonvalue_2d.isEmpty())
+       {
+          if ((lonvalue_2d.extent(0) != ni) ||
+              (lonvalue_2d.extent(1) != nj))
+             ERROR("CDomain::completeLonLatClient(void)",
+                   <<"the lonvalue has not the same size as the local domain"<<endl
+                   <<"Local size is "<<ni<<"x"<<nj<<endl
+                   <<"Lonvalue size is "<<lonvalue_2d.extent(0)<<"x"<<lonvalue_2d.extent(1));
+       }
+
+       if (!latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
+         ERROR("CDomain::completeLonLatClient(void)",
+              <<"Only one longitude value can be used but both latvalue_1d and latvalue_2d are defined! "<<endl
+              <<"Define only one longitude value: latvalue_1d or latvalue_2d ");
+
+       if (!latvalue_1d.isEmpty() && latvalue_2d.isEmpty())
+       {
+         if (latvalue_1d.numElements() != i_index.numElements())
+           ERROR("CDomain::completeLonLatClient(void)",
+                 <<"the latvalue_1d has not the same size as the local domain"<<endl
+                 <<"Local size is "<<i_index.numElements()<<endl
+                 <<"Mask size is "<<latvalue_1d.numElements());
+       }
+
+       if (latvalue_1d.isEmpty() && !latvalue_2d.isEmpty())
+       {
+          if ((latvalue_2d.extent(0) != ni) ||
+              (latvalue_2d.extent(1) != nj))
+             ERROR("CDomain::completeLonLatClient(void)",
+                   <<"the mask has not the same size as the local domain"<<endl
+                   <<"Local size is "<<ni<<"x"<<nj<<endl
+                   <<"Mask size is "<<latvalue_2d.extent(0)<<"x"<<latvalue_2d.extent(1));
+       }
+     }
    }
 
@@ -697,5 +632,4 @@
      CContext* context=CContext::getCurrent() ;
 
-     this->checkZoom();
      if (this->isClientAfterTransformationChecked) return;
      if (context->hasClient)
@@ -742,5 +676,4 @@
      CContext* context=CContext::getCurrent() ;
 
-     this->checkZoom();
      if (this->isChecked) return;
      if (context->hasClient)
@@ -759,5 +692,4 @@
 
       this->checkDomain();
-      this->checkZoom();
       this->checkLonLat();
       this->checkBounds();
@@ -769,5 +701,5 @@
          this->checkDomainData();
          this->checkCompression();
-         this->completeLonLatClient();
+
       }
       else
@@ -777,7 +709,8 @@
       if (context->hasClient)
       {
-        computeConnectedServer() ;
-        sendServerAttribut() ;
-        sendLonLatArea() ;
+        this->computeConnectedServer();
+        this->completeLonLatClient();
+        this->sendServerAttribut();
+        this->sendLonLatArea();
       }
 
@@ -837,7 +770,4 @@
   void CDomain::computeConnectedServer(void)
   {
-    ibegin_client=ibegin; ni_client=ni; iend_client=ibegin_client + ni_client - 1;
-    jbegin_client=jbegin; nj_client=nj; jend_client=jbegin_client + nj_client - 1;
-
     CContext* context=CContext::getCurrent() ;
     CContextClient* client=context->client ;
@@ -846,6 +776,6 @@
 
     int i,j,i_ind,j_ind, nbIndex;
-    int zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
-    int zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
+    int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
+    int global_zoom_jend=global_zoom_jbegin+global_zoom_nj-1 ;
 
     // Precompute number of index
@@ -857,5 +787,5 @@
       j_ind=j_index(i);
 
-      if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend)
+      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
       {
         ++globalIndexCountZoom;
@@ -878,5 +808,5 @@
       globalIndexDomain(globalIndexCount) = globalIndex;
       ++globalIndexCount;
-      if (i_ind >= global_zoom_ibegin && i_ind <= zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= zoom_jend)
+      if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
       {
         globalIndexDomainZoom(globalIndexCountZoom) = globalIndex;
@@ -1076,10 +1006,6 @@
       {
         idx = static_cast<int>(it->second[n]);
-        i = i_index(idx);
-        j = j_index(idx);
-        ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client;
-
-        lon(n) = lonvalue_client(ind);
-        lat(n) = latvalue_client(ind);
+        lon(n) = lonvalue_client(idx);
+        lat(n) = latvalue_client(idx);
 
         if (hasBounds)
@@ -1088,8 +1014,8 @@
           CArray<double,2>& boundslat = list_boundslat.back();
 
-          for (nv = 0; nv < nvertex; nv++)
+          for (nv = 0; nv < nvertex; ++nv)
           {
-            boundslon(nv, n) = bounds_lon_client(nv, ind);
-            boundslat(nv, n) = bounds_lat_client(nv, ind);
+            boundslon(nv, n) = bounds_lon_client(nv, idx);
+            boundslat(nv, n) = bounds_lat_client(nv, idx);
           }
         }
@@ -1252,5 +1178,5 @@
       if (hasBounds)
       {
-        for (int nv = 0; nv < nvertex; nv++)
+        for (int nv = 0; nv < nvertex; ++nv)
           bounds_lon_srv(nv, ind_srv) = boundslon(nv, ind);
       }
Index: /XIOS/trunk/src/node/domain.hpp
===================================================================
--- /XIOS/trunk/src/node/domain.hpp	(revision 665)
+++ /XIOS/trunk/src/node/domain.hpp	(revision 666)
@@ -77,7 +77,5 @@
 
       private :
-
          void checkDomain(void);
-
          void checkLocalIDomain(void);
          void checkLocalJDomain(void);
@@ -87,9 +85,7 @@
          void checkCompression(void);
 
-         void checkZoom(void);
          void checkBounds(void);
          void checkArea(void);
          void checkLonLat();
-
 
       public :
@@ -107,9 +103,9 @@
 
 
-         int ni_client,ibegin_client,iend_client ;
-         int zoom_ni_client,zoom_ibegin_client,zoom_iend_client ;
-
-         int nj_client,jbegin_client,jend_client ;
-         int zoom_nj_client,zoom_jbegin_client,zoom_jend_client ;
+//         int ni_client,ibegin_client,iend_client ;
+//         int zoom_ni_client,zoom_ibegin_client,zoom_iend_client ;
+//
+//         int nj_client,jbegin_client,jend_client ;
+//         int zoom_nj_client,zoom_jbegin_client,zoom_jend_client ;
 
          int ni_srv,ibegin_srv,iend_srv ;
@@ -133,12 +129,10 @@
 
 
-        CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target
+//        CArray<int,2> mapConnectedServer ;  // (ni,nj) => mapped to connected server number, -1 if no server is target
 
         int global_zoom_ibegin, global_zoom_ni;
         int global_zoom_jbegin, global_zoom_nj;
-//        CArray<bool,1> maskInter;
 
       public :
-
          /// Mutateur ///
          void addRelFile(const StdString & filename);
@@ -178,6 +172,4 @@
          void setTransformations(const TransMapTypes&);
          void computeNGlobDomain();
-         void completeLonClient();
-         void completeLatClient();
 
          void sendIndex();
Index: /XIOS/trunk/src/node/grid.cpp
===================================================================
--- /XIOS/trunk/src/node/grid.cpp	(revision 665)
+++ /XIOS/trunk/src/node/grid.cpp	(revision 666)
@@ -686,5 +686,5 @@
       else
       {
-        globalDim_[idx] = axis[idxAxis]->size.getValue();
+        globalDim_[idx] = axis[idxAxis]->n_glo.getValue();
         ++idxAxis;
         ++idx;
@@ -807,5 +807,5 @@
             nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv;
             nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->global_zoom_begin;
-            nGlob[indexMap[i]] = axisList[axisId]->size;
+            nGlob[indexMap[i]] = axisList[axisId]->n_glo;
             ++axisId;
           }
Index: /XIOS/trunk/src/node/zoom_axis.cpp
===================================================================
--- /XIOS/trunk/src/node/zoom_axis.cpp	(revision 665)
+++ /XIOS/trunk/src/node/zoom_axis.cpp	(revision 666)
@@ -25,14 +25,14 @@
   void CZoomAxis::checkValid(CAxis* axisDest)
   {
-    int axisIBegin, axisNi, axisSize;
+    int axisIBegin, axisNi, axisGlobalSize;
     int zoom_begin, zoom_end, zoom_size;
 
-    axisIBegin = axisDest->ibegin.getValue();
-    axisNi     = axisDest->ni.getValue();
-    axisSize   = axisDest->size.getValue();
+    axisIBegin = axisDest->begin.getValue();
+    axisNi     = axisDest->n.getValue();
+    axisGlobalSize   = axisDest->n_glo.getValue();
 
     zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ;
-    zoom_size  = (this->zoom_size.isEmpty()) ?  axisSize : this->zoom_size.getValue() ;
-    zoom_end   = (this->zoom_end.isEmpty()) ?  (axisSize - 1) : this->zoom_end.getValue() ;
+    zoom_size  = (this->zoom_size.isEmpty()) ?  axisGlobalSize : this->zoom_size.getValue() ;
+    zoom_end   = (this->zoom_end.isEmpty()) ?  (axisGlobalSize - 1) : this->zoom_end.getValue() ;
 
     if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1;
@@ -40,5 +40,5 @@
     if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1;
 
-    if ((zoom_begin < 0) || (zoom_begin > axisSize-1) || (zoom_end<0) || (zoom_end>axisSize-1) || (zoom_size<1) || (zoom_size>axisSize) || (zoom_begin>zoom_end))
+    if ((zoom_begin < 0) || (zoom_begin > axisGlobalSize-1) || (zoom_end<0) || (zoom_end>axisGlobalSize-1) || (zoom_size<1) || (zoom_size>axisGlobalSize) || (zoom_begin>zoom_end))
       ERROR("CZoomAxis::checkAttributes(void)",
             << "One or more attributes among <zoom_begin>, <zoom_end>, <zoom_size> of axis transformation [ id = '" << axisDest->getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
Index: /XIOS/trunk/src/test/test_client.f90
===================================================================
--- /XIOS/trunk/src/test/test_client.f90	(revision 665)
+++ /XIOS/trunk/src/test/test_client.f90	(revision 666)
@@ -76,5 +76,5 @@
   PRINT *, "calendar_type = ", calendar_type
 
-  CALL xios_set_axis_attr("axis_A",size=llm ,value=lval) ;
+  CALL xios_set_axis_attr("axis_A",n_glo=llm ,value=lval) ;
   CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear')
   CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
Index: /XIOS/trunk/src/test/test_complete.f90
===================================================================
--- /XIOS/trunk/src/test/test_complete.f90	(revision 665)
+++ /XIOS/trunk/src/test/test_complete.f90	(revision 666)
@@ -87,5 +87,5 @@
                             time_origin=xios_date(1999, 01, 01, 15, 00, 00))
 
-  CALL xios_set_axis_attr("axis_atm",size=llm ,value=lval) ;
+  CALL xios_set_axis_attr("axis_atm",n_glo=llm ,value=lval) ;
 
   CALL xios_set_domain_attr("domain_atm",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj, type='curvilinear')
@@ -176,8 +176,8 @@
                             time_origin=xios_date(1999, 01, 01, 15, 00, 00))
 
-  CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval)
+  CALL xios_set_axis_attr("axis_srf",n_glo=llm ,value=lval)
   CALL xios_set_domain_attr("domain_srf",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj, type='curvilinear')
   CALL xios_set_domain_attr("domain_srf",data_dim=1, data_ibegin=0, data_ni=nb_pt)
-  CALL xios_set_domain_attr("domain_srf",data_n_index=nb_pt, data_i_index=kindex)
+  CALL xios_set_domain_attr("domain_srf",data_i_index=kindex)
   CALL xios_set_domain_attr("domain_srf",lonvalue_2D=lon,latvalue_2D=lat)
 
Index: /XIOS/trunk/src/test/test_new_features.f90
===================================================================
--- /XIOS/trunk/src/test/test_new_features.f90	(revision 665)
+++ /XIOS/trunk/src/test/test_new_features.f90	(revision 666)
@@ -125,9 +125,9 @@
   PRINT *, "calendar_type = ", calendar_type
 
-  CALL xios_set_axis_attr("axis_A", size=ni_glo, ibegin=ibegin, ni=ni, value=lval_ni)
-  CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj, mask=mask)
-  CALL xios_set_axis_attr("axis_C", size=llm, value=lval)
-  CALL xios_set_axis_attr("axis_D", size=llm, ibegin=axisBegin, ni=nAxis, value=lvaln)
-  CALL xios_set_axis_attr("axis_G", size=llmInterPolated, value=lvalnInterp, ibegin=axisterpBegin, ni=nAxisinterp)
+  CALL xios_set_axis_attr("axis_A", n_glo=ni_glo, begin=ibegin, n=ni, value=lval_ni)
+  CALL xios_set_axis_attr("axis_B", n_glo=nj_glo, begin=jbegin, n=nj, value=lval_nj, mask=mask)
+  CALL xios_set_axis_attr("axis_C", n_glo=llm, value=lval)
+  CALL xios_set_axis_attr("axis_D", n_glo=llm, begin=axisBegin, n=nAxis, value=lvaln)
+  CALL xios_set_axis_attr("axis_G", n_glo=llmInterPolated, value=lvalnInterp, begin=axisterpBegin, n=nAxisinterp)
   CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj)
   CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
Index: /XIOS/trunk/src/test/test_unstruct_complete.f90
===================================================================
--- /XIOS/trunk/src/test/test_unstruct_complete.f90	(revision 665)
+++ /XIOS/trunk/src/test/test_unstruct_complete.f90	(revision 666)
@@ -199,8 +199,8 @@
   CALL xios_set_current_context(ctx_hdl)
 
-  CALL xios_set_axis_attr("axis_srf",size=llm ,value=lval) ;
+  CALL xios_set_axis_attr("axis_srf",n_glo=llm ,value=lval) ;
   CALL xios_set_domain_attr("domain_srf", ni_glo=ncell_glo, ni=ncell, ibegin=1, i_index=i_index)
   CALL xios_set_domain_attr("domain_srf", type='unstructured', data_dim=1, data_ni=data_n_index, &
-                                          data_n_index=data_n_index, data_i_index=data_i_index)
+                                          data_i_index=data_i_index)
   CALL xios_set_domain_attr("domain_srf", lonvalue_1D=lon, latvalue_1D=lat)
   CALL xios_set_domain_attr("domain_srf", nvertex=4, bounds_lon_1D=bounds_lon, bounds_lat_1D=bounds_lat)
Index: /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp	(revision 665)
+++ /XIOS/trunk/src/transformation/axis_algorithm_interpolate.cpp	(revision 666)
@@ -20,9 +20,9 @@
   interpAxis->checkValid(axisSource);
   order_ = interpAxis->order.getValue();
-  if (order_ >= axisSource->size.getValue())
+  if (order_ >= axisSource->n_glo.getValue())
   {
     ERROR("CAxisAlgorithmInterpolate::CAxisAlgorithmInterpolate(CAxis* axisDestination, CAxis* axisSource, CInterpolateAxis* interpAxis)",
-           << "Order of interpolation is greater than size of axis source"
-           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
+           << "Order of interpolation is greater than global size of axis source"
+           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl
            << "Order of interpolation is " << order_ );
   }
@@ -43,5 +43,5 @@
   int nbClient = client->clientSize;
 
-  int srcSize  = axisSrc_->size.getValue();
+  int srcSize  = axisSrc_->n_glo.getValue();
   int numValue = axisValue.numElements();
 
@@ -67,5 +67,5 @@
   const double sfmax = NumTraits<double>::sfmax();
 
-  int ibegin = axisDest_->ibegin.getValue();
+  int ibegin = axisDest_->begin.getValue();
   CArray<double,1>& axisDestValue = axisDest_->value;
   int numValue = axisDestValue.numElements();
@@ -131,5 +131,5 @@
   std::map<int, std::vector<std::pair<int,double> > >::const_iterator itb = interpolatingIndexValues.begin(), it,
                                                                       ite = interpolatingIndexValues.end();
-  int ibegin = axisDest_->ibegin.getValue();
+  int ibegin = axisDest_->begin.getValue();
   for (it = itb; it != ite; ++it)
   {
@@ -169,5 +169,5 @@
   int nbClient = client->clientSize;
 
-  int srcSize  = axisSrc_->size.getValue();
+  int srcSize  = axisSrc_->n_glo.getValue();
   int numValue = axisValue.numElements();
 
@@ -191,5 +191,5 @@
     int* recvIndexBuff = new int [srcSize];
 
-    int ibegin = axisSrc_->ibegin.getValue();
+    int ibegin = axisSrc_->begin.getValue();
     for (int idx = 0; idx < numValue; ++idx)
     {
Index: /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp	(revision 665)
+++ /XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp	(revision 666)
@@ -17,15 +17,15 @@
  : CAxisAlgorithmTransformation(axisDestination, axisSource)
 {
-  if (axisDestination->size.getValue() != axisSource->size.getValue())
+  if (axisDestination->n_glo.getValue() != axisSource->n_glo.getValue())
   {
     ERROR("CAxisAlgorithmInverse::CAxisAlgorithmInverse(CAxis* axisDestination, CAxis* axisSource)",
-           << "Two axis have different size"
-           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
-           << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->size.getValue());
+           << "Two axis have different global size"
+           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl
+           << "Size of axis destionation " <<axisDestination->getId() << " is " << axisDestination->n_glo.getValue());
   }
 
   this->computeIndexSourceMapping();
-  int niSrc   = axisSrc_->ni.getValue();
-  int sizeSrc = axisSrc_->size.getValue();
+  int niSrc   = axisSrc_->n.getValue();
+  int sizeSrc = axisSrc_->n_glo.getValue();
   if (niSrc != sizeSrc) updateAxisValue();
   else
@@ -60,6 +60,6 @@
   CContextClient* client=context->client;
 
-  int niSrc     = axisSrc_->ni.getValue();
-  int ibeginSrc = axisSrc_->ibegin.getValue();
+  int niSrc     = axisSrc_->n.getValue();
+  int ibeginSrc = axisSrc_->begin.getValue();
 
   CTransformationMapping transformationMap(axisDest_, axisSrc_);
@@ -128,5 +128,5 @@
  }
 
- int ibeginDest = axisDest_->ibegin.getValue();
+ int ibeginDest = axisDest_->begin.getValue();
  currentRecvBuff = recvBuff;
  for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv)
Index: /XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp	(revision 665)
+++ /XIOS/trunk/src/transformation/axis_algorithm_transformation.cpp	(revision 666)
@@ -17,7 +17,7 @@
  : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource)
 {
-  axisDestGlobalSize_ = axisDestination->size.getValue();
-  int niDest = axisDestination->ni.getValue();
-  int ibeginDest = axisDestination->ibegin.getValue();
+  axisDestGlobalSize_ = axisDestination->n_glo.getValue();
+  int niDest = axisDestination->n.getValue();
+  int ibeginDest = axisDestination->begin.getValue();
 
   for (int idx = 0; idx < niDest; ++idx)
Index: /XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp
===================================================================
--- /XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp	(revision 665)
+++ /XIOS/trunk/src/transformation/axis_algorithm_zoom.cpp	(revision 666)
@@ -19,9 +19,9 @@
   zoomSize_  = zoomAxis->zoom_size.getValue();
 
-  if (zoomSize_ > axisSource->size.getValue())
+  if (zoomSize_ > axisSource->n_glo.getValue())
   {
     ERROR("CAxisAlgorithmZoom::CAxisAlgorithmZoom(CAxis* axisDestination, CAxis* axisSource, CZoomAxis* zoomAxis)",
-           << "Zoom size is greater than size of axis source"
-           << "Size of axis source " <<axisSource->getId() << " is " << axisSource->size.getValue()  << std::endl
+           << "Zoom size is greater than global size of axis source"
+           << "Global size of axis source " <<axisSource->getId() << " is " << axisSource->n_glo.getValue()  << std::endl
            << "Zoom size is " << zoomSize_ );
   }
@@ -35,6 +35,6 @@
 void CAxisAlgorithmZoom::computeIndexSourceMapping()
 {
-  StdSize niSource = axisSrc_->ni.getValue();
-  StdSize ibeginSource = axisSrc_->ibegin.getValue();
+  StdSize niSource = axisSrc_->n.getValue();
+  StdSize ibeginSource = axisSrc_->begin.getValue();
   StdSize iendSource = ibeginSource + niSource - 1;
 
@@ -73,5 +73,5 @@
 {
   StdSize niMask = axisDest_->mask.numElements();
-  StdSize iBeginMask = axisDest_->ibegin.getValue();
+  StdSize iBeginMask = axisDest_->begin.getValue();
   StdSize globalIndexMask = 0;
   std::map<int, std::vector<int> >& transMap = this->transformationMapping_;
Index: /XIOS/trunk/src/transformation/transformation_mapping.cpp
===================================================================
--- /XIOS/trunk/src/transformation/transformation_mapping.cpp	(revision 665)
+++ /XIOS/trunk/src/transformation/transformation_mapping.cpp	(revision 666)
@@ -45,6 +45,6 @@
   int clientRank = client->clientRank;
 
-  int niSrc     = source->ni.getValue();
-  int ibeginSrc = source->ibegin.getValue();
+  int niSrc     = source->n.getValue();
+  int ibeginSrc = source->begin.getValue();
 
   boost::unordered_map<size_t,int> globalIndexOfAxisSource;
