Index: XIOS/trunk/inputs/REMAP/iodef.xml
===================================================================
--- XIOS/trunk/inputs/REMAP/iodef.xml	(revision 663)
+++ XIOS/trunk/inputs/REMAP/iodef.xml	(revision 664)
@@ -14,5 +14,5 @@
    <file_definition type="multiple_file" par_access="collective" output_freq="1ts" output_level="10" enabled=".TRUE.">
      <file id="output" name="output">
-        <field field_ref="src_field" name="field" />
+<!--        <field field_ref="src_field" name="field" />-->
      </file>
      <file id="output_dst" name="output_dst">
Index: XIOS/trunk/inputs/Version2/iodef.xml
===================================================================
--- XIOS/trunk/inputs/Version2/iodef.xml	(revision 663)
+++ XIOS/trunk/inputs/Version2/iodef.xml	(revision 664)
@@ -28,5 +28,5 @@
      </file>
      <file id="output_Axis_transformed" name="output_Axis_transformed" type="one_file">
-<!--        <field field_ref="field_Axis_transformed" />-->
+        <field field_ref="field_Axis_transformed" />
      </file>
      <file id="output_Axis_transformed_interpolated" name="output_Axis_transformed_interpolated">
@@ -34,5 +34,5 @@
      </file>
      <file id="output_Domain_transformed_interpolated" name="output_Domain_transformed_interpolated">
-        <field field_ref="field_Domain_transformed_Interpolated" />
+<!--        <field field_ref="field_Domain_transformed_Interpolated" />-->
      </file>
      <file id="output_Scalar" name="output_Scalar" type="one_file">
@@ -67,5 +67,5 @@
      <domain id="domain_A_zoom" domain_ref="domain_A">
 <!--       <zoom_domain zoom_ibegin="1" zoom_ni="3" zoom_jbegin="0" zoom_nj="2"/>-->
-       <zoom_domain zoom_ibegin="39" zoom_ni="20" zoom_jbegin="39" zoom_nj="20"/>
+       <zoom_domain zoom_ibegin="1" zoom_ni="9" zoom_jbegin="0" zoom_nj="2"/>
 <!--       <zoom_domain zoom_ibegin="0" zoom_ni="2" zoom_jbegin="0" zoom_nj="2"/>-->
      </domain>
Index: XIOS/trunk/src/attribute_array_decl.cpp
===================================================================
--- XIOS/trunk/src/attribute_array_decl.cpp	(revision 663)
+++ XIOS/trunk/src/attribute_array_decl.cpp	(revision 664)
@@ -7,4 +7,5 @@
   template class CAttributeArray<double,1> ;
   template class CAttributeArray<double,2> ;
+  template class CAttributeArray<double,3> ;
   template class CAttributeArray<int,1> ;
   template class CAttributeArray<int,2> ;
Index: XIOS/trunk/src/config/domain_attribute.conf
===================================================================
--- XIOS/trunk/src/config/domain_attribute.conf	(revision 663)
+++ XIOS/trunk/src/config/domain_attribute.conf	(revision 664)
@@ -24,7 +24,6 @@
 
 /* LOCAL */
-DECLARE_ARRAY(bool, 1 , mask_1D)
-DECLARE_ARRAY(bool, 2 , mask_2D)
-DECLARE_ARRAY(bool, 2 , mask)
+DECLARE_ARRAY(bool, 1 , mask_1d)
+DECLARE_ARRAY(bool, 2 , mask_2d)
 
 /* GLOBAL */
@@ -43,12 +42,22 @@
 
 /* LOCAL */
-DECLARE_ARRAY(double, 1, lonvalue)
-DECLARE_ARRAY(double, 1, latvalue)
+//DECLARE_ARRAY(double, 1, lonvalue)
+//DECLARE_ARRAY(double, 1, latvalue)
+DECLARE_ARRAY(double, 1, lonvalue_1d)
+DECLARE_ARRAY(double, 1, latvalue_1d)
+DECLARE_ARRAY(double, 2, lonvalue_2d)
+DECLARE_ARRAY(double, 2, latvalue_2d)
+
 DECLARE_ATTRIBUTE(int, nvertex)
-DECLARE_ARRAY(double, 2, bounds_lon)
-DECLARE_ARRAY(double, 2, bounds_lat)
+//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)
+DECLARE_ARRAY(double, 3, bounds_lon_2d)
+DECLARE_ARRAY(double, 3, bounds_lat_2d)
+
 DECLARE_ARRAY(double, 2, area)
 
-DECLARE_ENUM3(type,regular,curvilinear,unstructured) //rectilinear
+DECLARE_ENUM3(type,rectilinear,curvilinear,unstructured)
 DECLARE_ATTRIBUTE(StdString, domain_ref)
 
Index: XIOS/trunk/src/distribution_client.cpp
===================================================================
--- XIOS/trunk/src/distribution_client.cpp	(revision 663)
+++ XIOS/trunk/src/distribution_client.cpp	(revision 664)
@@ -132,6 +132,6 @@
   for (int i = 0; i < domainNum_;++i)
   {
-    domainMasks_[i].resize(domList[i]->mask.extent(0), domList[i]->mask.extent(1));
-    domainMasks_[i] = domList[i]->mask;
+    domainMasks_[i].resize(domList[i]->mask_1d.numElements());
+    domainMasks_[i] = domList[i]->mask_1d;
   }
 
