Index: XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 554)
+++ XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 555)
@@ -44,4 +44,92 @@
   
   
+  void cxios_set_axis_data_begin(axis_Ptr axis_hdl, int data_begin)
+  {
+     CTimer::get("XIOS").resume();
+    axis_hdl->data_begin.setValue(data_begin);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axis_data_begin(axis_Ptr axis_hdl, int* data_begin)
+  {
+    *data_begin = axis_hdl->data_begin.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axis_data_begin(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->data_begin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_axis_data_index(axis_Ptr axis_hdl, int* data_index, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ;
+    axis_hdl->data_index.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axis_data_index(axis_Ptr axis_hdl, int* data_index, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ;
+    tmp=axis_hdl->data_index.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_axis_data_index(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->data_index.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_axis_data_n(axis_Ptr axis_hdl, int data_n)
+  {
+     CTimer::get("XIOS").resume();
+    axis_hdl->data_n.setValue(data_n);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axis_data_n(axis_Ptr axis_hdl, int* data_n)
+  {
+    *data_n = axis_hdl->data_n.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axis_data_n(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->data_n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  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)
+  {
+    *ibegin = axis_hdl->ibegin.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axis_ibegin(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axis_long_name(axis_Ptr axis_hdl, const char * long_name, int long_name_size)
   {
@@ -70,4 +158,29 @@
   
   
+  void cxios_set_axis_mask(axis_Ptr axis_hdl, bool* mask, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ;
+    axis_hdl->mask.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axis_mask(axis_Ptr axis_hdl, bool* mask, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ;
+    tmp=axis_hdl->mask.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_axis_mask(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->mask.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axis_name(axis_Ptr axis_hdl, const char * name, int name_size)
   {
@@ -96,4 +209,25 @@
   
   
+  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)
+  {
+    *ni = axis_hdl->ni.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axis_ni(axis_Ptr axis_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axis_hdl->ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axis_positive(axis_Ptr axis_hdl, const char * positive, int positive_size)
   {
Index: XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 554)
+++ XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 555)
@@ -44,4 +44,71 @@
   
   
+  void cxios_set_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int data_begin)
+  {
+     CTimer::get("XIOS").resume();
+    axisgroup_hdl->data_begin.setValue(data_begin);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl, int* data_begin)
+  {
+    *data_begin = axisgroup_hdl->data_begin.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axisgroup_data_begin(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->data_begin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ;
+    axisgroup_hdl->data_index.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl, int* data_index, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(data_index,shape(extent1),neverDeleteData) ;
+    tmp=axisgroup_hdl->data_index.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_axisgroup_data_index(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->data_index.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int data_n)
+  {
+     CTimer::get("XIOS").resume();
+    axisgroup_hdl->data_n.setValue(data_n);
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl, int* data_n)
+  {
+    *data_n = axisgroup_hdl->data_n.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axisgroup_data_n(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->data_n.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, const char * group_ref, int group_ref_size)
   {
@@ -70,4 +137,25 @@
   
   
+  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)
+  {
+    *ibegin = axisgroup_hdl->ibegin.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axisgroup_ibegin(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, const char * long_name, int long_name_size)
   {
@@ -96,4 +184,29 @@
   
   
+  void cxios_set_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ;
+    axisgroup_hdl->mask.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_axisgroup_mask(axisgroup_Ptr axisgroup_hdl, bool* mask, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask,shape(extent1),neverDeleteData) ;
+    tmp=axisgroup_hdl->mask.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_axisgroup_mask(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->mask.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axisgroup_name(axisgroup_Ptr axisgroup_hdl, const char * name, int name_size)
   {
@@ -122,4 +235,25 @@
   
   
+  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)
+  {
+    *ni = axisgroup_hdl->ni.getInheritedValue();
+  }
+  
+  bool cxios_is_defined_axisgroup_ni(axisgroup_Ptr axisgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return axisgroup_hdl->ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
   void cxios_set_axisgroup_positive(axisgroup_Ptr axisgroup_hdl, const char * positive, int positive_size)
   {
Index: XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp	(revision 554)
+++ XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp	(revision 555)
@@ -17,6 +17,6 @@
 {
   typedef xios::CGrid*  grid_Ptr;
-
-  void cxios_set_grid_axisDomOrder(grid_Ptr grid_hdl, bool* axisDomainOrder, int extent1)
+  
+  void cxios_set_grid_axisDomainOrder(grid_Ptr grid_hdl, bool* axisDomainOrder, int extent1)
   {
     CTimer::get("XIOS").resume();
@@ -25,6 +25,6 @@
      CTimer::get("XIOS").suspend();
   }
-
-  void cxios_get_grid_axisDomOrder(grid_Ptr grid_hdl, bool* axisDomainOrder, int extent1)
+  
+  void cxios_get_grid_axisDomainOrder(grid_Ptr grid_hdl, bool* axisDomainOrder, int extent1)
   {
     CTimer::get("XIOS").resume();
@@ -33,6 +33,6 @@
      CTimer::get("XIOS").suspend();
   }
-
-  bool cxios_is_defined_grid_axisDomOrder(grid_Ptr grid_hdl )
+  
+  bool cxios_is_defined_grid_axisDomainOrder(grid_Ptr grid_hdl )
   {
      CTimer::get("XIOS").resume();
@@ -40,7 +40,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_grid_description(grid_Ptr grid_hdl, const char * description, int description_size)
   {
@@ -51,5 +51,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)
   {
@@ -59,5 +59,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_grid_description(grid_Ptr grid_hdl )
   {
@@ -66,7 +66,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_grid_mask(grid_Ptr grid_hdl, bool* mask, int extent1, int extent2, int extent3)
   {
@@ -76,5 +76,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_grid_mask(grid_Ptr grid_hdl, bool* mask, int extent1, int extent2, int extent3)
   {
@@ -84,5 +84,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_grid_mask(grid_Ptr grid_hdl )
   {
@@ -91,7 +91,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_grid_name(grid_Ptr grid_hdl, const char * name, int name_size)
   {
@@ -102,5 +102,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)
   {
@@ -110,5 +110,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_grid_name(grid_Ptr grid_hdl )
   {
@@ -117,7 +117,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
-
+  
+  
+  
+  
 }
Index: XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp	(revision 554)
+++ XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp	(revision 555)
@@ -17,6 +17,6 @@
 {
   typedef xios::CGridGroup*  gridgroup_Ptr;
-
-  void cxios_set_gridgroup_axisDomOrder(gridgroup_Ptr gridgroup_hdl, bool* axisDomainOrder, int extent1)
+  
+  void cxios_set_gridgroup_axisDomainOrder(gridgroup_Ptr gridgroup_hdl, bool* axisDomainOrder, int extent1)
   {
     CTimer::get("XIOS").resume();
@@ -25,6 +25,6 @@
      CTimer::get("XIOS").suspend();
   }
-
-  void cxios_get_gridgroup_axisDomOrder(gridgroup_Ptr gridgroup_hdl, bool* axisDomainOrder, int extent1)
+  
+  void cxios_get_gridgroup_axisDomainOrder(gridgroup_Ptr gridgroup_hdl, bool* axisDomainOrder, int extent1)
   {
     CTimer::get("XIOS").resume();
@@ -33,6 +33,6 @@
      CTimer::get("XIOS").suspend();
   }
-
-  bool cxios_is_defined_gridgroup_axisDomOrder(gridgroup_Ptr gridgroup_hdl )
+  
+  bool cxios_is_defined_gridgroup_axisDomainOrder(gridgroup_Ptr gridgroup_hdl )
   {
      CTimer::get("XIOS").resume();
@@ -40,7 +40,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_gridgroup_description(gridgroup_Ptr gridgroup_hdl, const char * description, int description_size)
   {
@@ -51,5 +51,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)
   {
@@ -59,5 +59,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_gridgroup_description(gridgroup_Ptr gridgroup_hdl )
   {
@@ -66,7 +66,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, const char * group_ref, int group_ref_size)
   {
@@ -77,5 +77,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)
   {
@@ -85,5 +85,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl )
   {
@@ -92,7 +92,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_gridgroup_mask(gridgroup_Ptr gridgroup_hdl, bool* mask, int extent1, int extent2, int extent3)
   {
@@ -102,5 +102,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_gridgroup_mask(gridgroup_Ptr gridgroup_hdl, bool* mask, int extent1, int extent2, int extent3)
   {
@@ -110,5 +110,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_gridgroup_mask(gridgroup_Ptr gridgroup_hdl )
   {
@@ -117,7 +117,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
+  
+  
+  
   void cxios_set_gridgroup_name(gridgroup_Ptr gridgroup_hdl, const char * name, int name_size)
   {
@@ -128,5 +128,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)
   {
@@ -136,5 +136,5 @@
      CTimer::get("XIOS").suspend();
   }
-
+  
   bool cxios_is_defined_gridgroup_name(gridgroup_Ptr gridgroup_hdl )
   {
@@ -143,7 +143,7 @@
      CTimer::get("XIOS").suspend();
   }
-
-
-
-
+  
+  
+  
+  
 }
Index: XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/axis_interface_attr.F90	(revision 555)
@@ -31,4 +31,82 @@
     
     
+    SUBROUTINE cxios_set_axis_data_begin(axis_hdl, data_begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: data_begin
+    END SUBROUTINE cxios_set_axis_data_begin
+    
+    SUBROUTINE cxios_get_axis_data_begin(axis_hdl, data_begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)             :: data_begin
+    END SUBROUTINE cxios_get_axis_data_begin
+    
+    FUNCTION cxios_is_defined_axis_data_begin(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_data_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_data_begin
+    
+    
+    SUBROUTINE cxios_set_axis_data_index(axis_hdl, data_index, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axis_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: data_index
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_axis_data_index
+    
+    SUBROUTINE cxios_get_axis_data_index(axis_hdl, data_index, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axis_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: data_index
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_axis_data_index
+    
+    FUNCTION cxios_is_defined_axis_data_index(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_data_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_data_index
+    
+    
+    SUBROUTINE cxios_set_axis_data_n(axis_hdl, data_n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: data_n
+    END SUBROUTINE cxios_set_axis_data_n
+    
+    SUBROUTINE cxios_get_axis_data_n(axis_hdl, data_n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+      INTEGER (KIND=C_INT)             :: data_n
+    END SUBROUTINE cxios_get_axis_data_n
+    
+    FUNCTION cxios_is_defined_axis_data_n(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_data_n
+      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
+    
+    
     SUBROUTINE cxios_set_axis_long_name(axis_hdl, long_name, long_name_size) BIND(C)
       USE ISO_C_BINDING
@@ -52,4 +130,25 @@
     
     
+    SUBROUTINE cxios_set_axis_mask(axis_hdl, mask, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axis_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_axis_mask
+    
+    SUBROUTINE cxios_get_axis_mask(axis_hdl, mask, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axis_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_axis_mask
+    
+    FUNCTION cxios_is_defined_axis_mask(axis_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axis_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: axis_hdl
+    END FUNCTION cxios_is_defined_axis_mask
+    
+    
     SUBROUTINE cxios_set_axis_name(axis_hdl, name, name_size) BIND(C)
       USE ISO_C_BINDING
@@ -73,4 +172,23 @@
     
     
+    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
Index: XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/axisgroup_interface_attr.F90	(revision 555)
@@ -31,4 +31,63 @@
     
     
+    SUBROUTINE cxios_set_axisgroup_data_begin(axisgroup_hdl, data_begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: data_begin
+    END SUBROUTINE cxios_set_axisgroup_data_begin
+    
+    SUBROUTINE cxios_get_axisgroup_data_begin(axisgroup_hdl, data_begin) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)             :: data_begin
+    END SUBROUTINE cxios_get_axisgroup_data_begin
+    
+    FUNCTION cxios_is_defined_axisgroup_data_begin(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_data_begin
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_data_begin
+    
+    
+    SUBROUTINE cxios_set_axisgroup_data_index(axisgroup_hdl, data_index, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axisgroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: data_index
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_axisgroup_data_index
+    
+    SUBROUTINE cxios_get_axisgroup_data_index(axisgroup_hdl, data_index, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axisgroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: data_index
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_axisgroup_data_index
+    
+    FUNCTION cxios_is_defined_axisgroup_data_index(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_data_index
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_data_index
+    
+    
+    SUBROUTINE cxios_set_axisgroup_data_n(axisgroup_hdl, data_n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: data_n
+    END SUBROUTINE cxios_set_axisgroup_data_n
+    
+    SUBROUTINE cxios_get_axisgroup_data_n(axisgroup_hdl, data_n) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+      INTEGER (KIND=C_INT)             :: data_n
+    END SUBROUTINE cxios_get_axisgroup_data_n
+    
+    FUNCTION cxios_is_defined_axisgroup_data_n(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_data_n
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_data_n
+    
+    
     SUBROUTINE cxios_set_axisgroup_group_ref(axisgroup_hdl, group_ref, group_ref_size) BIND(C)
       USE ISO_C_BINDING
@@ -52,4 +111,23 @@
     
     
+    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
@@ -73,4 +151,25 @@
     
     
+    SUBROUTINE cxios_set_axisgroup_mask(axisgroup_hdl, mask, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axisgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_axisgroup_mask
+    
+    SUBROUTINE cxios_get_axisgroup_mask(axisgroup_hdl, mask, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: axisgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_axisgroup_mask
+    
+    FUNCTION cxios_is_defined_axisgroup_mask(axisgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_axisgroup_mask
+      INTEGER (kind = C_INTPTR_T), VALUE :: axisgroup_hdl
+    END FUNCTION cxios_is_defined_axisgroup_mask
+    
+    
     SUBROUTINE cxios_set_axisgroup_name(axisgroup_hdl, name, name_size) BIND(C)
       USE ISO_C_BINDING
@@ -94,4 +193,23 @@
     
     
+    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
Index: XIOS/trunk/src/interface/fortran_attr/grid_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/grid_interface_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/grid_interface_attr.F90	(revision 555)
@@ -10,23 +10,23 @@
     
     
-    SUBROUTINE cxios_set_grid_axisDomOrder(grid_hdl, axisDomOrder, extent1) BIND(C)
+    SUBROUTINE cxios_set_grid_axisDomainOrder(grid_hdl, axisDomainOrder, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
-      INTEGER (KIND=C_INT)     , DIMENSION(*) :: axisDomOrder
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: axisDomainOrder
       INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_grid_axisDomOrder
+    END SUBROUTINE cxios_set_grid_axisDomainOrder
     
-    SUBROUTINE cxios_get_grid_axisDomOrder(grid_hdl, axisDomOrder, extent1) BIND(C)
+    SUBROUTINE cxios_get_grid_axisDomainOrder(grid_hdl, axisDomainOrder, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
-      INTEGER (KIND=C_INT)     , DIMENSION(*) :: axisDomOrder
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: axisDomainOrder
       INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_grid_axisDomOrder
+    END SUBROUTINE cxios_get_grid_axisDomainOrder
     
-    FUNCTION cxios_is_defined_grid_axisDomOrder(grid_hdl ) BIND(C)
+    FUNCTION cxios_is_defined_grid_axisDomainOrder(grid_hdl ) BIND(C)
       USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_axisDomOrder
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_axisDomainOrder
       INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
-    END FUNCTION cxios_is_defined_grid_axisDomOrder
+    END FUNCTION cxios_is_defined_grid_axisDomainOrder
     
     
Index: XIOS/trunk/src/interface/fortran_attr/gridgroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/gridgroup_interface_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/gridgroup_interface_attr.F90	(revision 555)
@@ -10,23 +10,23 @@
     
     
-    SUBROUTINE cxios_set_gridgroup_axisDomOrder(gridgroup_hdl, axisDomOrder, extent1) BIND(C)
+    SUBROUTINE cxios_set_gridgroup_axisDomainOrder(gridgroup_hdl, axisDomainOrder, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
-      INTEGER (KIND=C_INT)     , DIMENSION(*) :: axisDomOrder
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: axisDomainOrder
       INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_gridgroup_axisDomOrder
+    END SUBROUTINE cxios_set_gridgroup_axisDomainOrder
     
-    SUBROUTINE cxios_get_gridgroup_axisDomOrder(gridgroup_hdl, axisDomOrder, extent1) BIND(C)
+    SUBROUTINE cxios_get_gridgroup_axisDomainOrder(gridgroup_hdl, axisDomainOrder, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
-      INTEGER (KIND=C_INT)     , DIMENSION(*) :: axisDomOrder
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: axisDomainOrder
       INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_gridgroup_axisDomOrder
+    END SUBROUTINE cxios_get_gridgroup_axisDomainOrder
     
-    FUNCTION cxios_is_defined_gridgroup_axisDomOrder(gridgroup_hdl ) BIND(C)
+    FUNCTION cxios_is_defined_gridgroup_axisDomainOrder(gridgroup_hdl ) BIND(C)
       USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_axisDomOrder
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_axisDomainOrder
       INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
-    END FUNCTION cxios_is_defined_gridgroup_axisDomOrder
+    END FUNCTION cxios_is_defined_gridgroup_axisDomainOrder
     
     
Index: XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/iaxis_attr.F90	(revision 555)
@@ -12,6 +12,6 @@
   
   SUBROUTINE xios(set_axis_attr)  &
-    ( axis_id, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_id, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
@@ -19,6 +19,13 @@
       CHARACTER(LEN=*), INTENT(IN) ::axis_id
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
       INTEGER  , OPTIONAL, INTENT(IN) :: size
@@ -32,18 +39,25 @@
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(set_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(set_axis_attr)
   
   SUBROUTINE xios(set_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
       INTEGER  , OPTIONAL, INTENT(IN) :: size
@@ -56,18 +70,25 @@
       
       CALL xios(set_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(set_axis_attr_hdl)
   
   SUBROUTINE xios(set_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, long_name_, name_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axis_hdl, axis_ref_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_, name_  &
+    , ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
     
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_
       INTEGER  , OPTIONAL, INTENT(IN) :: size_
@@ -83,12 +104,38 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        CALL cxios_set_axis_data_begin(axis_hdl%daddr, data_begin_)
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        CALL cxios_set_axis_data_index(axis_hdl%daddr, data_index_,size(data_index_,1))
+      ENDIF
+      
+      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
+      
       IF (PRESENT(long_name_)) THEN
         CALL cxios_set_axis_long_name(axis_hdl%daddr, long_name_, len(long_name_))
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(size(mask_,1)))
+        mask__tmp=mask_
+        CALL cxios_set_axis_mask(axis_hdl%daddr, mask__tmp,size(mask_,1))
+      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_))
@@ -128,6 +175,6 @@
   
   SUBROUTINE xios(get_axis_attr)  &
-    ( axis_id, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_id, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
@@ -135,6 +182,13 @@
       CHARACTER(LEN=*), INTENT(IN) ::axis_id
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
       INTEGER  , OPTIONAL, INTENT(OUT) :: size
@@ -148,18 +202,25 @@
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(get_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(get_axis_attr)
   
   SUBROUTINE xios(get_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
       INTEGER  , OPTIONAL, INTENT(OUT) :: size
@@ -172,18 +233,25 @@
       
       CALL xios(get_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(get_axis_attr_hdl)
   
   SUBROUTINE xios(get_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, long_name_, name_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axis_hdl, axis_ref_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_, name_  &
+    , ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
     
     IMPLICIT NONE
       TYPE(txios(axis)) , INTENT(IN) :: axis_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_
       INTEGER  , OPTIONAL, INTENT(OUT) :: size_
@@ -199,12 +267,38 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        CALL cxios_get_axis_data_begin(axis_hdl%daddr, data_begin_)
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        CALL cxios_get_axis_data_index(axis_hdl%daddr, data_index_,size(data_index_,1))
+      ENDIF
+      
+      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
+      
       IF (PRESENT(long_name_)) THEN
         CALL cxios_get_axis_long_name(axis_hdl%daddr, long_name_, len(long_name_))
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(size(mask_,1)))
+        CALL cxios_get_axis_mask(axis_hdl%daddr, mask__tmp,size(mask_,1))
+        mask_=mask__tmp_
+      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_))
@@ -244,6 +338,6 @@
   
   SUBROUTINE xios(is_defined_axis_attr)  &
-    ( axis_id, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_id, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
@@ -252,8 +346,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin
+      LOGICAL(KIND=C_BOOL) :: data_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index
+      LOGICAL(KIND=C_BOOL) :: data_index_tmp
+      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) :: 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
@@ -275,12 +381,12 @@
       CALL xios(get_axis_handle)(axis_id,axis_hdl)
       CALL xios(is_defined_axis_attr_hdl_)   &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(is_defined_axis_attr)
   
   SUBROUTINE xios(is_defined_axis_attr_hdl)  &
-    ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-    , zoom_end, zoom_size )
+    ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+    , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
     IMPLICIT NONE
@@ -288,8 +394,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin
+      LOGICAL(KIND=C_BOOL) :: data_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index
+      LOGICAL(KIND=C_BOOL) :: data_index_tmp
+      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) :: 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
@@ -310,12 +428,12 @@
       
       CALL xios(is_defined_axis_attr_hdl_)  &
-      ( axis_hdl, axis_ref, long_name, name, positive, size, standard_name, unit, value, zoom_begin  &
-      , zoom_end, zoom_size )
+      ( axis_hdl, axis_ref, data_begin, data_index, data_n, ibegin, long_name, mask, name, ni, positive  &
+      , size, standard_name, unit, value, zoom_begin, zoom_end, zoom_size )
     
   END SUBROUTINE xios(is_defined_axis_attr_hdl)
   
   SUBROUTINE xios(is_defined_axis_attr_hdl_)   &
-    ( axis_hdl, axis_ref_, long_name_, name_, positive_, size_, standard_name_, unit_, value_, zoom_begin_  &
-    , zoom_end_, zoom_size_ )
+    ( axis_hdl, axis_ref_, data_begin_, data_index_, data_n_, ibegin_, long_name_, mask_, name_  &
+    , ni_, positive_, size_, standard_name_, unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
     
     IMPLICIT NONE
@@ -323,8 +441,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
       LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin_
+      LOGICAL(KIND=C_BOOL) :: data_begin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index_
+      LOGICAL(KIND=C_BOOL) :: data_index__tmp
+      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) :: 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
@@ -349,4 +479,24 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        data_begin__tmp=cxios_is_defined_axis_data_begin(axis_hdl%daddr)
+        data_begin_=data_begin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        data_index__tmp=cxios_is_defined_axis_data_index(axis_hdl%daddr)
+        data_index_=data_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_n_)) THEN
+        data_n__tmp=cxios_is_defined_axis_data_n(axis_hdl%daddr)
+        data_n_=data_n__tmp
+      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)
@@ -354,4 +504,9 @@
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_axis_mask(axis_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
       IF (PRESENT(name_)) THEN
         name__tmp=cxios_is_defined_axis_name(axis_hdl%daddr)
@@ -359,4 +514,9 @@
       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)
Index: XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/iaxisgroup_attr.F90	(revision 555)
@@ -12,6 +12,6 @@
   
   SUBROUTINE xios(set_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_id, axis_ref, 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 )
     
     IMPLICIT NONE
@@ -19,7 +19,14 @@
       CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
       INTEGER  , OPTIONAL, INTENT(IN) :: size
@@ -33,19 +40,26 @@
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(set_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(set_axisgroup_attr)
   
   SUBROUTINE xios(set_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_hdl, axis_ref, 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 )
     
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_index(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive
       INTEGER  , OPTIONAL, INTENT(IN) :: size
@@ -58,19 +72,27 @@
       
       CALL xios(set_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(set_axisgroup_attr_hdl)
   
   SUBROUTINE xios(set_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, group_ref_, long_name_, name_, positive_, size_, standard_name_  &
-    , unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, 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_ )
     
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_begin_
+      INTEGER  , OPTIONAL, INTENT(IN) :: data_index_(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
+      INTEGER  , OPTIONAL, INTENT(IN) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: positive_
       INTEGER  , OPTIONAL, INTENT(IN) :: size_
@@ -86,16 +108,42 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        CALL cxios_set_axisgroup_data_begin(axisgroup_hdl%daddr, data_begin_)
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        CALL cxios_set_axisgroup_data_index(axisgroup_hdl%daddr, data_index_,size(data_index_,1))
+      ENDIF
+      
+      IF (PRESENT(data_n_)) THEN
+        CALL cxios_set_axisgroup_data_n(axisgroup_hdl%daddr, data_n_)
+      ENDIF
+      
       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
+      
       IF (PRESENT(long_name_)) THEN
         CALL cxios_set_axisgroup_long_name(axisgroup_hdl%daddr, long_name_, len(long_name_))
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(size(mask_,1)))
+        mask__tmp=mask_
+        CALL cxios_set_axisgroup_mask(axisgroup_hdl%daddr, mask__tmp,size(mask_,1))
+      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_))
@@ -135,6 +183,6 @@
   
   SUBROUTINE xios(get_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_id, axis_ref, 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 )
     
     IMPLICIT NONE
@@ -142,7 +190,14 @@
       CHARACTER(LEN=*), INTENT(IN) ::axisgroup_id
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
       INTEGER  , OPTIONAL, INTENT(OUT) :: size
@@ -156,19 +211,26 @@
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(get_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(get_axisgroup_attr)
   
   SUBROUTINE xios(get_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_hdl, axis_ref, 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 )
     
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive
       INTEGER  , OPTIONAL, INTENT(OUT) :: size
@@ -181,19 +243,27 @@
       
       CALL xios(get_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(get_axisgroup_attr_hdl)
   
   SUBROUTINE xios(get_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, group_ref_, long_name_, name_, positive_, size_, standard_name_  &
-    , unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, 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_ )
     
     IMPLICIT NONE
       TYPE(txios(axisgroup)) , INTENT(IN) :: axisgroup_hdl
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: axis_ref_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_begin_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: data_index_(:)
+      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(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: positive_
       INTEGER  , OPTIONAL, INTENT(OUT) :: size_
@@ -209,16 +279,42 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        CALL cxios_get_axisgroup_data_begin(axisgroup_hdl%daddr, data_begin_)
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        CALL cxios_get_axisgroup_data_index(axisgroup_hdl%daddr, data_index_,size(data_index_,1))
+      ENDIF
+      
+      IF (PRESENT(data_n_)) THEN
+        CALL cxios_get_axisgroup_data_n(axisgroup_hdl%daddr, data_n_)
+      ENDIF
+      
       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
+      
       IF (PRESENT(long_name_)) THEN
         CALL cxios_get_axisgroup_long_name(axisgroup_hdl%daddr, long_name_, len(long_name_))
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        ALLOCATE(mask__tmp(size(mask_,1)))
+        CALL cxios_get_axisgroup_mask(axisgroup_hdl%daddr, mask__tmp,size(mask_,1))
+        mask_=mask__tmp_
+      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_))
@@ -258,6 +354,6 @@
   
   SUBROUTINE xios(is_defined_axisgroup_attr)  &
-    ( axisgroup_id, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_id, axis_ref, 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 )
     
     IMPLICIT NONE
@@ -266,10 +362,22 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin
+      LOGICAL(KIND=C_BOOL) :: data_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index
+      LOGICAL(KIND=C_BOOL) :: data_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n
+      LOGICAL(KIND=C_BOOL) :: data_n_tmp
       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) :: 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
@@ -291,12 +399,12 @@
       CALL xios(get_axisgroup_handle)(axisgroup_id,axisgroup_hdl)
       CALL xios(is_defined_axisgroup_attr_hdl_)   &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(is_defined_axisgroup_attr)
   
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl)  &
-    ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-    , zoom_begin, zoom_end, zoom_size )
+    ( axisgroup_hdl, axis_ref, 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 )
     
     IMPLICIT NONE
@@ -304,10 +412,22 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref
       LOGICAL(KIND=C_BOOL) :: axis_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin
+      LOGICAL(KIND=C_BOOL) :: data_begin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index
+      LOGICAL(KIND=C_BOOL) :: data_index_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n
+      LOGICAL(KIND=C_BOOL) :: data_n_tmp
       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) :: 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
@@ -328,12 +448,13 @@
       
       CALL xios(is_defined_axisgroup_attr_hdl_)  &
-      ( axisgroup_hdl, axis_ref, group_ref, long_name, name, positive, size, standard_name, unit, value  &
-      , zoom_begin, zoom_end, zoom_size )
+      ( axisgroup_hdl, axis_ref, 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 )
     
   END SUBROUTINE xios(is_defined_axisgroup_attr_hdl)
   
   SUBROUTINE xios(is_defined_axisgroup_attr_hdl_)   &
-    ( axisgroup_hdl, axis_ref_, group_ref_, long_name_, name_, positive_, size_, standard_name_  &
-    , unit_, value_, zoom_begin_, zoom_end_, zoom_size_ )
+    ( axisgroup_hdl, axis_ref_, 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_ )
     
     IMPLICIT NONE
@@ -341,10 +462,22 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: axis_ref_
       LOGICAL(KIND=C_BOOL) :: axis_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_begin_
+      LOGICAL(KIND=C_BOOL) :: data_begin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_index_
+      LOGICAL(KIND=C_BOOL) :: data_index__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: data_n_
+      LOGICAL(KIND=C_BOOL) :: data_n__tmp
       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) :: 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
@@ -369,4 +502,19 @@
       ENDIF
       
+      IF (PRESENT(data_begin_)) THEN
+        data_begin__tmp=cxios_is_defined_axisgroup_data_begin(axisgroup_hdl%daddr)
+        data_begin_=data_begin__tmp
+      ENDIF
+      
+      IF (PRESENT(data_index_)) THEN
+        data_index__tmp=cxios_is_defined_axisgroup_data_index(axisgroup_hdl%daddr)
+        data_index_=data_index__tmp
+      ENDIF
+      
+      IF (PRESENT(data_n_)) THEN
+        data_n__tmp=cxios_is_defined_axisgroup_data_n(axisgroup_hdl%daddr)
+        data_n_=data_n__tmp
+      ENDIF
+      
       IF (PRESENT(group_ref_)) THEN
         group_ref__tmp=cxios_is_defined_axisgroup_group_ref(axisgroup_hdl%daddr)
@@ -374,4 +522,9 @@
       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)
@@ -379,4 +532,9 @@
       ENDIF
       
+      IF (PRESENT(mask_)) THEN
+        mask__tmp=cxios_is_defined_axisgroup_mask(axisgroup_hdl%daddr)
+        mask_=mask__tmp
+      ENDIF
+      
       IF (PRESENT(name_)) THEN
         name__tmp=cxios_is_defined_axisgroup_name(axisgroup_hdl%daddr)
@@ -384,4 +542,9 @@
       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)
Index: XIOS/trunk/src/interface/fortran_attr/igrid_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/igrid_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/igrid_attr.F90	(revision 555)
@@ -12,10 +12,11 @@
   
   SUBROUTINE xios(set_grid_attr)  &
-    ( grid_id, axisDomOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(grid))  :: grid_hdl
       CHARACTER(LEN=*), INTENT(IN) ::grid_id
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
@@ -25,14 +26,15 @@
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(set_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(set_grid_attr)
   
   SUBROUTINE xios(set_grid_attr_hdl)  &
-    ( grid_hdl, axisDomOrder, description, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder(:)
+    ( grid_hdl, axisDomainOrder, description, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
@@ -41,14 +43,15 @@
       
       CALL xios(set_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(set_grid_attr_hdl)
   
   SUBROUTINE xios(set_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomOrder_, description_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder_(:)
+    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
       LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:,:)
@@ -56,6 +59,8 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        CALL cxios_set_grid_axisDomOrder(grid_hdl%daddr, axisDomOrder_,size(axisDomOrder_,1))
+      IF (PRESENT(axisDomainOrder_)) THEN
+        ALLOCATE(axisDomainOrder__tmp(size(axisDomainOrder_,1)))
+        axisDomainOrder__tmp=axisDomainOrder_
+        CALL cxios_set_grid_axisDomainOrder(grid_hdl%daddr, axisDomainOrder__tmp,size(axisDomainOrder_,1))
       ENDIF
       
@@ -79,10 +84,11 @@
   
   SUBROUTINE xios(get_grid_attr)  &
-    ( grid_id, axisDomOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(grid))  :: grid_hdl
       CHARACTER(LEN=*), INTENT(IN) ::grid_id
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
@@ -92,14 +98,15 @@
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(get_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(get_grid_attr)
   
   SUBROUTINE xios(get_grid_attr_hdl)  &
-    ( grid_hdl, axisDomOrder, description, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder(:)
+    ( grid_hdl, axisDomainOrder, description, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
@@ -108,14 +115,15 @@
       
       CALL xios(get_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(get_grid_attr_hdl)
   
   SUBROUTINE xios(get_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomOrder_, description_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder_(:)
+    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
       LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:,:)
@@ -123,6 +131,8 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        CALL cxios_get_grid_axisDomOrder(grid_hdl%daddr, axisDomOrder_,size(axisDomOrder_,1))
+      IF (PRESENT(axisDomainOrder_)) THEN
+        ALLOCATE(axisDomainOrder__tmp(size(axisDomainOrder_,1)))
+        CALL cxios_get_grid_axisDomainOrder(grid_hdl%daddr, axisDomainOrder__tmp,size(axisDomainOrder_,1))
+        axisDomainOrder_=axisDomainOrder__tmp_
       ENDIF
       
@@ -146,11 +156,11 @@
   
   SUBROUTINE xios(is_defined_grid_attr)  &
-    ( grid_id, axisDomOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(grid))  :: grid_hdl
       CHARACTER(LEN=*), INTENT(IN) ::grid_id
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -162,15 +172,15 @@
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(is_defined_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(is_defined_grid_attr)
   
   SUBROUTINE xios(is_defined_grid_attr_hdl)  &
-    ( grid_hdl, axisDomOrder, description, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder_tmp
+    ( grid_hdl, axisDomainOrder, description, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -181,15 +191,15 @@
       
       CALL xios(is_defined_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask, name )
     
   END SUBROUTINE xios(is_defined_grid_attr_hdl)
   
   SUBROUTINE xios(is_defined_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomOrder_, description_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder_
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder__tmp
+    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(grid)) , INTENT(IN) :: grid_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder_
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description_
       LOGICAL(KIND=C_BOOL) :: description__tmp
@@ -199,7 +209,7 @@
       LOGICAL(KIND=C_BOOL) :: name__tmp
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        axisDomOrder__tmp=cxios_is_defined_grid_axisDomOrder(grid_hdl%daddr)
-        axisDomOrder_=axisDomOrder__tmp
+      IF (PRESENT(axisDomainOrder_)) THEN
+        axisDomainOrder__tmp=cxios_is_defined_grid_axisDomainOrder(grid_hdl%daddr)
+        axisDomainOrder_=axisDomainOrder__tmp
       ENDIF
       
Index: XIOS/trunk/src/interface/fortran_attr/igridgroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/igridgroup_attr.F90	(revision 554)
+++ XIOS/trunk/src/interface/fortran_attr/igridgroup_attr.F90	(revision 555)
@@ -12,10 +12,11 @@
   
   SUBROUTINE xios(set_gridgroup_attr)  &
-    ( gridgroup_id, axisDomOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(gridgroup))  :: gridgroup_hdl
       CHARACTER(LEN=*), INTENT(IN) ::gridgroup_id
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
@@ -26,14 +27,15 @@
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(set_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(set_gridgroup_attr)
   
   SUBROUTINE xios(set_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder(:)
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
@@ -43,14 +45,15 @@
       
       CALL xios(set_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(set_gridgroup_attr_hdl)
   
   SUBROUTINE xios(set_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomOrder_, description_, group_ref_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      INTEGER  , OPTIONAL, INTENT(IN) :: axisDomOrder_(:)
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: axisDomainOrder_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
@@ -59,6 +62,8 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        CALL cxios_set_gridgroup_axisDomOrder(gridgroup_hdl%daddr, axisDomOrder_,size(axisDomOrder_,1))
+      IF (PRESENT(axisDomainOrder_)) THEN
+        ALLOCATE(axisDomainOrder__tmp(size(axisDomainOrder_,1)))
+        axisDomainOrder__tmp=axisDomainOrder_
+        CALL cxios_set_gridgroup_axisDomainOrder(gridgroup_hdl%daddr, axisDomainOrder__tmp,size(axisDomainOrder_,1))
       ENDIF
       
@@ -86,10 +91,11 @@
   
   SUBROUTINE xios(get_gridgroup_attr)  &
-    ( gridgroup_id, axisDomOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(gridgroup))  :: gridgroup_hdl
       CHARACTER(LEN=*), INTENT(IN) ::gridgroup_id
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
@@ -100,14 +106,15 @@
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(get_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(get_gridgroup_attr)
   
   SUBROUTINE xios(get_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder(:)
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
@@ -117,14 +124,15 @@
       
       CALL xios(get_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(get_gridgroup_attr_hdl)
   
   SUBROUTINE xios(get_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomOrder_, description_, group_ref_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      INTEGER  , OPTIONAL, INTENT(OUT) :: axisDomOrder_(:)
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: axisDomainOrder_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
@@ -133,6 +141,8 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        CALL cxios_get_gridgroup_axisDomOrder(gridgroup_hdl%daddr, axisDomOrder_,size(axisDomOrder_,1))
+      IF (PRESENT(axisDomainOrder_)) THEN
+        ALLOCATE(axisDomainOrder__tmp(size(axisDomainOrder_,1)))
+        CALL cxios_get_gridgroup_axisDomainOrder(gridgroup_hdl%daddr, axisDomainOrder__tmp,size(axisDomainOrder_,1))
+        axisDomainOrder_=axisDomainOrder__tmp_
       ENDIF
       
@@ -160,11 +170,11 @@
   
   SUBROUTINE xios(is_defined_gridgroup_attr)  &
-    ( gridgroup_id, axisDomOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
     
     IMPLICIT NONE
       TYPE(txios(gridgroup))  :: gridgroup_hdl
       CHARACTER(LEN=*), INTENT(IN) ::gridgroup_id
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -178,15 +188,15 @@
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(is_defined_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(is_defined_gridgroup_attr)
   
   SUBROUTINE xios(is_defined_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder_tmp
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
@@ -199,15 +209,15 @@
       
       CALL xios(is_defined_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
     
   END SUBROUTINE xios(is_defined_gridgroup_attr_hdl)
   
   SUBROUTINE xios(is_defined_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomOrder_, description_, group_ref_, mask_, name_ )
-    
-    IMPLICIT NONE
-      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
-      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomOrder_
-      LOGICAL(KIND=C_BOOL) :: axisDomOrder__tmp
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    
+    IMPLICIT NONE
+      TYPE(txios(gridgroup)) , INTENT(IN) :: gridgroup_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: axisDomainOrder_
+      LOGICAL(KIND=C_BOOL) :: axisDomainOrder__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: description_
       LOGICAL(KIND=C_BOOL) :: description__tmp
@@ -219,7 +229,7 @@
       LOGICAL(KIND=C_BOOL) :: name__tmp
       
-      IF (PRESENT(axisDomOrder_)) THEN
-        axisDomOrder__tmp=cxios_is_defined_gridgroup_axisDomOrder(gridgroup_hdl%daddr)
-        axisDomOrder_=axisDomOrder__tmp
+      IF (PRESENT(axisDomainOrder_)) THEN
+        axisDomainOrder__tmp=cxios_is_defined_gridgroup_axisDomainOrder(gridgroup_hdl%daddr)
+        axisDomainOrder_=axisDomainOrder__tmp
       ENDIF
       