@@ -274,5 +274,5 @@
         if ((iIdx >= nBeginLocal_[indexMap_[i]]) && (iIdx < nLocal_[indexMap_[i]]) &&
            (jIdx >= nBeginLocal_[indexMap_[i]+1]) && (jIdx < nLocal_[indexMap_[i]+1]) &&
-           (domainMasks_[idxDomain](iIdx, jIdx)))
+           (domainMasks_[idxDomain](iIdx + jIdx*nLocal_[indexMap_[i]])))
         {
           (localDomainIndex_[idxDomain]).push_back(iIdx);
Index: XIOS/trunk/src/distribution_client.hpp
===================================================================
--- XIOS/trunk/src/distribution_client.hpp	(revision 663)
+++ XIOS/trunk/src/distribution_client.hpp	(revision 664)
@@ -98,5 +98,5 @@
     std::vector<CArray<int,1> > dataIndex_; //!< Data index
 
-    std::vector<CArray<bool,2> > domainMasks_; //!< Domain mask
+    std::vector<CArray<bool,1> > domainMasks_; //!< Domain mask
     std::vector<CArray<bool,1> > axisMasks_; //!< Axis mask
 
Index: XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 663)
+++ XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 664)
@@ -43,49 +43,99 @@
 
 
-  void cxios_set_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData);
-    domain_hdl->bounds_lat.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_bounds_lat(domain_Ptr domain_hdl, double* bounds_lat, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData);
-    tmp=domain_hdl->bounds_lat.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_bounds_lat(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->bounds_lat.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData);
-    domain_hdl->bounds_lon.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_bounds_lon(domain_Ptr domain_hdl, double* bounds_lon, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData);
-    tmp=domain_hdl->bounds_lon.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_bounds_lon(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->bounds_lon.hasInheritedValue();
+  void cxios_set_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
+    domain_hdl->bounds_lat_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lat_1d(domain_Ptr domain_hdl, double* bounds_lat_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
+    tmp=domain_hdl->bounds_lat_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lat_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lat_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    domain_hdl->bounds_lat_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lat_2d(domain_Ptr domain_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    tmp=domain_hdl->bounds_lat_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lat_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lat_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
+    domain_hdl->bounds_lon_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lon_1d(domain_Ptr domain_hdl, double* bounds_lon_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
+    tmp=domain_hdl->bounds_lon_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lon_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lon_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    domain_hdl->bounds_lon_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_bounds_lon_2d(domain_Ptr domain_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    tmp=domain_hdl->bounds_lon_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_bounds_lon_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->bounds_lon_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -429,24 +479,49 @@
 
 
-  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData);
-    domain_hdl->latvalue.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData);
-    tmp=domain_hdl->latvalue.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_latvalue(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->latvalue.hasInheritedValue();
+  void cxios_set_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
+    domain_hdl->latvalue_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_latvalue_1d(domain_Ptr domain_hdl, double* latvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
+    tmp=domain_hdl->latvalue_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_latvalue_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->latvalue_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
+    domain_hdl->latvalue_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_latvalue_2d(domain_Ptr domain_hdl, double* latvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domain_hdl->latvalue_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_latvalue_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->latvalue_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -480,49 +555,99 @@
 
 
-  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData);
-    domain_hdl->lonvalue.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData);
-    tmp=domain_hdl->lonvalue.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_lonvalue(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->lonvalue.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData);
-    domain_hdl->mask.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData);
-    tmp=domain_hdl->mask.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domain_mask(domain_Ptr domain_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domain_hdl->mask.hasInheritedValue();
+  void cxios_set_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
+    domain_hdl->lonvalue_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_lonvalue_1d(domain_Ptr domain_hdl, double* lonvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
+    tmp=domain_hdl->lonvalue_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_lonvalue_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->lonvalue_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
+    domain_hdl->lonvalue_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_lonvalue_2d(domain_Ptr domain_hdl, double* lonvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domain_hdl->lonvalue_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_lonvalue_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->lonvalue_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
+    domain_hdl->mask_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_mask_1d(domain_Ptr domain_hdl, bool* mask_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
+    tmp=domain_hdl->mask_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_mask_1d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->mask_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
+    domain_hdl->mask_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_mask_2d(domain_Ptr domain_hdl, bool* mask_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domain_hdl->mask_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_mask_2d(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->mask_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
Index: XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 663)
+++ XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 664)
@@ -43,49 +43,99 @@
 
 
-  void cxios_set_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData);
-    domaingroup_hdl->bounds_lat.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl, double* bounds_lat, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lat, shape(extent1, extent2), neverDeleteData);
-    tmp=domaingroup_hdl->bounds_lat.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_bounds_lat(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->bounds_lat.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData);
-    domaingroup_hdl->bounds_lon.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl, double* bounds_lon, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,2> tmp(bounds_lon, shape(extent1, extent2), neverDeleteData);
-    tmp=domaingroup_hdl->bounds_lon.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_bounds_lon(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->bounds_lon.hasInheritedValue();
+  void cxios_set_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
+    domaingroup_hdl->bounds_lat_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lat_1d, shape(extent1, extent2), neverDeleteData);
+    tmp=domaingroup_hdl->bounds_lat_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lat_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    domaingroup_hdl->bounds_lat_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lat_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lat_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    tmp=domaingroup_hdl->bounds_lat_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lat_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
+    domaingroup_hdl->bounds_lon_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_1d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(bounds_lon_1d, shape(extent1, extent2), neverDeleteData);
+    tmp=domaingroup_hdl->bounds_lon_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lon_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    domaingroup_hdl->bounds_lon_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl, double* bounds_lon_2d, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,3> tmp(bounds_lon_2d, shape(extent1, extent2, extent3), neverDeleteData);
+    tmp=domaingroup_hdl->bounds_lon_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->bounds_lon_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -455,24 +505,49 @@
 
 
-  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData);
-    domaingroup_hdl->latvalue.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(latvalue, shape(extent1), neverDeleteData);
-    tmp=domaingroup_hdl->latvalue.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->latvalue.hasInheritedValue();
+  void cxios_set_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
+    domaingroup_hdl->latvalue_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl, double* latvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(latvalue_1d, shape(extent1), neverDeleteData);
+    tmp=domaingroup_hdl->latvalue_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_latvalue_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->latvalue_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl, double* latvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
+    domaingroup_hdl->latvalue_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl, double* latvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(latvalue_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domaingroup_hdl->latvalue_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_latvalue_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->latvalue_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
@@ -506,49 +581,99 @@
 
 
-  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData);
-    domaingroup_hdl->lonvalue.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<double,1> tmp(lonvalue, shape(extent1), neverDeleteData);
-    tmp=domaingroup_hdl->lonvalue.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->lonvalue.hasInheritedValue();
-     CTimer::get("XIOS").suspend();
-     return isDefined;
-  }
-
-
-  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData);
-    domaingroup_hdl->mask.reference(tmp.copy());
-     CTimer::get("XIOS").suspend();
-  }
-
-  void cxios_get_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
-  {
-    CTimer::get("XIOS").resume();
-    CArray<bool,2> tmp(mask, shape(extent1, extent2), neverDeleteData);
-    tmp=domaingroup_hdl->mask.getInheritedValue();
-     CTimer::get("XIOS").suspend();
-  }
-
-  bool cxios_is_defined_domaingroup_mask(domaingroup_Ptr domaingroup_hdl)
-  {
-     CTimer::get("XIOS").resume();
-     bool isDefined = domaingroup_hdl->mask.hasInheritedValue();
+  void cxios_set_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
+    domaingroup_hdl->lonvalue_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,1> tmp(lonvalue_1d, shape(extent1), neverDeleteData);
+    tmp=domaingroup_hdl->lonvalue_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->lonvalue_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
+    domaingroup_hdl->lonvalue_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl, double* lonvalue_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<double,2> tmp(lonvalue_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domaingroup_hdl->lonvalue_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->lonvalue_2d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl, bool* mask_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
+    domaingroup_hdl->mask_1d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl, bool* mask_1d, int extent1)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,1> tmp(mask_1d, shape(extent1), neverDeleteData);
+    tmp=domaingroup_hdl->mask_1d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_mask_1d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->mask_1d.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl, bool* mask_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
+    domaingroup_hdl->mask_2d.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl, bool* mask_2d, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask_2d, shape(extent1, extent2), neverDeleteData);
+    tmp=domaingroup_hdl->mask_2d.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_mask_2d(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->mask_2d.hasInheritedValue();
      CTimer::get("XIOS").suspend();
      return isDefined;
Index: XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 663)
+++ XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 664)
@@ -33,48 +33,98 @@
 
 
-    SUBROUTINE cxios_set_domain_bounds_lat(domain_hdl, bounds_lat, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domain_bounds_lat
-
-    SUBROUTINE cxios_get_domain_bounds_lat(domain_hdl, bounds_lat, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domain_bounds_lat
-
-    FUNCTION cxios_is_defined_domain_bounds_lat(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_bounds_lat
-
-
-    SUBROUTINE cxios_set_domain_bounds_lon(domain_hdl, bounds_lon, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domain_bounds_lon
-
-    SUBROUTINE cxios_get_domain_bounds_lon(domain_hdl, bounds_lon, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domain_bounds_lon
-
-    FUNCTION cxios_is_defined_domain_bounds_lon(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_bounds_lon
+    SUBROUTINE cxios_set_domain_bounds_lat_1d(domain_hdl, bounds_lat_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domain_bounds_lat_1d
+
+    SUBROUTINE cxios_get_domain_bounds_lat_1d(domain_hdl, bounds_lat_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domain_bounds_lat_1d
+
+    FUNCTION cxios_is_defined_domain_bounds_lat_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_bounds_lat_1d
+
+
+    SUBROUTINE cxios_set_domain_bounds_lat_2d(domain_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_set_domain_bounds_lat_2d
+
+    SUBROUTINE cxios_get_domain_bounds_lat_2d(domain_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_get_domain_bounds_lat_2d
+
+    FUNCTION cxios_is_defined_domain_bounds_lat_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lat_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_bounds_lat_2d
+
+
+    SUBROUTINE cxios_set_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domain_bounds_lon_1d
+
+    SUBROUTINE cxios_get_domain_bounds_lon_1d(domain_hdl, bounds_lon_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domain_bounds_lon_1d
+
+    FUNCTION cxios_is_defined_domain_bounds_lon_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_bounds_lon_1d
+
+
+    SUBROUTINE cxios_set_domain_bounds_lon_2d(domain_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_set_domain_bounds_lon_2d
+
+    SUBROUTINE cxios_get_domain_bounds_lon_2d(domain_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_get_domain_bounds_lon_2d
+
+    FUNCTION cxios_is_defined_domain_bounds_lon_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_bounds_lon_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_bounds_lon_2d
 
 
@@ -357,23 +407,46 @@
 
 
-    SUBROUTINE cxios_set_domain_latvalue(domain_hdl, latvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_domain_latvalue
-
-    SUBROUTINE cxios_get_domain_latvalue(domain_hdl, latvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_domain_latvalue
-
-    FUNCTION cxios_is_defined_domain_latvalue(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_latvalue
+    SUBROUTINE cxios_set_domain_latvalue_1d(domain_hdl, latvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domain_latvalue_1d
+
+    SUBROUTINE cxios_get_domain_latvalue_1d(domain_hdl, latvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domain_latvalue_1d
+
+    FUNCTION cxios_is_defined_domain_latvalue_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_latvalue_1d
+
+
+    SUBROUTINE cxios_set_domain_latvalue_2d(domain_hdl, latvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domain_latvalue_2d
+
+    SUBROUTINE cxios_get_domain_latvalue_2d(domain_hdl, latvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domain_latvalue_2d
+
+    FUNCTION cxios_is_defined_domain_latvalue_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_latvalue_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_latvalue_2d
 
 
@@ -399,46 +472,90 @@
 
 
-    SUBROUTINE cxios_set_domain_lonvalue(domain_hdl, lonvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_domain_lonvalue
-
-    SUBROUTINE cxios_get_domain_lonvalue(domain_hdl, lonvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_domain_lonvalue
-
-    FUNCTION cxios_is_defined_domain_lonvalue(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_lonvalue
-
-
-    SUBROUTINE cxios_set_domain_mask(domain_hdl, mask, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domain_mask
-
-    SUBROUTINE cxios_get_domain_mask(domain_hdl, mask, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domain_mask
-
-    FUNCTION cxios_is_defined_domain_mask(domain_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask
-      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
-    END FUNCTION cxios_is_defined_domain_mask
+    SUBROUTINE cxios_set_domain_lonvalue_1d(domain_hdl, lonvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domain_lonvalue_1d
+
+    SUBROUTINE cxios_get_domain_lonvalue_1d(domain_hdl, lonvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domain_lonvalue_1d
+
+    FUNCTION cxios_is_defined_domain_lonvalue_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_lonvalue_1d
+
+
+    SUBROUTINE cxios_set_domain_lonvalue_2d(domain_hdl, lonvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domain_lonvalue_2d
+
+    SUBROUTINE cxios_get_domain_lonvalue_2d(domain_hdl, lonvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domain_lonvalue_2d
+
+    FUNCTION cxios_is_defined_domain_lonvalue_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_lonvalue_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_lonvalue_2d
+
+
+    SUBROUTINE cxios_set_domain_mask_1d(domain_hdl, mask_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domain_mask_1d
+
+    SUBROUTINE cxios_get_domain_mask_1d(domain_hdl, mask_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domain_mask_1d
+
+    FUNCTION cxios_is_defined_domain_mask_1d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_mask_1d
+
+
+    SUBROUTINE cxios_set_domain_mask_2d(domain_hdl, mask_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domain_mask_2d
+
+    SUBROUTINE cxios_get_domain_mask_2d(domain_hdl, mask_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domain_mask_2d
+
+    FUNCTION cxios_is_defined_domain_mask_2d(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_mask_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_mask_2d
 
 
Index: XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 663)
+++ XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 664)
@@ -33,48 +33,98 @@
 
 
-    SUBROUTINE cxios_set_domaingroup_bounds_lat(domaingroup_hdl, bounds_lat, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domaingroup_bounds_lat
-
-    SUBROUTINE cxios_get_domaingroup_bounds_lat(domaingroup_hdl, bounds_lat, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domaingroup_bounds_lat
-
-    FUNCTION cxios_is_defined_domaingroup_bounds_lat(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_bounds_lat
-
-
-    SUBROUTINE cxios_set_domaingroup_bounds_lon(domaingroup_hdl, bounds_lon, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domaingroup_bounds_lon
-
-    SUBROUTINE cxios_get_domaingroup_bounds_lon(domaingroup_hdl, bounds_lon, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domaingroup_bounds_lon
-
-    FUNCTION cxios_is_defined_domaingroup_bounds_lon(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_bounds_lon
+    SUBROUTINE cxios_set_domaingroup_bounds_lat_1d(domaingroup_hdl, bounds_lat_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domaingroup_bounds_lat_1d
+
+    SUBROUTINE cxios_get_domaingroup_bounds_lat_1d(domaingroup_hdl, bounds_lat_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domaingroup_bounds_lat_1d
+
+    FUNCTION cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_bounds_lat_2d(domaingroup_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_set_domaingroup_bounds_lat_2d
+
+    SUBROUTINE cxios_get_domaingroup_bounds_lat_2d(domaingroup_hdl, bounds_lat_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lat_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_get_domaingroup_bounds_lat_2d
+
+    FUNCTION cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lat_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_bounds_lat_2d
+
+
+    SUBROUTINE cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domaingroup_bounds_lon_1d
+
+    SUBROUTINE cxios_get_domaingroup_bounds_lon_1d(domaingroup_hdl, bounds_lon_1d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domaingroup_bounds_lon_1d
+
+    FUNCTION cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_bounds_lon_2d(domaingroup_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_set_domaingroup_bounds_lon_2d
+
+    SUBROUTINE cxios_get_domaingroup_bounds_lon_2d(domaingroup_hdl, bounds_lon_2d, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: bounds_lon_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+      INTEGER (kind = C_INT), VALUE  :: extent3
+    END SUBROUTINE cxios_get_domaingroup_bounds_lon_2d
+
+    FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_bounds_lon_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_bounds_lon_2d
 
 
@@ -378,23 +428,46 @@
 
 
-    SUBROUTINE cxios_set_domaingroup_latvalue(domaingroup_hdl, latvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_domaingroup_latvalue
-
-    SUBROUTINE cxios_get_domaingroup_latvalue(domaingroup_hdl, latvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_domaingroup_latvalue
-
-    FUNCTION cxios_is_defined_domaingroup_latvalue(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_latvalue
+    SUBROUTINE cxios_set_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domaingroup_latvalue_1d
+
+    SUBROUTINE cxios_get_domaingroup_latvalue_1d(domaingroup_hdl, latvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domaingroup_latvalue_1d
+
+    FUNCTION cxios_is_defined_domaingroup_latvalue_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_latvalue_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_latvalue_2d(domaingroup_hdl, latvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domaingroup_latvalue_2d
+
+    SUBROUTINE cxios_get_domaingroup_latvalue_2d(domaingroup_hdl, latvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: latvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domaingroup_latvalue_2d
+
+    FUNCTION cxios_is_defined_domaingroup_latvalue_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_latvalue_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_latvalue_2d
 
 
@@ -420,46 +493,90 @@
 
 
-    SUBROUTINE cxios_set_domaingroup_lonvalue(domaingroup_hdl, lonvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_set_domaingroup_lonvalue
-
-    SUBROUTINE cxios_get_domaingroup_lonvalue(domaingroup_hdl, lonvalue, extent1) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue
-      INTEGER (kind = C_INT), VALUE  :: extent1
-    END SUBROUTINE cxios_get_domaingroup_lonvalue
-
-    FUNCTION cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_lonvalue
-
-
-    SUBROUTINE cxios_set_domaingroup_mask(domaingroup_hdl, mask, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_set_domaingroup_mask
-
-    SUBROUTINE cxios_get_domaingroup_mask(domaingroup_hdl, mask, extent1, extent2) BIND(C)
-      USE ISO_C_BINDING
-      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
-      INTEGER (kind = C_INT), VALUE  :: extent1
-      INTEGER (kind = C_INT), VALUE  :: extent2
-    END SUBROUTINE cxios_get_domaingroup_mask
-
-    FUNCTION cxios_is_defined_domaingroup_mask(domaingroup_hdl) BIND(C)
-      USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask
-      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
-    END FUNCTION cxios_is_defined_domaingroup_mask
+    SUBROUTINE cxios_set_domaingroup_lonvalue_1d(domaingroup_hdl, lonvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domaingroup_lonvalue_1d
+
+    SUBROUTINE cxios_get_domaingroup_lonvalue_1d(domaingroup_hdl, lonvalue_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domaingroup_lonvalue_1d
+
+    FUNCTION cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_lonvalue_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_lonvalue_2d(domaingroup_hdl, lonvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domaingroup_lonvalue_2d
+
+    SUBROUTINE cxios_get_domaingroup_lonvalue_2d(domaingroup_hdl, lonvalue_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      REAL (KIND=C_DOUBLE)     , DIMENSION(*) :: lonvalue_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domaingroup_lonvalue_2d
+
+    FUNCTION cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_lonvalue_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_lonvalue_2d
+
+
+    SUBROUTINE cxios_set_domaingroup_mask_1d(domaingroup_hdl, mask_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_domaingroup_mask_1d
+
+    SUBROUTINE cxios_get_domaingroup_mask_1d(domaingroup_hdl, mask_1d, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_1d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_domaingroup_mask_1d
+
+    FUNCTION cxios_is_defined_domaingroup_mask_1d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask_1d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_mask_1d
+
+
+    SUBROUTINE cxios_set_domaingroup_mask_2d(domaingroup_hdl, mask_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_domaingroup_mask_2d
+
+    SUBROUTINE cxios_get_domaingroup_mask_2d(domaingroup_hdl, mask_2d, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask_2d
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_domaingroup_mask_2d
+
+    FUNCTION cxios_is_defined_domaingroup_mask_2d(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_mask_2d
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_mask_2d
 
 
Index: XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 663)
+++ XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 664)
@@ -12,8 +12,8 @@
 
   SUBROUTINE xios(set_domain_attr)  &
-    ( domain_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -21,6 +21,8 @@
       CHARACTER(LEN=*), INTENT(IN) ::domain_id
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:)
@@ -37,9 +39,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       INTEGER  , OPTIONAL, INTENT(IN) :: ni
@@ -53,22 +59,24 @@
       CALL xios(get_domain_handle)(domain_id,domain_hdl)
       CALL xios(set_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(set_domain_attr)
 
   SUBROUTINE xios(set_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:)
@@ -85,9 +93,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       INTEGER  , OPTIONAL, INTENT(IN) :: ni
@@ -100,22 +112,25 @@
 
       CALL xios(set_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(set_domain_attr_hdl)
 
   SUBROUTINE xios(set_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  &
-    , nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:)
@@ -132,9 +147,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d_(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       INTEGER  , OPTIONAL, INTENT(IN) :: ni_
@@ -150,10 +169,18 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        CALL cxios_set_domain_bounds_lat(domain_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2))
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        CALL cxios_set_domain_bounds_lon(domain_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2))
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        CALL cxios_set_domain_bounds_lat_1d(domain_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        CALL cxios_set_domain_bounds_lat_2d(domain_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        CALL cxios_set_domain_bounds_lon_1d(domain_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        CALL cxios_set_domain_bounds_lon_2d(domain_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3))
       ENDIF
 
@@ -214,6 +241,10 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        CALL cxios_set_domain_latvalue(domain_hdl%daddr, latvalue_, size(latvalue_,1))
+      IF (PRESENT(latvalue_1d_)) THEN
+        CALL cxios_set_domain_latvalue_1d(domain_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        CALL cxios_set_domain_latvalue_2d(domain_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2))
       ENDIF
 
@@ -222,12 +253,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        CALL cxios_set_domain_lonvalue(domain_hdl%daddr, lonvalue_, size(lonvalue_,1))
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2)))
-        mask__tmp = mask_
-        CALL cxios_set_domain_mask(domain_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2))
+      IF (PRESENT(lonvalue_1d_)) THEN
+        CALL cxios_set_domain_lonvalue_1d(domain_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        CALL cxios_set_domain_lonvalue_2d(domain_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2))
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        ALLOCATE(mask_1d__tmp(size(mask_1d_,1)))
+        mask_1d__tmp = mask_1d_
+        CALL cxios_set_domain_mask_1d(domain_hdl%daddr, mask_1d__tmp, size(mask_1d_,1))
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2)))
+        mask_2d__tmp = mask_2d_
+        CALL cxios_set_domain_mask_2d(domain_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2))
       ENDIF
 
@@ -267,8 +308,8 @@
 
   SUBROUTINE xios(get_domain_attr)  &
-    ( domain_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -276,6 +317,8 @@
       CHARACTER(LEN=*), INTENT(IN) ::domain_id
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:)
@@ -292,9 +335,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni
@@ -308,22 +355,24 @@
       CALL xios(get_domain_handle)(domain_id,domain_hdl)
       CALL xios(get_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(get_domain_attr)
 
   SUBROUTINE xios(get_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:)
@@ -340,9 +389,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni
@@ -355,22 +408,25 @@
 
       CALL xios(get_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(get_domain_attr_hdl)
 
   SUBROUTINE xios(get_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  &
-    , nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
       TYPE(txios(domain)) , INTENT(IN) :: domain_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index_(:)
@@ -387,9 +443,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index_(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin_
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d_(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
@@ -405,10 +465,18 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        CALL cxios_get_domain_bounds_lat(domain_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2))
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        CALL cxios_get_domain_bounds_lon(domain_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2))
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        CALL cxios_get_domain_bounds_lat_1d(domain_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        CALL cxios_get_domain_bounds_lat_2d(domain_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        CALL cxios_get_domain_bounds_lon_1d(domain_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        CALL cxios_get_domain_bounds_lon_2d(domain_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3))
       ENDIF
 
@@ -469,6 +537,10 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        CALL cxios_get_domain_latvalue(domain_hdl%daddr, latvalue_, size(latvalue_,1))
+      IF (PRESENT(latvalue_1d_)) THEN
+        CALL cxios_get_domain_latvalue_1d(domain_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        CALL cxios_get_domain_latvalue_2d(domain_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2))
       ENDIF
 
@@ -477,12 +549,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        CALL cxios_get_domain_lonvalue(domain_hdl%daddr, lonvalue_, size(lonvalue_,1))
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2)))
-        CALL cxios_get_domain_mask(domain_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2))
-        mask_ = mask__tmp
+      IF (PRESENT(lonvalue_1d_)) THEN
+        CALL cxios_get_domain_lonvalue_1d(domain_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        CALL cxios_get_domain_lonvalue_2d(domain_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2))
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        ALLOCATE(mask_1d__tmp(size(mask_1d_,1)))
+        CALL cxios_get_domain_mask_1d(domain_hdl%daddr, mask_1d__tmp, size(mask_1d_,1))
+        mask_1d_ = mask_1d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2)))
+        CALL cxios_get_domain_mask_2d(domain_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2))
+        mask_2d_ = mask_2d__tmp
       ENDIF
 
@@ -522,8 +604,8 @@
 
   SUBROUTINE xios(is_defined_domain_attr)  &
-    ( domain_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -532,8 +614,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat
-      LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon
-      LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
       LOGICAL(KIND=C_BOOL) :: data_dim_tmp
@@ -564,12 +650,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
       LOGICAL(KIND=C_BOOL) :: jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
-      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
-      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d
+      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d
+      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -591,16 +683,16 @@
       CALL xios(get_domain_handle)(domain_id,domain_hdl)
       CALL xios(is_defined_domain_attr_hdl_)   &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(is_defined_domain_attr)
 
   SUBROUTINE xios(is_defined_domain_attr_hdl)  &
-    ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-    , standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -608,8 +700,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat
-      LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon
-      LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
       LOGICAL(KIND=C_BOOL) :: data_dim_tmp
@@ -640,12 +736,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
       LOGICAL(KIND=C_BOOL) :: jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
-      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
-      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d
+      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d
+      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -666,16 +768,17 @@
 
       CALL xios(is_defined_domain_attr_hdl_)  &
-      ( domain_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo, nvertex  &
-      , standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(is_defined_domain_attr_hdl)
 
   SUBROUTINE xios(is_defined_domain_attr_hdl_)   &
-    ( domain_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_, ni_glo_, nj_  &
-    , nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
@@ -683,8 +786,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area_
       LOGICAL(KIND=C_BOOL) :: area__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_
-      LOGICAL(KIND=C_BOOL) :: bounds_lat__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_
-      LOGICAL(KIND=C_BOOL) :: bounds_lon__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_
       LOGICAL(KIND=C_BOOL) :: data_dim__tmp
@@ -715,12 +822,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_
       LOGICAL(KIND=C_BOOL) :: jbegin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_
-      LOGICAL(KIND=C_BOOL) :: latvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d_
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d_
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL(KIND=C_BOOL) :: long_name__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_
-      LOGICAL(KIND=C_BOOL) :: lonvalue__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
-      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d_
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d_
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d_
+      LOGICAL(KIND=C_BOOL) :: mask_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d_
+      LOGICAL(KIND=C_BOOL) :: mask_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
@@ -745,12 +858,22 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        bounds_lat__tmp = cxios_is_defined_domain_bounds_lat(domain_hdl%daddr)
-        bounds_lat_ = bounds_lat__tmp
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        bounds_lon__tmp = cxios_is_defined_domain_bounds_lon(domain_hdl%daddr)
-        bounds_lon_ = bounds_lon__tmp
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        bounds_lat_1d__tmp = cxios_is_defined_domain_bounds_lat_1d(domain_hdl%daddr)
+        bounds_lat_1d_ = bounds_lat_1d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        bounds_lat_2d__tmp = cxios_is_defined_domain_bounds_lat_2d(domain_hdl%daddr)
+        bounds_lat_2d_ = bounds_lat_2d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        bounds_lon_1d__tmp = cxios_is_defined_domain_bounds_lon_1d(domain_hdl%daddr)
+        bounds_lon_1d_ = bounds_lon_1d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        bounds_lon_2d__tmp = cxios_is_defined_domain_bounds_lon_2d(domain_hdl%daddr)
+        bounds_lon_2d_ = bounds_lon_2d__tmp
       ENDIF
 
@@ -825,7 +948,12 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        latvalue__tmp = cxios_is_defined_domain_latvalue(domain_hdl%daddr)
-        latvalue_ = latvalue__tmp
+      IF (PRESENT(latvalue_1d_)) THEN
+        latvalue_1d__tmp = cxios_is_defined_domain_latvalue_1d(domain_hdl%daddr)
+        latvalue_1d_ = latvalue_1d__tmp
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        latvalue_2d__tmp = cxios_is_defined_domain_latvalue_2d(domain_hdl%daddr)
+        latvalue_2d_ = latvalue_2d__tmp
       ENDIF
 
@@ -835,12 +963,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        lonvalue__tmp = cxios_is_defined_domain_lonvalue(domain_hdl%daddr)
-        lonvalue_ = lonvalue__tmp
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        mask__tmp = cxios_is_defined_domain_mask(domain_hdl%daddr)
-        mask_ = mask__tmp
+      IF (PRESENT(lonvalue_1d_)) THEN
+        lonvalue_1d__tmp = cxios_is_defined_domain_lonvalue_1d(domain_hdl%daddr)
+        lonvalue_1d_ = lonvalue_1d__tmp
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        lonvalue_2d__tmp = cxios_is_defined_domain_lonvalue_2d(domain_hdl%daddr)
+        lonvalue_2d_ = lonvalue_2d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        mask_1d__tmp = cxios_is_defined_domain_mask_1d(domain_hdl%daddr)
+        mask_1d_ = mask_1d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        mask_2d__tmp = cxios_is_defined_domain_mask_2d(domain_hdl%daddr)
+        mask_2d_ = mask_2d__tmp
       ENDIF
 
Index: XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 663)
+++ XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 664)
@@ -12,8 +12,9 @@
 
   SUBROUTINE xios(set_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -21,6 +22,8 @@
       CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:)
@@ -38,9 +41,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       INTEGER  , OPTIONAL, INTENT(IN) :: ni
@@ -54,22 +61,26 @@
       CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl)
       CALL xios(set_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(set_domaingroup_attr)
 
   SUBROUTINE xios(set_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index(:)
@@ -87,9 +98,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       INTEGER  , OPTIONAL, INTENT(IN) :: ni
@@ -102,22 +117,26 @@
 
       CALL xios(set_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(set_domaingroup_attr_hdl)
 
   SUBROUTINE xios(set_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_  &
-    , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: area_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lat_2d_(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: bounds_lon_2d_(:,:,:)
       INTEGER  , OPTIONAL, INTENT(IN) :: data_dim_
       INTEGER  , OPTIONAL, INTENT(IN) :: data_i_index_(:)
@@ -135,9 +154,13 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: j_index_(:)
       INTEGER  , OPTIONAL, INTENT(IN) :: jbegin_
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: latvalue_2d_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
-      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_(:)
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(IN) :: lonvalue_2d_(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_1d_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_2d_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       INTEGER  , OPTIONAL, INTENT(IN) :: ni_
@@ -153,10 +176,18 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        CALL cxios_set_domaingroup_bounds_lat(domaingroup_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2))
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        CALL cxios_set_domaingroup_bounds_lon(domaingroup_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2))
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        CALL cxios_set_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        CALL cxios_set_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        CALL cxios_set_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        CALL cxios_set_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3))
       ENDIF
 
@@ -221,6 +252,10 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        CALL cxios_set_domaingroup_latvalue(domaingroup_hdl%daddr, latvalue_, size(latvalue_,1))
+      IF (PRESENT(latvalue_1d_)) THEN
+        CALL cxios_set_domaingroup_latvalue_1d(domaingroup_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        CALL cxios_set_domaingroup_latvalue_2d(domaingroup_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2))
       ENDIF
 
@@ -229,12 +264,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        CALL cxios_set_domaingroup_lonvalue(domaingroup_hdl%daddr, lonvalue_, size(lonvalue_,1))
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2)))
-        mask__tmp = mask_
-        CALL cxios_set_domaingroup_mask(domaingroup_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2))
+      IF (PRESENT(lonvalue_1d_)) THEN
+        CALL cxios_set_domaingroup_lonvalue_1d(domaingroup_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        CALL cxios_set_domaingroup_lonvalue_2d(domaingroup_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2))
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        ALLOCATE(mask_1d__tmp(size(mask_1d_,1)))
+        mask_1d__tmp = mask_1d_
+        CALL cxios_set_domaingroup_mask_1d(domaingroup_hdl%daddr, mask_1d__tmp, size(mask_1d_,1))
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2)))
+        mask_2d__tmp = mask_2d_
+        CALL cxios_set_domaingroup_mask_2d(domaingroup_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2))
       ENDIF
 
@@ -274,8 +319,9 @@
 
   SUBROUTINE xios(get_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -283,6 +329,8 @@
       CHARACTER(LEN=*), INTENT(IN) ::domaingroup_id
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:)
@@ -300,9 +348,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni
@@ -316,22 +368,26 @@
       CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl)
       CALL xios(get_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(get_domaingroup_attr)
 
   SUBROUTINE xios(get_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index(:)
@@ -349,9 +405,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d_tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni
@@ -364,22 +424,26 @@
 
       CALL xios(get_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(get_domaingroup_attr_hdl)
 
   SUBROUTINE xios(get_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_  &
-    , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
       TYPE(txios(domaingroup)) , INTENT(IN) :: domaingroup_hdl
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: area_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_(:,:)
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lat_2d_(:,:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_1d_(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: bounds_lon_2d_(:,:,:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_dim_
       INTEGER  , OPTIONAL, INTENT(OUT) :: data_i_index_(:)
@@ -397,9 +461,13 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: j_index_(:)
       INTEGER  , OPTIONAL, INTENT(OUT) :: jbegin_
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: latvalue_2d_(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
-      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_(:)
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_1d_(:)
+      REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: lonvalue_2d_(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_1d_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_1d__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_2d_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_2d__tmp(:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       INTEGER  , OPTIONAL, INTENT(OUT) :: ni_
@@ -415,10 +483,18 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        CALL cxios_get_domaingroup_bounds_lat(domaingroup_hdl%daddr, bounds_lat_, size(bounds_lat_,1), size(bounds_lat_,2))
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        CALL cxios_get_domaingroup_bounds_lon(domaingroup_hdl%daddr, bounds_lon_, size(bounds_lon_,1), size(bounds_lon_,2))
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        CALL cxios_get_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr, bounds_lat_1d_, size(bounds_lat_1d_,1), size(bounds_lat_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        CALL cxios_get_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr, bounds_lat_2d_, size(bounds_lat_2d_,1), size(bounds_lat_2d_,2), size(bounds_lat_2d_,3))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        CALL cxios_get_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr, bounds_lon_1d_, size(bounds_lon_1d_,1), size(bounds_lon_1d_,2))
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        CALL cxios_get_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr, bounds_lon_2d_, size(bounds_lon_2d_,1), size(bounds_lon_2d_,2), size(bounds_lon_2d_,3))
       ENDIF
 
@@ -483,6 +559,10 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        CALL cxios_get_domaingroup_latvalue(domaingroup_hdl%daddr, latvalue_, size(latvalue_,1))
+      IF (PRESENT(latvalue_1d_)) THEN
+        CALL cxios_get_domaingroup_latvalue_1d(domaingroup_hdl%daddr, latvalue_1d_, size(latvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        CALL cxios_get_domaingroup_latvalue_2d(domaingroup_hdl%daddr, latvalue_2d_, size(latvalue_2d_,1), size(latvalue_2d_,2))
       ENDIF
 
@@ -491,12 +571,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        CALL cxios_get_domaingroup_lonvalue(domaingroup_hdl%daddr, lonvalue_, size(lonvalue_,1))
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1), size(mask_,2)))
-        CALL cxios_get_domaingroup_mask(domaingroup_hdl%daddr, mask__tmp, size(mask_,1), size(mask_,2))
-        mask_ = mask__tmp
+      IF (PRESENT(lonvalue_1d_)) THEN
+        CALL cxios_get_domaingroup_lonvalue_1d(domaingroup_hdl%daddr, lonvalue_1d_, size(lonvalue_1d_,1))
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        CALL cxios_get_domaingroup_lonvalue_2d(domaingroup_hdl%daddr, lonvalue_2d_, size(lonvalue_2d_,1), size(lonvalue_2d_,2))
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        ALLOCATE(mask_1d__tmp(size(mask_1d_,1)))
+        CALL cxios_get_domaingroup_mask_1d(domaingroup_hdl%daddr, mask_1d__tmp, size(mask_1d_,1))
+        mask_1d_ = mask_1d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        ALLOCATE(mask_2d__tmp(size(mask_2d_,1), size(mask_2d_,2)))
+        CALL cxios_get_domaingroup_mask_2d(domaingroup_hdl%daddr, mask_2d__tmp, size(mask_2d_,1), size(mask_2d_,2))
+        mask_2d_ = mask_2d__tmp
       ENDIF
 
@@ -536,8 +626,9 @@
 
   SUBROUTINE xios(is_defined_domaingroup_attr)  &
-    ( domaingroup_id, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -546,8 +637,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat
-      LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon
-      LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
       LOGICAL(KIND=C_BOOL) :: data_dim_tmp
@@ -580,12 +675,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
       LOGICAL(KIND=C_BOOL) :: jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
-      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
-      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d
+      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d
+      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -607,16 +708,18 @@
       CALL xios(get_domaingroup_handle)(domaingroup_id,domaingroup_hdl)
       CALL xios(is_defined_domaingroup_attr_hdl_)   &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr)
 
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl)  &
-    ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-    , nvertex, standard_name, type )
+    ( 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 )
 
     IMPLICIT NONE
@@ -624,8 +727,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area
       LOGICAL(KIND=C_BOOL) :: area_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat
-      LOGICAL(KIND=C_BOOL) :: bounds_lat_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon
-      LOGICAL(KIND=C_BOOL) :: bounds_lon_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim
       LOGICAL(KIND=C_BOOL) :: data_dim_tmp
@@ -658,12 +765,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin
       LOGICAL(KIND=C_BOOL) :: jbegin_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue
-      LOGICAL(KIND=C_BOOL) :: latvalue_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name
       LOGICAL(KIND=C_BOOL) :: long_name_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue
-      LOGICAL(KIND=C_BOOL) :: lonvalue_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d
+      LOGICAL(KIND=C_BOOL) :: mask_1d_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d
+      LOGICAL(KIND=C_BOOL) :: mask_2d_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -684,16 +797,18 @@
 
       CALL xios(is_defined_domaingroup_attr_hdl_)  &
-      ( domaingroup_hdl, area, bounds_lat, bounds_lon, 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, long_name, lonvalue, mask, name, ni, ni_glo, nj, nj_glo  &
-      , nvertex, standard_name, type )
+      ( 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 )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr_hdl)
 
   SUBROUTINE xios(is_defined_domaingroup_attr_hdl_)   &
-    ( domaingroup_hdl, area_, bounds_lat_, bounds_lon_, 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_, long_name_, lonvalue_, mask_, name_, ni_  &
-    , ni_glo_, nj_, nj_glo_, nvertex_, standard_name_, type_ )
+    ( 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_ )
 
     IMPLICIT NONE
@@ -701,8 +816,12 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: area_
       LOGICAL(KIND=C_BOOL) :: area__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_
-      LOGICAL(KIND=C_BOOL) :: bounds_lat__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_
-      LOGICAL(KIND=C_BOOL) :: bounds_lon__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_1d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lat_2d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lat_2d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_1d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: bounds_lon_2d_
+      LOGICAL(KIND=C_BOOL) :: bounds_lon_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: data_dim_
       LOGICAL(KIND=C_BOOL) :: data_dim__tmp
@@ -735,12 +854,18 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: jbegin_
       LOGICAL(KIND=C_BOOL) :: jbegin__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_
-      LOGICAL(KIND=C_BOOL) :: latvalue__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_1d_
+      LOGICAL(KIND=C_BOOL) :: latvalue_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: latvalue_2d_
+      LOGICAL(KIND=C_BOOL) :: latvalue_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: long_name_
       LOGICAL(KIND=C_BOOL) :: long_name__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_
-      LOGICAL(KIND=C_BOOL) :: lonvalue__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
-      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_1d_
+      LOGICAL(KIND=C_BOOL) :: lonvalue_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: lonvalue_2d_
+      LOGICAL(KIND=C_BOOL) :: lonvalue_2d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_1d_
+      LOGICAL(KIND=C_BOOL) :: mask_1d__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_2d_
+      LOGICAL(KIND=C_BOOL) :: mask_2d__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
@@ -765,12 +890,22 @@
       ENDIF
 
-      IF (PRESENT(bounds_lat_)) THEN
-        bounds_lat__tmp = cxios_is_defined_domaingroup_bounds_lat(domaingroup_hdl%daddr)
-        bounds_lat_ = bounds_lat__tmp
-      ENDIF
-
-      IF (PRESENT(bounds_lon_)) THEN
-        bounds_lon__tmp = cxios_is_defined_domaingroup_bounds_lon(domaingroup_hdl%daddr)
-        bounds_lon_ = bounds_lon__tmp
+      IF (PRESENT(bounds_lat_1d_)) THEN
+        bounds_lat_1d__tmp = cxios_is_defined_domaingroup_bounds_lat_1d(domaingroup_hdl%daddr)
+        bounds_lat_1d_ = bounds_lat_1d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lat_2d_)) THEN
+        bounds_lat_2d__tmp = cxios_is_defined_domaingroup_bounds_lat_2d(domaingroup_hdl%daddr)
+        bounds_lat_2d_ = bounds_lat_2d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lon_1d_)) THEN
+        bounds_lon_1d__tmp = cxios_is_defined_domaingroup_bounds_lon_1d(domaingroup_hdl%daddr)
+        bounds_lon_1d_ = bounds_lon_1d__tmp
+      ENDIF
+
+      IF (PRESENT(bounds_lon_2d_)) THEN
+        bounds_lon_2d__tmp = cxios_is_defined_domaingroup_bounds_lon_2d(domaingroup_hdl%daddr)
+        bounds_lon_2d_ = bounds_lon_2d__tmp
       ENDIF
 
@@ -850,7 +985,12 @@
       ENDIF
 
-      IF (PRESENT(latvalue_)) THEN
-        latvalue__tmp = cxios_is_defined_domaingroup_latvalue(domaingroup_hdl%daddr)
-        latvalue_ = latvalue__tmp
+      IF (PRESENT(latvalue_1d_)) THEN
+        latvalue_1d__tmp = cxios_is_defined_domaingroup_latvalue_1d(domaingroup_hdl%daddr)
+        latvalue_1d_ = latvalue_1d__tmp
+      ENDIF
+
+      IF (PRESENT(latvalue_2d_)) THEN
+        latvalue_2d__tmp = cxios_is_defined_domaingroup_latvalue_2d(domaingroup_hdl%daddr)
+        latvalue_2d_ = latvalue_2d__tmp
       ENDIF
 
@@ -860,12 +1000,22 @@
       ENDIF
 
-      IF (PRESENT(lonvalue_)) THEN
-        lonvalue__tmp = cxios_is_defined_domaingroup_lonvalue(domaingroup_hdl%daddr)
-        lonvalue_ = lonvalue__tmp
-      ENDIF
-
-      IF (PRESENT(mask_)) THEN
-        mask__tmp = cxios_is_defined_domaingroup_mask(domaingroup_hdl%daddr)
-        mask_ = mask__tmp
+      IF (PRESENT(lonvalue_1d_)) THEN
+        lonvalue_1d__tmp = cxios_is_defined_domaingroup_lonvalue_1d(domaingroup_hdl%daddr)
+        lonvalue_1d_ = lonvalue_1d__tmp
+      ENDIF
+
+      IF (PRESENT(lonvalue_2d_)) THEN
+        lonvalue_2d__tmp = cxios_is_defined_domaingroup_lonvalue_2d(domaingroup_hdl%daddr)
+        lonvalue_2d_ = lonvalue_2d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_1d_)) THEN
+        mask_1d__tmp = cxios_is_defined_domaingroup_mask_1d(domaingroup_hdl%daddr)
+        mask_1d_ = mask_1d__tmp
+      ENDIF
+
+      IF (PRESENT(mask_2d_)) THEN
+        mask_2d__tmp = cxios_is_defined_domaingroup_mask_2d(domaingroup_hdl%daddr)
+        mask_2d_ = mask_2d__tmp
       ENDIF
 
Index: XIOS/trunk/src/node/domain.cpp
===================================================================
--- XIOS/trunk/src/node/domain.cpp	(revision 663)
+++ XIOS/trunk/src/node/domain.cpp	(revision 664)
@@ -27,6 +27,7 @@
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
       , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
-      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0), maskInter_()
+      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
       , isClientAfterTransformationChecked(false)
+      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
    { /* Ne rien faire de plus */ }
 
@@ -35,6 +36,7 @@
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
       , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
-      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0), maskInter_()
+      , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
       , isClientAfterTransformationChecked(false)
+      , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
    { /* Ne rien faire de plus */ }
 
@@ -95,79 +97,66 @@
    void CDomain::checkDomain(void)
    {
-      if (!type.isEmpty() && type==type_attr::unstructured)
-      {
-         if (ni_glo.isEmpty() || ni_glo <= 0 )
-         {
-            ERROR("CDomain::checkAttributes(void)",
-               << "[ Id = " << this->getId() << " ] "
-               << "The global domain is badly defined,"
-               << " check the \'ni_glo\'  value !")
-         }
-         isUnstructed_ = true;
-         nj_glo = 1;
-         nj = 1;
-         jbegin = 0;
-         if (ni.isEmpty()) ni = i_index.numElements();
-         j_index.resize(ni);
-         for(int i=0;i<ni;++i) j_index(i)=0;
-
-//         nj_glo=ni_glo ;
-//         ni_glo=1 ;
-//         if (!ni.isEmpty()) nj=ni ;
-//         if (!ibegin.isEmpty()) jbegin=ibegin ;
-//         if (!iend.isEmpty()) jend=iend ;
-//         if (!i_index.isEmpty())
-//         {
-//          j_index.resize(1,nj) ;
-//          for(int i=0;i<ni;i++) j_index(0,i)=i_index(i,0) ;
-//          i_index.resize(1,nj) ;
-//          for(int j=0;j<nj;j++) i_index(0,j)=0 ;
-//         }
-//
-//         if (!mask.isEmpty())
-//         {
-//          CArray<int,2> mask_tmp(nj,1);
-//          mask_tmp = mask ;
-//          mask.resize(1,nj) ;
-//          for(int j=0;j<nj;j++) mask(0,j)=mask_tmp(j,0) ;
-//         }
-
-         if (!area.isEmpty())
-           area.transposeSelf(1, 0);
-      }
-      else if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) ||
-          (nj_glo.isEmpty() || nj_glo.getValue() <= 0 ))
-      {
-         ERROR("CDomain::checkAttributes(void)",
-               << "[ Id = " << this->getId() << " ] "
-               << "The global domain is badly defined,"
-               << " check the \'ni_glo\' et \'nj_glo\' values !")
-      }
-
-      isDistributed_ = !ibegin.isEmpty() || !ni.isEmpty() || !jbegin.isEmpty() || !nj.isEmpty();
-
-      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())
-      {
-        i_index.resize(ni*nj);
-        for (int j = 0; j < nj; ++j)
-          for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin;
-      }
-
-      if (j_index.isEmpty())
-      {
-        j_index.resize(ni*nj);
-        for (int j = 0; j < nj; ++j)
-          for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
-      }
-      computeNGlobDomain();
-
-      if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
-      if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
+     if (type.isEmpty())
+     {
+       ERROR("CDomain::checkDomain(void)",
+             << "[ Id = " << this->getId() << " ] "
+             << "The domain type is not defined,"
+             << " check the 'type'  value !")
+     }
+
+     if (type==type_attr::unstructured)
+     {
+        if (ni_glo.isEmpty() || ni_glo <= 0 )
+        {
+           ERROR("CDomain::checkAttributes(void)",
+              << "[ Id = " << this->getId() << " ] "
+              << "The global domain is badly defined,"
+              << " check the \'ni_glo\'  value !")
+        }
+        isUnstructed_ = true;
+        nj_glo = 1;
+        nj = 1;
+        jbegin = 0;
+        if (ni.isEmpty()) ni = i_index.numElements();
+        j_index.resize(ni);
+        for(int i=0;i<ni;++i) j_index(i)=0;
+
+        if (!area.isEmpty())
+          area.transposeSelf(1, 0);
+     }
+     else if ((ni_glo.isEmpty() || ni_glo.getValue() <= 0 ) ||
+         (nj_glo.isEmpty() || nj_glo.getValue() <= 0 ))
+     {
+        ERROR("CDomain::checkAttributes(void)",
+              << "[ Id = " << this->getId() << " ] "
+              << "The global domain is badly defined,"
+              << " check the \'ni_glo\' et \'nj_glo\' values !")
+     }
+
+     isDistributed_ = !ibegin.isEmpty() || !ni.isEmpty() || !jbegin.isEmpty() || !nj.isEmpty();
+
+     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())
+     {
+       i_index.resize(ni*nj);
+       for (int j = 0; j < nj; ++j)
+         for (int i = 0; i < ni; ++i) i_index(i+j*ni) = i+ibegin;
+     }
+
+     if (j_index.isEmpty())
+     {
+       j_index.resize(ni*nj);
+       for (int j = 0; j < nj; ++j)
+         for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
+     }
+     computeNGlobDomain();
+
+     if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
+     if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
    }
 
@@ -229,89 +218,38 @@
           jend_mask = jbegin.getValue() + nj.getValue() - 1;
 
-      if (!mask_1D.isEmpty() && !mask_2D.isEmpty())
+      if (!mask_1d.isEmpty() && !mask_2d.isEmpty())
         ERROR("CDomain::checkMask(void)",
-             <<"Only one mask is used but both mask_1D and mask_2D are defined! "<<endl
-             <<"Define only one mask: mask_1D or mask_2D ");
-
-      if (!mask_1D.isEmpty() && mask_2D.isEmpty())
-      {
-        if (mask_1D.numElements() != i_index.numElements())
+             <<"Only one mask is used but both mask_1d and mask_2d are defined! "<<endl
+             <<"Define only one mask: mask_1d or mask_2d ");
+
+      if (!mask_1d.isEmpty() && mask_2d.isEmpty())
+      {
+        if (mask_1d.numElements() != i_index.numElements())
           ERROR("CDomain::checkMask(void)",
-                <<"the mask_1D has not the same size than the local domain"<<endl
+                <<"the mask_1d has not the same size as the local domain"<<endl
                 <<"Local size is "<<i_index.numElements()<<endl
-                <<"Mask size is "<<mask_1D.numElements());
-      }
-
-      if (mask_1D.isEmpty() && !mask_2D.isEmpty())
-      {
-         if ((mask_2D.extent(0) != ni) ||
-             (mask_2D.extent(1) != nj))
+                <<"Mask size is "<<mask_1d.numElements());
+      }
+
+      if (mask_1d.isEmpty() && !mask_2d.isEmpty())
+      {
+         if ((mask_2d.extent(0) != ni) ||
+             (mask_2d.extent(1) != nj))
             ERROR("CDomain::checkMask(void)",
-                  <<"the mask has not the same size than the local domain"<<endl
+                  <<"the mask has not the same size as the local domain"<<endl
                   <<"Local size is "<<ni<<"x"<<nj<<endl
-                  <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1));
-      }
-
-      if (!mask_1D.isEmpty())
-      {
-        maskInter_.resize(mask_1D.numElements());
-        maskInter_ = mask_1D;
-      }
-      else if (!mask_2D.isEmpty())
-      {
-        maskInter_.resize(mask_2D.extent(0) * mask_2D.extent(0));
+                  <<"Mask size is "<<mask_2d.extent(0)<<"x"<<mask_2d.extent(1));
+      }
+
+      if (!mask_2d.isEmpty())
+      {
+        mask_1d.resize(mask_2d.extent(0) * mask_2d.extent(1));
         for (int j = 0; j < nj; ++j)
-          for (int i = 0; i < ni; ++i) maskInter_(i+j*ni) = mask_2D(i,j);
+          for (int i = 0; i < ni; ++i) mask_1d(i+j*ni) = mask_2d(i,j);
       }
       else
       {
-        maskInter_.resize(i_index.numElements());
-        for (int i = 0; i < i_index.numElements(); ++i) maskInter_(i) = true;
-      }
-
-      if (!mask.isEmpty())
-      {
-        maskInter_.resize(mask.extent(0) * mask.extent(1));
-        for (int j = 0; j < nj; ++j)
-          for (int i = 0; i < ni; ++i) maskInter_(i+j*ni) = mask(i,j);
-      }
-      else
-      {
-        maskInter_.resize(ni*nj);
-        for (int i = 0; i < maskInter_.numElements(); ++i) maskInter_(i) = true;
-      }
-
-      if (!mask.isEmpty())
-      {
-         if ((mask.extent(0) != ni) ||
-             (mask.extent(1) != nj))
-            ERROR("CDomain::checkAttributes(void)",
-                  <<"the mask has not the same size than the local domain"<<endl
-                   <<"Local size is "<<ni<<"x"<<nj<<endl
-                  <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1));
-//         for (int i = 0; i < ni; i++)
-//         {
-//            for (int j = 0; j < nj; j++)
-//            {
-//               if (i < ibegin_mask && i > iend_mask &&
-//                   j < jbegin_mask && j > jend_mask )
-//                     mask(i,j) = 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,nj) ;
-         for (int i = 0; i < ni.getValue(); i++)
-         {
-            for (int j = 0; j < nj.getValue(); j++)
-            {
-               if (i >= ibegin_mask && i <= iend_mask &&
-                   j >= jbegin_mask && j <= jend_mask )
-                     mask(i,j) = true;
-               else  mask(i,j) = false;
-            }
-         }
+        mask_1d.resize(i_index.numElements());
+        for (int i = 0; i < i_index.numElements(); ++i) mask_1d(i) = true;
       }
    }
@@ -319,5 +257,4 @@
 
    //----------------------------------------------------------------
-
    void CDomain::checkDomainData(void)
    {
@@ -331,6 +268,4 @@
       {
         data_dim.setValue(1);
-//         ERROR("CDomain::checkAttributes(void)",
-//               << "Data dimension undefined !") ;
       }
 
@@ -366,49 +301,35 @@
 
    //----------------------------------------------------------------
-
    void CDomain::checkCompression(void)
    {
       if (!data_i_index.isEmpty())
       {
-//         int ssize = data_i_index.numElements();
-//         if (!data_n_index.isEmpty() &&
-//            (data_n_index.getValue() != ssize))
-//         {
-//            ERROR("CDomain::checkAttributes(void)",
-//                  <<"Dimension data_i_index incompatible with data_n_index.") ;
-//         }
-//         else if (data_n_index.isEmpty())
-//            data_n_index.setValue(ssize) ;
-          if (!data_j_index.isEmpty() &&
-             (data_j_index.numElements() != data_i_index.numElements()))
+        if (!data_j_index.isEmpty() &&
+           (data_j_index.numElements() != data_i_index.numElements()))
+        {
+           ERROR("CDomain::checkAttributes(void)",
+                 <<"Dimension data_j_index incompatible with data_i_index.") ;
+        }
+
+       if (2 == data_dim.getValue())
+       {
+          if (data_j_index.isEmpty())
           {
              ERROR("CDomain::checkAttributes(void)",
-                   <<"Dimension data_j_index incompatible with data_i_index.") ;
+                   <<"data_j_index must be defined !") ;
           }
-
-         if (2 == data_dim.getValue())
-         {
-            if (data_j_index.isEmpty())
-            {
-               ERROR("CDomain::checkAttributes(void)",
-                     <<"data_j_index must be defined !") ;
-            }
-         }
-         else // (1 == data_dim.getValue())
-         {
-            if (data_j_index.isEmpty())
-            {
-              const int dni = data_ni.getValue();
-              data_j_index.resize(dni);
-              for (int j = 0; j < dni; ++j) data_j_index(j) = 0;
-            }
-
-         }
+       }
+       else // (1 == data_dim.getValue())
+       {
+          if (data_j_index.isEmpty())
+          {
+            const int dni = data_ni.getValue();
+            data_j_index.resize(dni);
+            for (int j = 0; j < dni; ++j) data_j_index(j) = 0;
+          }
+       }
       }
       else
       {
-//         if (!data_n_index.isEmpty() ||
-//            ((data_dim.getValue() == 2) && (!data_j_index.isEmpty())))
-//            ERROR("CDomain::checkAttributes(void)", << "data_i_index undefined") ;
          if ((data_dim.getValue() == 2) && (!data_j_index.isEmpty()))
             ERROR("CDomain::checkAttributes(void)", << "data_i_index undefined") ;
@@ -444,124 +365,299 @@
          }
       }
-
-//      if (data_n_index.isEmpty())
-//      { // -> bloc re-vÃ©rifiÃ© OK
-//         if (data_dim.getValue() == 1)
-//         {
-//            const int dni = data_ni.getValue();
-//            data_i_index.resize(dni) ;
-//            data_n_index.setValue(dni);
-//            for (int i = 0; i < dni; i++) data_i_index(i) = i+1 ;
-//         }
-//         else   // (data_dim == 2)
-//         {
-//            const int dni = data_ni.getValue() * data_nj.getValue();
-//            data_i_index.resize(dni) ;
-//            data_j_index.resize(dni) ;
-//
-//            data_n_index.setValue(dni);
-//
-//            for(int count = 0, j = 0; j  < data_nj.getValue(); j++)
-//            {
-//               for(int i = 0; i < data_ni.getValue(); i++, count++)
-//               {
-//                  data_i_index(count) = i+1 ;
-//                  data_j_index(count) = j+1 ;
-//               }
-//            }
-//         }
-//      }
-   }
-
-   //----------------------------------------------------------------
-
-   void CDomain::completeLonLatClient(void)
-   {
-      int i,j,k ;
-      CArray<double,1> lonvalue_temp(ni*nj) ;
-      CArray<double,1> latvalue_temp(ni*nj) ;
-      CArray<double,2> bounds_lon_temp(nvertex,ni*nj) ;
-      CArray<double,2> bounds_lat_temp(nvertex,ni*nj) ;
-
-      if (type.isEmpty())
-      {
-        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj )
-        {
-          type.setValue(type_attr::curvilinear) ;
-          isCurvilinear=true ;
-        }
-        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj )
-        {
-          type.setValue(type_attr::regular) ;
-          isCurvilinear=false ;
-        }
-        else ERROR("void CDomain::completeLonLatClient(void)",<<"the grid is nor curvilinear, nor cartesian, because the size of longitude and latitude array is not coherent with the domain size"<<endl
-                                                              <<"lonvalue size = " << lonvalue.numElements() << "different of ni or ni*nj"<<endl
-                                                              <<"latvalue size = " << latvalue.numElements() << "different of nj or ni*nj" ) ;
-      }
-      if (type==type_attr::curvilinear || type==type_attr::unstructured)
-      {
-        lonvalue_temp=lonvalue ;
-        latvalue_temp=latvalue ;
-        if (hasBounds) bounds_lon_temp=bounds_lon ;
-        if (hasBounds) bounds_lat_temp=bounds_lat ;
-      }
-      else
-      {
-        for(j=0;j<nj;j++)
-          for(i=0;i<ni;i++)
+   }
+
+   void CDomain::completeLonClient()
+   {
+     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));
+     }
+
+     if (!lonvalue_2d.isEmpty())
+     {
+        for (j = 0; j < nj; ++j)
+          for (i = 0; i < ni; ++i)
           {
-            k=j*ni+i ;
-            lonvalue_temp(k)=lonvalue(i) ;
-            latvalue_temp(k)=latvalue(j) ;
+            lonvalue_temp(i+j*ni) = lonvalue_2d(i,j);
             if (hasBounds)
             {
-              for(int n=0;n<nvertex;n++)
-              {
-                bounds_lon_temp(n,k)=bounds_lon(n,i) ;
-                bounds_lat_temp(n,k)=bounds_lat(n,j) ;
-              }
+              k=j*ni+i;
+              for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_2d(n,i,j);
             }
           }
-      }
-
-      StdSize dm = zoom_ni_client * zoom_nj_client;
+     }
+
+     if (!lonvalue_1d.isEmpty())
+     {
+       if (type_attr::rectilinear == type)
+       {
+         if (ni == lonvalue_1d.numElements())
+         {
+           for(j=0;j<nj;++j)
+             for(i=0;i<ni;++i)
+             {
+               k=j*ni+i;
+               lonvalue_temp(k) = lonvalue_1d(i);
+               if (hasBounds)
+               {
+                 for(int n=0;n<nvertex;++n) bounds_lon_temp(n,k) = bounds_lon_1d(n,i);
+               }
+             }
+          }
+          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());
+       }
+       else if (type==type_attr::curvilinear || type==type_attr::unstructured)
+       {
+         lonvalue_temp=lonvalue_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.resize(dm);
-        latvalue.resize(dm);
-      }
-
-
-      for (int i = 0; i < zoom_ni_client; i++)
-      {
-        for (int j = 0; j < zoom_nj_client; j++)
-        {
-          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
-          latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni );
-          if (hasBounds)
+     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)
           {
-            for(int n=0;n<nvertex;n++)
+            latvalue_temp(i+j*ni) = latvalue_2d(i,j);
+            if (hasBounds)
             {
-              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
-              bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni );
+              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;
+         }
+       }
+     }
+
+     StdSize dm = zoom_ni_client * zoom_nj_client;
+
+      // 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++)
+       {
+         latvalue_client(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
+         if (hasBounds)
+         {
+           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 );
+           }
+         }
+       }
+     }
+   }
 
    //----------------------------------------------------------------
 
+   void CDomain::completeLonLatClient(void)
+   {
+     completeLonClient();
+     completeLatClient();
+//      int i,j,k ;
+//      CArray<double,1> lonvalue_temp(ni*nj) ;
+//      CArray<double,1> latvalue_temp(ni*nj) ;
+//      CArray<double,2> bounds_lon_temp(nvertex,ni*nj);
+//      CArray<double,2> bounds_lat_temp(nvertex,ni*nj);
+//
+//      if (type.isEmpty())
+//      {
+//        if ( lonvalue.numElements() == ni*nj && latvalue.numElements() == ni*nj )
+//        {
+//          type.setValue(type_attr::curvilinear) ;
+//          isCurvilinear=true ;
+//        }
+//        else if ( lonvalue.numElements() == ni && latvalue.numElements() == nj )
+//        {
+//          type.setValue(type_attr::regular) ;
+//          isCurvilinear=false ;
+//        }
+//        else ERROR("void CDomain::completeLonLatClient(void)",<<"the grid is nor curvilinear, nor cartesian, because the size of longitude and latitude array is not coherent with the domain size"<<endl
+//                                                              <<"lonvalue size = " << lonvalue.numElements() << "different of ni or ni*nj"<<endl
+//                                                              <<"latvalue size = " << latvalue.numElements() << "different of nj or ni*nj" ) ;
+//      }
+//      if (type==type_attr::curvilinear || type==type_attr::unstructured)
+//      {
+//        lonvalue_temp=lonvalue ;
+//        latvalue_temp=latvalue ;
+//        if (hasBounds) bounds_lon_temp=bounds_lon ;
+//        if (hasBounds) bounds_lat_temp=bounds_lat ;
+//      }checkBounds
+//      else
+//      {
+//        for(j=0;j<nj;j++)
+//          for(i=0;i<ni;i++)
+//          {
+//            k=j*ni+i ;
+//            lonvalue_temp(k)=lonvalue(i) ;
+//            latvalue_temp(k)=latvalue(j) ;
+//            if (hasBounds)
+//            {
+//              for(int n=0;n<nvertex;n++)
+//              {
+//                bounds_lon_temp(n,k)=bounds_lon(n,i) ;
+//                bounds_lat_temp(n,k)=bounds_lat(n,j) ;
+//              }
+//            }
+//          }
+//      }
+//
+//      StdSize dm = zoom_ni_client * zoom_nj_client;
+//
+//      // Make sure that this attribute is non-empty for every client.
+//      if (0 != dm)
+//      {
+//        lonvalue.resize(dm);
+//        latvalue.resize(dm);
+//      }
+//
+//
+//      for (int i = 0; i < zoom_ni_client; i++)
+//      {
+//        for (int j = 0; j < zoom_nj_client; j++)
+//        {
+//          lonvalue(i + j * zoom_ni_client) = lonvalue_temp( (i + zoom_ibegin_client-ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
+//          latvalue(i + j * zoom_ni_client) = latvalue_temp( (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client - jbegin)*ni );
+//          if (hasBounds)
+//          {
+//            for(int n=0;n<nvertex;n++)
+//            {
+//              bounds_lon(n,i + j * zoom_ni_client) = bounds_lon_temp( n, (i + zoom_ibegin_client - ibegin) + (j + zoom_jbegin_client -jbegin)*ni );
+//              bounds_lat(n,i + j * zoom_ni_client) = bounds_lat_temp( n, (i + zoom_ibegin_client - ibegin)+(j + zoom_jbegin_client -jbegin)*ni );
+//            }
+//          }
+//        }
+//      }
+    }
+
+
+   //----------------------------------------------------------------
+
    void CDomain::checkZoom(void)
    {
-      // compute client zoom indices
-      // compute client zoom indices
-//      if (0 == global_zoom_ni) global_zoom_ni = ni_glo;
-//      if (0 == global_zoom_nj) global_zoom_nj = nj_glo;
-
       int global_zoom_iend=global_zoom_ibegin+global_zoom_ni-1 ;
       zoom_ibegin_client = ibegin_client > global_zoom_ibegin ? ibegin_client : global_zoom_ibegin ;
@@ -580,6 +676,69 @@
    void CDomain::checkBounds(void)
    {
-     if (!nvertex.isEmpty() && !bounds_lon.isEmpty() && !bounds_lat.isEmpty())
-     {
+     if (!nvertex.isEmpty() && (0 != nvertex.getValue()))
+     {
+       if (!bounds_lon_1d.isEmpty() && !bounds_lon_2d.isEmpty())
+         ERROR("CDomain::checkBounds(void)",
+              <<"Only one longitude boundary value can be used but both bounds_lon_1d and bounds_lon_2d are defined! "<<endl
+              <<"Define only one longitude boundary value: lonvalue_1d or bounds_lon_2d ");
+
+       if (!bounds_lat_1d.isEmpty() && !bounds_lat_2d.isEmpty())
+         ERROR("CDomain::checkBounds(void)",
+              <<"Only one latitude boundary value can be used but both bounds_lat_1d and bounds_lat_2d are defined! "<<endl
+              <<"Define only one latitude boundary value: bounds_lat_1d or bounds_lat_2d ");
+
+       if ((!bounds_lon_1d.isEmpty() && bounds_lat_1d.isEmpty()) || (bounds_lon_1d.isEmpty() && !bounds_lat_1d.isEmpty()))
+       {
+         ERROR("CDomain::checkBounds(void)",
+           <<"Only bounds_lon_1d or bounds_lat_1d is defined "<<endl
+           <<"Both must be defined ");
+       }
+
+       if ((!bounds_lon_2d.isEmpty() && bounds_lat_2d.isEmpty()) || (bounds_lon_2d.isEmpty() && !bounds_lat_2d.isEmpty()))
+       {
+         ERROR("CDomain::checkBounds(void)",
+           <<"Only bounds_lon_2d or bounds_lat_2d is defined "<<endl
+           <<"Both must be defined ");
+       }
+
+       if (!bounds_lon_1d.isEmpty() && (nvertex.getValue() != bounds_lon_1d.extent(0)))
+          ERROR("CDomain::checkBounds(void)",
+                <<"Only bounds_lon_1d and nvertex are not compatible"<<endl
+                <<"bounds_lon_1d dimension is " << bounds_lon_1d.extent(1)
+                <<"but nvertex is " << nvertex.getValue());
+
+       if (!bounds_lon_2d.isEmpty() && (nvertex.getValue() != bounds_lon_2d.extent(0)))
+          ERROR("CDomain::checkBounds(void)",
+                <<"Only bounds_lon_2d and nvertex are not compatible"<<endl
+                <<"bounds_lon_2d dimension is " << bounds_lon_1d.extent(2)
+                <<"but nvertex is " << nvertex.getValue());
+
+       if (!bounds_lon_1d.isEmpty() && lonvalue_1d.isEmpty())
+           ERROR("CDomain::checkBounds(void)",
+                <<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl);
+
+       if (!bounds_lon_2d.isEmpty() && lonvalue_2d.isEmpty())
+           ERROR("CDomain::checkBounds(void)",
+                <<"Both bounds_lon_1d and lonvalue_1d must be defined"<<endl);
+
+       if (!bounds_lat_1d.isEmpty() && (nvertex.getValue() != bounds_lat_1d.extent(0)))
+          ERROR("CDomain::checkBounds(void)",
+                <<"Only bounds_lat_1d and nvertex are not compatible"<<endl
+                <<"bounds_lat_1d dimension is " << bounds_lat_1d.extent(1)
+                <<"but nvertex is " << nvertex.getValue());
+
+       if (!bounds_lat_2d.isEmpty() && (nvertex.getValue() != bounds_lat_2d.extent(0)))
+          ERROR("CDomain::checkBounds(void)",
+                <<"Only bounds_lat_2d and nvertex are not compatible"<<endl
+                <<"bounds_lat_2d dimension is " << bounds_lat_1d.extent(2)
+                <<"but nvertex is " << nvertex.getValue());
+
+       if (!bounds_lat_1d.isEmpty() && latvalue_1d.isEmpty())
+           ERROR("CDomain::checkBounds(void)",
+                <<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl);
+
+       if (!bounds_lat_2d.isEmpty() && latvalue_2d.isEmpty())
+           ERROR("CDomain::checkBounds(void)",
+                <<"Both bounds_lat_1d and latvalue_1d must be defined"<<endl);
        hasBounds=true ;
      }
@@ -604,22 +763,4 @@
    }
 
-//   void CDomain::checkAttributesOnClientBeforeTransformation()
-//   {
-//      if (this->isClientBeforeTransformationChecked) return;
-//      CContext* context=CContext::getCurrent();
-//
-//      this->checkDomain();
-//      this->checkBounds();
-//      this->checkArea();
-//
-//      if (context->hasClient)
-//      {
-//        this->checkDomainData();
-//        this->checkCompression();
-//      }
-//
-//      this->isClientBeforeTransformationChecked = true;
-//   }
-
    void CDomain::checkAttributesOnClientAfterTransformation()
    {
@@ -639,5 +780,5 @@
 
    //----------------------------------------------------------------
-   // Divide function checkAttributes into 2 seperate ones
+   // Divide function checkAttributes into 2 seperate onescheckBounds
    // This function only checks all attributes of current domain
    void CDomain::checkAttributesOnClient()
@@ -658,6 +799,4 @@
       else
       { // CÃŽtÃ© serveur uniquement
-//         if (!this->isEmpty())
-// ne sert plus //   this->completeLonLatServer();
       }
 
@@ -676,7 +815,4 @@
      if (context->hasClient)
      {
-//       this->computeConnectedServer();
-//       this->completeLonLatClient();
-
        sendServerAttribut() ;
        sendLonLatArea() ;
@@ -705,6 +841,4 @@
       else
       { // CÃŽtÃ© serveur uniquement
-//         if (!this->isEmpty())
-// ne sert plus //   this->completeLonLatServer();
       }
 
@@ -932,9 +1066,8 @@
         i = i_index(idx);
         j = j_index(idx);
-        ind = n;
-//        ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client;
-
-        lon(n) = lonvalue(ind);
-        lat(n) = latvalue(ind);
+        ind = (i - zoom_ibegin_client) + (j - zoom_jbegin_client) * zoom_ni_client;
+
+        lon(n) = lonvalue_client(ind);
+        lat(n) = latvalue_client(ind);
 
         if (hasBounds)
@@ -945,6 +1078,6 @@
           for (nv = 0; nv < nvertex; nv++)
           {
-            boundslon(nv, n) = bounds_lon(nv, ind);
-            boundslat(nv, n) = bounds_lat(nv, ind);
+            boundslon(nv, n) = bounds_lon_client(nv, ind);
+            boundslat(nv, n) = bounds_lat_client(nv, ind);
           }
         }
Index: XIOS/trunk/src/node/domain.hpp
===================================================================
--- XIOS/trunk/src/node/domain.hpp	(revision 663)
+++ XIOS/trunk/src/node/domain.hpp	(revision 664)
@@ -120,4 +120,6 @@
          CArray<double, 1> lonvalue_srv, latvalue_srv ;
          CArray<double, 2> bounds_lon_srv, bounds_lat_srv ;
+         CArray<double, 1> lonvalue_client, latvalue_client;
+         CArray<double, 2> bounds_lon_client, bounds_lat_client;
          CArray<double, 1> area_srv;
 
@@ -134,6 +136,5 @@
         int global_zoom_ibegin, global_zoom_ni;
         int global_zoom_jbegin, global_zoom_nj;
-//        vector<int> ib_srv, ie_srv, in_srv ;
-//        vector<int> jb_srv, je_srv, jn_srv ;
+//        CArray<bool,1> maskInter;
 
       public :
@@ -175,4 +176,6 @@
          void setTransformations(const TransMapTypes&);
          void computeNGlobDomain();
+         void completeLonClient();
+         void completeLatClient();
 
        private :
@@ -189,5 +192,5 @@
          std::vector<int> nGlobDomain_;
          bool isUnstructed_;
-         CArray<bool,1> maskInter_;
+
 
 
Index: XIOS/trunk/src/node/grid.cpp
===================================================================
--- XIOS/trunk/src/node/grid.cpp	(revision 663)
+++ XIOS/trunk/src/node/grid.cpp	(revision 664)
@@ -200,6 +200,6 @@
       int dim = domainP.size() * 2 + axisP.size();
 
-      std::vector<CArray<bool,2>* > domainMasks(domainP.size());
-      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask);
+      std::vector<CArray<bool,1>* > domainMasks(domainP.size());
+      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask_1d);
       std::vector<CArray<bool,1>* > axisMasks(axisP.size());
       for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask);
Index: XIOS/trunk/src/node/grid.hpp
===================================================================
--- XIOS/trunk/src/node/grid.hpp	(revision 663)
+++ XIOS/trunk/src/node/grid.hpp	(revision 664)
@@ -191,5 +191,5 @@
        template<int N>
        void checkGridMask(CArray<bool,N>& gridMask,
-                          const std::vector<CArray<bool,2>* >& domainMasks,
+                          const std::vector<CArray<bool,1>* >& domainMasks,
                           const std::vector<CArray<bool,1>* >& axisMasks,
                           const CArray<bool,1>& axisDomainOrder);
@@ -267,5 +267,5 @@
    template<int N>
    void CGrid::checkGridMask(CArray<bool,N>& gridMask,
-                             const std::vector<CArray<bool,2>* >& domainMasks,
+                             const std::vector<CArray<bool,1>* >& domainMasks,
                              const std::vector<CArray<bool,1>* >& axisMasks,
                              const CArray<bool,1>& axisDomainOrder)
@@ -274,4 +274,5 @@
      int numElement = axisDomainOrder.numElements();
      int dim = domainMasks.size() * 2 + axisMasks.size();
+     std::vector<CDomain*> domainP = this->getDomains();
 
      std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
@@ -282,6 +283,6 @@
       indexMap[i] = idx;
       if (true == axisDomainOrder(i)) {
-          eachDimSize[indexMap[i]]   = domainMasks[idxDomain]->extent(0);
-          eachDimSize[indexMap[i]+1] = domainMasks[idxDomain]->extent(1);
+          eachDimSize[indexMap[i]]   = domainP[idxDomain]->ni;
+          eachDimSize[indexMap[i]+1] = domainP[idxDomain]->nj;
           idx += 2; ++idxDomain;
       }
@@ -328,6 +329,5 @@
         if (axisDomainOrder(i))
         {
-          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]],
-                                                          idxLoop[indexMap[i]+1]);
+          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]] + idxLoop[indexMap[i]+1] * eachDimSize[indexMap[i]]);
           ++idxDomain;
         }
Index: XIOS/trunk/src/output/nc4_data_output.cpp
===================================================================
--- XIOS/trunk/src/output/nc4_data_output.cpp	(revision 663)
+++ XIOS/trunk/src/output/nc4_data_output.cpp	(revision 664)
@@ -83,5 +83,5 @@
          StdString dimXid, dimYid ;
 
-         bool isRegularDomain = (domain->type == CDomain::type_attr::regular);
+         bool isRegularDomain = (domain->type == CDomain::type_attr::rectilinear);
          switch (domain->type)
          {
@@ -90,5 +90,5 @@
              dimYid     = StdString("y").append(appendDomid);
              break ;
-           case CDomain::type_attr::regular :
+           case CDomain::type_attr::rectilinear :
              dimXid     = StdString("lon").append(appendDomid);
              dimYid     = StdString("lat").append(appendDomid);
@@ -130,5 +130,5 @@
                      latid = StdString("nav_lat").append(appendDomid);
                      break ;
-                   case CDomain::type_attr::regular :
+                   case CDomain::type_attr::rectilinear :
                      lonid = StdString("lon").append(appendDomid);
                      latid = StdString("lat").append(appendDomid);
@@ -171,5 +171,5 @@
                      SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0);
                      break ;
-                    case CDomain::type_attr::regular :
+                    case CDomain::type_attr::rectilinear :
                       SuperClassWriter::addVariable(latid, NC_FLOAT, dim0);
                       SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1);
@@ -227,5 +227,5 @@
                      SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0);
                      break;
-                   case CDomain::type_attr::regular :
+                   case CDomain::type_attr::rectilinear :
                      CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ;
                      SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0);
@@ -266,5 +266,5 @@
                      break;
 
-                   case CDomain::type_attr::regular :
+                   case CDomain::type_attr::rectilinear :
                      dim0.push_back(dimYid);
                      dim1.push_back(dimXid);
@@ -331,5 +331,5 @@
                      break;
                    }
-                   case CDomain::type_attr::regular :
+                   case CDomain::type_attr::rectilinear :
                    {
                      std::vector<StdSize> start(1) ;
@@ -772,5 +772,5 @@
                  dimCoordList.push_back(StdString("nav_lat").append(appendDomid));
                  break ;
-               case CDomain::type_attr::regular :
+               case CDomain::type_attr::rectilinear :
                  dimXid     = StdString("lon").append(appendDomid);
                  dimIdList.push_back(dimXid);
Index: XIOS/trunk/src/test/test_client.f90
===================================================================
--- XIOS/trunk/src/test/test_client.f90	(revision 663)
+++ XIOS/trunk/src/test/test_client.f90	(revision 664)
@@ -77,7 +77,8 @@
 
   CALL xios_set_axis_attr("axis_A",size=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)
+  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)
-  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+!  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat)
   CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)
 
@@ -112,9 +113,9 @@
   PRINT *, "xios_date_convert_to_seconds(date - 2.5h) = ", xios_date_convert_to_seconds(date - 2.5 * xios_hour)
 
-  ni=0 ; lonvalue(:)=0
-  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue=lonvalue)
+  ni=0 ; lonvalue(:)=0; lon(:,:)=0
+  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_2D=lon)
 
   print *,"ni",ni
-  print *,"lonvalue",lonvalue ;
+  print *,"lonvalue",lon;
 
   CALL xios_is_defined_field_attr("field_A",enabled=ok)
Index: XIOS/trunk/src/test/test_complete.f90
===================================================================
--- XIOS/trunk/src/test/test_complete.f90	(revision 663)
+++ XIOS/trunk/src/test/test_complete.f90	(revision 664)
@@ -25,5 +25,5 @@
   DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
   DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm)
-  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A_atm(:,:,:), field_A_srf(:,:), lonvalue(:)
+  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A_atm(:,:,:), field_A_srf(:,:), lonvalue(:,:)
   INTEGER, ALLOCATABLE :: kindex(:)
   INTEGER :: ni,ibegin,iend,nj,jbegin,jend
@@ -71,5 +71,5 @@
   iend=ibegin+ni-1 ; jend=jbegin+nj-1
 
-  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A_atm(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj))
+  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A_atm(0:ni+1,-1:nj+2,llm),lonvalue(ni,nj))
   lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
@@ -89,11 +89,11 @@
   CALL xios_set_axis_attr("axis_atm",size=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)
+  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')
   CALL xios_set_domain_attr("domain_atm",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
-  CALL xios_set_domain_attr("domain_atm",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+  CALL xios_set_domain_attr("domain_atm",lonvalue_2D=lon,latvalue_2D=lat)
 
   CALL xios_set_domain_attr("domain_atm_zoom",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj)
   CALL xios_set_domain_attr("domain_atm_zoom",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
-  CALL xios_set_domain_attr("domain_atm_zoom",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+  CALL xios_set_domain_attr("domain_atm_zoom",lonvalue_2D=lon,latvalue_2D=lat)
 !  CALL xios_set_domain_attr("domain_atm_zoom",zoom_ibegin=39, zoom_ni=20, zoom_jbegin=39, zoom_nj=5)
 
@@ -124,9 +124,9 @@
 !!! Recupration des valeurs des longitudes et de taille des domaines locaux (pour test de fonctionnalitÃ©)
 
-  ni=0 ; lonvalue(:)=0
-  CALL xios_get_domain_attr("domain_atm",ni=ni,lonvalue=lonvalue)
+  ni=0 ; lonvalue(:,:)=0
+  CALL xios_get_domain_attr("domain_atm",ni=ni,lonvalue_2D=lonvalue)
 
   PRINT *,"ni",ni
-  PRINT *,"lonvalue",lonvalue ;
+  PRINT *,"lonvalue",lonvalue;
 
 !!! Fin de la definition du contexte
@@ -177,8 +177,8 @@
 
   CALL xios_set_axis_attr("axis_srf",size=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)
+  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",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+  CALL xios_set_domain_attr("domain_srf",lonvalue_2D=lon,latvalue_2D=lat)
 
 !!! CrÃ©ation d un nouveau champ
@@ -204,6 +204,6 @@
 !!! Recupration des valeurs des longitudes et de taille des domaines locaux (pour test de fonctionnalitÃ©)
 
-  ni=0 ; lonvalue(:)=0
-  CALL xios_get_domain_attr("domain_srf",ni=ni,lonvalue=lonvalue)
+  ni=0 ; lonvalue(:,:)=0
+  CALL xios_get_domain_attr("domain_srf",ni=ni,lonvalue_2D=lonvalue)
 
   PRINT *,"ni",ni
Index: XIOS/trunk/src/test/test_new_features.f90
===================================================================
--- XIOS/trunk/src/test/test_new_features.f90	(revision 663)
+++ XIOS/trunk/src/test/test_new_features.f90	(revision 664)
@@ -132,10 +132,10 @@
   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)
-  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/)))
+  CALL xios_set_domain_attr("domain_A",lonvalue_2D=lon,latvalue_2D=lat)
 
   CALL xios_set_domain_attr("domain_A_transformed", ni_glo=niDomGlo, nj_glo=njDomGlo, &
                                                     ibegin=ibeginDomInterp, ni=niDomInterp, jbegin=jbeginDomInterp, nj=njDomInterp)
-  CALL xios_set_domain_attr("domain_A_transformed", lonvalue=RESHAPE(lontransformed,(/niDomInterp*njDomInterp/)), &
-                                                    latvalue=RESHAPE(lattransformed,(/niDomInterp*njDomInterp/)))
+  CALL xios_set_domain_attr("domain_A_transformed", lonvalue_2D=lontransformed, &
+                                                    latvalue_2D=lattransformed)
 
   CALL xios_set_fieldgroup_attr("field_definition",enabled=.TRUE.)
@@ -172,5 +172,5 @@
 
   ni=0 ; lonvalue(:)=0
-  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue=lonvalue)
+  CALL xios_get_domain_attr("domain_A",ni=ni,lonvalue_1D=lonvalue)
 
 !  print *,"ni",ni
Index: XIOS/trunk/src/test/test_remap.f90
===================================================================
--- XIOS/trunk/src/test/test_remap.f90	(revision 663)
+++ XIOS/trunk/src/test/test_remap.f90	(revision 664)
@@ -113,9 +113,9 @@
 
   CALL xios_set_domain_attr("src_domain", ni_glo=src_ni_glo, ibegin=src_ibegin, ni=src_ni, type="unstructured")
-  CALL xios_set_domain_attr("src_domain", lonvalue=src_lon, latvalue=src_lat, &
-                            bounds_lon=src_boundslon, bounds_lat=src_boundslat, nvertex=src_nvertex)
+  CALL xios_set_domain_attr("src_domain",lonvalue_1D=src_lon,latvalue_1D=src_lat, bounds_lon_1D=src_boundslon, bounds_lat_1D=src_boundslat, nvertex=src_nvertex)
+                            
   CALL xios_set_domain_attr("dst_domain", ni_glo=dst_ni_glo, ibegin=dst_ibegin, ni=dst_ni, type="unstructured")
-  CALL xios_set_domain_attr("dst_domain", lonvalue=dst_lon, latvalue=dst_lat, &
-                            bounds_lon=dst_boundslon, bounds_lat=dst_boundslat, nvertex=dst_nvertex)
+  CALL xios_set_domain_attr("dst_domain",lonvalue_1D=dst_lon,latvalue_1D=dst_lat, bounds_lon_1D=dst_boundslon, bounds_lat_1D=dst_boundslat, nvertex=dst_nvertex)
+                            
  
   dtime%second = 3600
Index: XIOS/trunk/src/test/test_unstruct_complete.f90
===================================================================
--- XIOS/trunk/src/test/test_unstruct_complete.f90	(revision 663)
+++ XIOS/trunk/src/test/test_unstruct_complete.f90	(revision 664)
@@ -203,6 +203,6 @@
   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)
-  CALL xios_set_domain_attr("domain_srf", lonvalue=lon, latvalue=lat)
-  CALL xios_set_domain_attr("domain_srf", nvertex=4, bounds_lon=bounds_lon, bounds_lat=bounds_lat)
+  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/domain_algorithm_zoom.cpp
===================================================================
--- XIOS/trunk/src/transformation/domain_algorithm_zoom.cpp	(revision 663)
+++ XIOS/trunk/src/transformation/domain_algorithm_zoom.cpp	(revision 664)
@@ -118,5 +118,5 @@
       globalIndexMask = (j+jBeginMask) * niGlob + (i + iBeginMask);
       if (transMap.find(globalIndexMask) == ite)
-        (domainDest_->mask)(i,j) = false;
+        (domainDest_->mask_1d)(i+j*niMask) = false;
     }
   }
