Index: XIOS/trunk/inputs/test_tiled_domain/iodef.xml
===================================================================
--- XIOS/trunk/inputs/test_tiled_domain/iodef.xml	(revision 2131)
+++ XIOS/trunk/inputs/test_tiled_domain/iodef.xml	(revision 2131)
@@ -0,0 +1,58 @@
+<?xml version="1.0"?>
+<simulation>
+
+ <context id="test">
+   <calendar type="Gregorian" start_date="2012-03-01 15:00:00" time_origin="2012-02-28 15:00:00 + 1d" />
+
+
+   <field_definition level="1" enabled=".TRUE.">
+     <field id="field_3d"  operation="average" freq_op="3600s" grid_ref="grid"/>
+     <field id="field_2d"  operation="average" freq_op="3600s" domain_ref="domain"/>
+   </field_definition>
+
+
+   <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" enabled=".FALSE.">
+      <file id="output" name="output" enabled=".TRUE.">
+         <field field_ref="field_3d" name="field_3d" />
+     </file>
+   </file_definition>
+
+   <axis_definition>
+     <axis id="axis"/>
+   </axis_definition>
+
+   <domain_definition>
+     <domain id="domain" />
+
+   </domain_definition>
+
+   <grid_definition>
+     <grid id="grid">
+       <domain domain_ref="domain" />
+       <axis axis_ref="axis" />
+     </grid>
+   </grid_definition>
+  </context>
+
+  <context id="xios">
+      <variable_definition>
+         <variable_group id="server">
+            <variable id="using_server2" type="bool">false</variable>
+            <variable id="ratio_server2" type="int">50</variable>
+         </variable_group>
+
+        <variable_group id="buffer">
+            <variable id="optimal_buffer_size" type="string">performance</variable>
+            <variable id="buffer_size_factor" type="double">10.0</variable>
+         </variable_group>
+
+        <variable_group id="parameters" >
+          <variable id="using_server" type="bool">false</variable>
+          <variable id="info_level" type="int">50</variable>
+          <variable id="print_file" type="bool">true</variable>
+        </variable_group>
+      </variable_definition>
+  </context>
+
+</simulation>
+
Index: XIOS/trunk/inputs/test_tiled_domain/tile_data_def.nml
===================================================================
--- XIOS/trunk/inputs/test_tiled_domain/tile_data_def.nml	(revision 2131)
+++ XIOS/trunk/inputs/test_tiled_domain/tile_data_def.nml	(revision 2131)
@@ -0,0 +1,5 @@
+&TILE_DATA_DEF
+! both offsets should be of the same sign or equal to zero simulteneously
+ioffset=-2
+joffset=-2
+/
Index: XIOS/trunk/src/config/domain_attribute.conf
===================================================================
--- XIOS/trunk/src/config/domain_attribute.conf	(revision 2109)
+++ XIOS/trunk/src/config/domain_attribute.conf	(revision 2131)
@@ -63,2 +63,14 @@
 DECLARE_ATTRIBUTE(StdString, domain_ref)
 DECLARE_ATTRIBUTE(int,       prec)
+
+/* LOCAL */
+DECLARE_ATTRIBUTE(int, ntiles, false)
+DECLARE_ATTRIBUTE(bool, tile_only, false)
+DECLARE_ARRAY(int, 1, tile_ni, false)
+DECLARE_ARRAY(int, 1, tile_nj, false)
+DECLARE_ARRAY(int, 1, tile_ibegin, false)
+DECLARE_ARRAY(int, 1, tile_jbegin, false)
+DECLARE_ARRAY(int, 1, tile_data_ibegin, false)
+DECLARE_ARRAY(int, 1, tile_data_jbegin, false)
+DECLARE_ARRAY(int, 1, tile_data_ni, false)
+DECLARE_ARRAY(int, 1, tile_data_nj, false)
Index: XIOS/trunk/src/distribution_client.cpp
===================================================================
--- XIOS/trunk/src/distribution_client.cpp	(revision 2109)
+++ XIOS/trunk/src/distribution_client.cpp	(revision 2131)
@@ -11,5 +11,5 @@
 namespace xios {
 
-CDistributionClient::CDistributionClient(int rank, CGrid* grid)
+CDistributionClient::CDistributionClient(int rank, CGrid* grid, bool isTiled)
    : CDistribution(rank, 0)
    , axisDomainOrder_()
@@ -24,5 +24,5 @@
    , elementNLocal_(), elementNGlobal_()
 {
-  readDistributionInfo(grid);
+  readDistributionInfo(grid, isTiled);
   createGlobalIndex();
 }
@@ -50,5 +50,5 @@
   \param [in] grid Grid to read
 */
-void CDistributionClient::readDistributionInfo(CGrid* grid)
+void CDistributionClient::readDistributionInfo(CGrid* grid, bool isTiled)
 {
   std::vector<CDomain*> domList = grid->getDomains();
@@ -57,5 +57,5 @@
   CArray<int,1> axisDomainOrder = grid->axis_domain_order;
 
-  readDistributionInfo(domList, axisList, scalarList, axisDomainOrder);
+  readDistributionInfo(domList, axisList, scalarList, axisDomainOrder, isTiled);
 
   // Then check mask of grid
@@ -102,10 +102,11 @@
   \param [in] scalarList List of scalar of grid
   \param [in] axisDomainOrder order of axis and domain inside a grid. 2 if domain, 1 if axis and zero if scalar
-//  \param [in] gridMask Mask of grid, for now, keep it 3 dimension, but it needs changing
+  \param [in] isTiled If true, domain data attributes should be ignored
 */
 void CDistributionClient::readDistributionInfo(const std::vector<CDomain*>& domList,
                                                const std::vector<CAxis*>& axisList,
                                                const std::vector<CScalar*>& scalarList,
-                                               const CArray<int,1>& axisDomainOrder)
+                                               const CArray<int,1>& axisDomainOrder,
+                                               bool isTiled)
 {
   domainNum_ = domList.size();
@@ -177,8 +178,4 @@
       nBeginGlobal_.at(indexMap_[idx]+1) = domList[domIndex]->jbegin;
 
-      dataBegin_.at(indexMap_[idx]+1) = domList[domIndex]->data_jbegin.getValue();
-      dataIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->data_j_index);
-      infoIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->j_index);
-
       // On the i axis
       nLocal_.at(indexMap_[idx]) = domList[domIndex]->ni.getValue();
@@ -187,10 +184,34 @@
       nBeginGlobal_.at(indexMap_[idx]) = domList[domIndex]->ibegin;
 
-      dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue();
-      dataIndex_.at(indexMap_[idx]).reference(domList[domIndex]->data_i_index);
-      infoIndex_.at(indexMap_[idx]).reference(domList[domIndex]->i_index);
-
-      dataNIndex_.at(idx) = domList[domIndex]->data_i_index.numElements();
-      dataDims_.at(idx) = domList[domIndex]->data_dim.getValue();
+      if (isTiled)
+      // Ignore all data attributes, if defined, for tiled domains
+      {
+        dataBegin_.at(indexMap_[idx]+1) = 0;
+        dataBegin_.at(indexMap_[idx]) = 0;
+
+        // Fill dataIndex_ and infoIndex_
+        CArray<int,1>& infoIndexI = infoIndex_.at(indexMap_[idx]);
+        CArray<int,1>& infoIndexJ = infoIndex_.at(indexMap_[idx]+1);
+        CArray<int,1>& dataIndexI = dataIndex_.at(indexMap_[idx]);
+        CArray<int,1>& dataIndexJ = dataIndex_.at(indexMap_[idx]+1);
+        domList[domIndex]->computeCompressionTiled(dataIndexI, dataIndexJ, infoIndexI, infoIndexJ);
+
+      }
+      else
+      {
+        // On the j axis
+        dataBegin_.at(indexMap_[idx]+1) = domList[domIndex]->data_jbegin.getValue();
+        dataIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->data_j_index);
+        infoIndex_.at(indexMap_[idx]+1).reference(domList[domIndex]->j_index);
+
+        // On the i axis
+        dataBegin_.at(indexMap_[idx]) = domList[domIndex]->data_ibegin.getValue();
+        dataIndex_.at(indexMap_[idx]).reference(domList[domIndex]->data_i_index);
+        infoIndex_.at(indexMap_[idx]).reference(domList[domIndex]->i_index);
+
+      }
+
+      dataNIndex_.at(idx) = isTiled ? (domList[domIndex]->ni*domList[domIndex]->nj) : domList[domIndex]->data_i_index.numElements();
+      dataDims_.at(idx) = isTiled ? 1 : domList[domIndex]->data_dim.getValue();
 
       isDataDistributed_ |= domList[domIndex]->isDistributed();
Index: XIOS/trunk/src/distribution_client.hpp
===================================================================
--- XIOS/trunk/src/distribution_client.hpp	(revision 2109)
+++ XIOS/trunk/src/distribution_client.hpp	(revision 2131)
@@ -34,5 +34,5 @@
   public:
     /** Default constructor */
-    CDistributionClient(int rank, CGrid* grid);
+    CDistributionClient(int rank, CGrid* grid, bool isTiled = false);
 
     void createGlobalIndexSendToServer();
@@ -61,9 +61,10 @@
   protected:
     void createGlobalIndex();
-    void readDistributionInfo(CGrid* grid);
+    void readDistributionInfo(CGrid* grid, bool isTiled);
     void readDistributionInfo(const std::vector<CDomain*>& domList,
                               const std::vector<CAxis*>& axisList,
                               const std::vector<CScalar*>& scalarList,
-                              const CArray<int,1>& axisDomainOrder);
+                              const CArray<int,1>& axisDomainOrder,
+                              bool isTiled);
   private:
     //! Create local index of a domain
Index: XIOS/trunk/src/filter/source_filter.cpp
===================================================================
--- XIOS/trunk/src/filter/source_filter.cpp	(revision 2109)
+++ XIOS/trunk/src/filter/source_filter.cpp	(revision 2131)
@@ -19,4 +19,6 @@
     , offset(offset)
     , hasMissingValue(hasMissingValue), defaultValue(defaultValue)
+    , ntiles(0)
+    , storedTileData()
   {
     if (!grid)
@@ -53,7 +55,26 @@
   }
 
+  template <int N>
+  void CSourceFilter::streamTile(CDate date, const CArray<double, N>& tileData, int tileId)
+  {
+    if (ntiles==0)
+    {
+      const double nanValue = std::numeric_limits<double>::quiet_NaN();
+//      storedTileData.resize(grid->storeIndex_client.numElements());
+      storedTileData.resize(grid->getDataSize());
+      storedTileData = nanValue;
+    }
+    grid->copyTile(tileData, storedTileData, tileId);
+    ++ntiles;
+    if (ntiles==grid->getNTiles())
+    {
+      // Data entering workflow will be exactly of size ni*nj for a grid 2d or ni*nj*n for a grid 3d
+      streamData(date, storedTileData, true);
+      ntiles = 0;
+    }
+  }
 
   template <int N>
-  void CSourceFilter::streamData(CDate date, const CArray<double, N>& data)
+  void CSourceFilter::streamData(CDate date, const CArray<double, N>& data, bool isTiled)
   {
     date = date + offset; // this is a temporary solution, it should be part of a proper temporal filter
@@ -74,5 +95,8 @@
     {
       if (mask)
-        grid->maskField(data, packet->data);
+        if (isTiled)
+          grid->maskField(data, packet->data, isTiled);
+        else
+          grid->maskField(data, packet->data);
       else
         grid->inputField(data, packet->data);
@@ -97,11 +121,19 @@
   }
 
-  template void CSourceFilter::streamData<1>(CDate date, const CArray<double, 1>& data);
-  template void CSourceFilter::streamData<2>(CDate date, const CArray<double, 2>& data);
-  template void CSourceFilter::streamData<3>(CDate date, const CArray<double, 3>& data);
-  template void CSourceFilter::streamData<4>(CDate date, const CArray<double, 4>& data);
-  template void CSourceFilter::streamData<5>(CDate date, const CArray<double, 5>& data);
-  template void CSourceFilter::streamData<6>(CDate date, const CArray<double, 6>& data);
-  template void CSourceFilter::streamData<7>(CDate date, const CArray<double, 7>& data);
+  template void CSourceFilter::streamData<1>(CDate date, const CArray<double, 1>& data, bool isTiled);
+  template void CSourceFilter::streamData<2>(CDate date, const CArray<double, 2>& data, bool isTiled);
+  template void CSourceFilter::streamData<3>(CDate date, const CArray<double, 3>& data, bool isTiled);
+  template void CSourceFilter::streamData<4>(CDate date, const CArray<double, 4>& data, bool isTiled);
+  template void CSourceFilter::streamData<5>(CDate date, const CArray<double, 5>& data, bool isTiled);
+  template void CSourceFilter::streamData<6>(CDate date, const CArray<double, 6>& data, bool isTiled);
+  template void CSourceFilter::streamData<7>(CDate date, const CArray<double, 7>& data, bool isTiled);
+
+  template void CSourceFilter::streamTile<1>(CDate date, const CArray<double, 1>& data, int ntile);
+  template void CSourceFilter::streamTile<2>(CDate date, const CArray<double, 2>& data, int ntile);
+  template void CSourceFilter::streamTile<3>(CDate date, const CArray<double, 3>& data, int ntile);
+  template void CSourceFilter::streamTile<4>(CDate date, const CArray<double, 4>& data, int ntile);
+  template void CSourceFilter::streamTile<5>(CDate date, const CArray<double, 5>& data, int ntile);
+  template void CSourceFilter::streamTile<6>(CDate date, const CArray<double, 6>& data, int ntile);
+  template void CSourceFilter::streamTile<7>(CDate date, const CArray<double, 7>& data, int ntile);
 
   void CSourceFilter::streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data)
Index: XIOS/trunk/src/filter/source_filter.hpp
===================================================================
--- XIOS/trunk/src/filter/source_filter.hpp	(revision 2109)
+++ XIOS/trunk/src/filter/source_filter.hpp	(revision 2131)
@@ -46,5 +46,8 @@
        */
       template <int N>
-      void streamData(CDate date, const CArray<double, N>& data);
+      void streamData(CDate date, const CArray<double, N>& data, bool isTiled = false);
+
+      template <int N>
+      void streamTile(CDate date, const CArray<double, N>& data, int ntile);
 
       void virtual buildGraph(CDataPacketPtr packet);
@@ -75,4 +78,6 @@
       const bool compression ; //!< indicates if data need to be compressed : on client side : true, on server side : false
       const bool mask ;        //!< indicates whether grid mask should be applied (true for clients, false for servers)
+      int ntiles ;
+      CArray<double, 1> storedTileData;
   }; // class CSourceFilter
 } // namespace xios
Index: XIOS/trunk/src/interface/c/icdata.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icdata.cpp	(revision 2109)
+++ XIOS/trunk/src/interface/c/icdata.cpp	(revision 2131)
@@ -438,5 +438,5 @@
 
   
-   void cxios_write_data_k81_hdl(CField* field, double* data_k8, int data_Xsize)
+   void cxios_write_data_k81_hdl(CField* field, double* data_k8, int data_Xsize, int tileid)
    TRY
    {
@@ -449,5 +449,5 @@
 
       CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData);
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -456,10 +456,10 @@
    CATCH_DUMP_STACK
    
-   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ;
+   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize, tileid) ;
     
    }
@@ -468,5 +468,5 @@
 
 
-   void cxios_write_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize)
+   void cxios_write_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int tileid)
    TRY
    {
@@ -479,26 +479,26 @@
 
       CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData);
-      field->setData(data);
-
-      CTimer::get("XIOS send field").suspend();
-      CTimer::get("XIOS").suspend();
-   }
-   CATCH_DUMP_STACK
-
-   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ;
-   }
-   CATCH_DUMP_STACK
-
-
-
-
-
-
-   void cxios_write_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
+      field->setData(data, tileid);
+
+      CTimer::get("XIOS send field").suspend();
+      CTimer::get("XIOS").suspend();
+   }
+   CATCH_DUMP_STACK
+
+   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, tileid) ;
+   }
+   CATCH_DUMP_STACK
+
+
+
+
+
+
+   void cxios_write_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize, int tileid)
    TRY
    {
@@ -511,5 +511,5 @@
 
       CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData);
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -518,21 +518,21 @@
    CATCH_DUMP_STACK
    
-   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ;
-
-
-   }
-   CATCH_DUMP_STACK
-
-
-
-
-
-
-   void cxios_write_data_k84_hdl(CField* field, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size)
+   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize, tileid) ;
+
+
+   }
+   CATCH_DUMP_STACK
+
+
+
+
+
+
+   void cxios_write_data_k84_hdl(CField* field, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size, int tileid)
    TRY
    {
@@ -545,20 +545,22 @@
 
       CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData);
-      field->setData(data);
-
-      CTimer::get("XIOS send field").suspend();
-      CTimer::get("XIOS").suspend();
-   }
-   CATCH_DUMP_STACK
-
-   void cxios_write_data_k84(const char* fieldid, int fieldid_size, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-
-      CTimer::get("XIOS").resume();
-      CTimer::get("XIOS send field").resume();
-      cxios_write_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ;
+      field->setData(data, tileid);
+
+      CTimer::get("XIOS send field").suspend();
+      CTimer::get("XIOS").suspend();
+   }
+   CATCH_DUMP_STACK
+
+   void cxios_write_data_k84(const char* fieldid, int fieldid_size, double* data_k8,
+                             int data_0size, int data_1size, int data_2size,
+                             int data_3size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+
+      CTimer::get("XIOS").resume();
+      CTimer::get("XIOS send field").resume();
+      cxios_write_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, tileid) ;
    }
    CATCH_DUMP_STACK
@@ -570,5 +572,5 @@
    void cxios_write_data_k85_hdl(CField* field, double* data_k8,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size)
+                             int data_3size, int data_4size, int tileid)
    TRY
    {
@@ -581,5 +583,5 @@
 
       CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData);
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -590,10 +592,10 @@
    void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ;
+                             int data_3size, int data_4size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, tileid) ;
 
    }
@@ -604,5 +606,5 @@
    void cxios_write_data_k86_hdl(CField* field, double* data_k8,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size, int data_5size)
+                             int data_3size, int data_4size, int data_5size, int tileid)
    TRY
    {
@@ -616,5 +618,5 @@
 
       CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData);
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -625,10 +627,10 @@
    void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size, int data_5size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
+                             int data_3size, int data_4size, int data_5size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, tileid) ;
 
   }
@@ -641,5 +643,5 @@
                              int data_0size, int data_1size, int data_2size,
                              int data_3size, int data_4size, int data_5size,
-                             int data_6size)
+                             int data_6size, int tileid)
    TRY
    {
@@ -652,5 +654,5 @@
 
       CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData);
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -662,10 +664,11 @@
                              int data_0size, int data_1size, int data_2size,
                              int data_3size, int data_4size, int data_5size,
-                             int data_6size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
+                             int data_6size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size,
+                               data_5size, data_6size, tileid) ;
    }
    CATCH_DUMP_STACK
@@ -704,5 +707,5 @@
    
    
-   void cxios_write_data_k41_hdl(CField* field, float* data_k4, int data_Xsize)
+   void cxios_write_data_k41_hdl(CField* field, float* data_k4, int data_Xsize, int tileid)
    TRY
    {
@@ -717,22 +720,22 @@
       CArray<double, 1> data(data_Xsize);
       data = data_tmp;
-      field->setData(data);
-
-      CTimer::get("XIOS send field").suspend();
-      CTimer::get("XIOS").suspend();
-   }
-   CATCH_DUMP_STACK
-
-   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize);
-   }
-   CATCH_DUMP_STACK
-
-
-   void cxios_write_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize)
+      field->setData(data, tileid);
+
+      CTimer::get("XIOS send field").suspend();
+      CTimer::get("XIOS").suspend();
+   }
+   CATCH_DUMP_STACK
+
+   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize, tileid);
+   }
+   CATCH_DUMP_STACK
+
+
+   void cxios_write_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int tileid)
    TRY
    {
@@ -747,24 +750,24 @@
       CArray<double, 2> data(data_Xsize, data_Ysize);
       data = data_tmp;
-      field->setData(data);
-
-      CTimer::get("XIOS send field").suspend();
-      CTimer::get("XIOS").suspend();
-   }
-   CATCH_DUMP_STACK
-
-   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize);
-   }
-   CATCH_DUMP_STACK
-
-
-
-
-   void cxios_write_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
+      field->setData(data, tileid);
+
+      CTimer::get("XIOS send field").suspend();
+      CTimer::get("XIOS").suspend();
+   }
+   CATCH_DUMP_STACK
+
+   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, tileid);
+   }
+   CATCH_DUMP_STACK
+
+
+
+
+   void cxios_write_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize, int tileid)
    TRY
    {
@@ -779,5 +782,5 @@
       CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize);
       data = data_tmp;
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -786,10 +789,10 @@
    CATCH_DUMP_STACK
    
-   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k43_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, data_Zsize);
+   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k43_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, data_Zsize, tileid);
     }
    CATCH_DUMP_STACK
@@ -799,5 +802,5 @@
    void cxios_write_data_k44_hdl(CField* field, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size)
+                             int data_3size, int tileid)
    TRY
    {
@@ -812,5 +815,5 @@
       CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size);
       data = data_tmp;
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -821,10 +824,10 @@
    void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ;
+                             int data_3size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, tileid) ;
     }
    CATCH_DUMP_STACK
@@ -835,5 +838,5 @@
    void cxios_write_data_k45_hdl(CField* field, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size)
+                             int data_3size, int data_4size, int tileid)
    TRY
    {
@@ -848,5 +851,5 @@
       CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size);
       data = data_tmp;
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -857,10 +860,10 @@
    void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ;
+                             int data_3size, int data_4size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, tileid) ;
     }
    CATCH_DUMP_STACK
@@ -870,5 +873,5 @@
    void cxios_write_data_k46_hdl(CField* field, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size, int data_5size)
+                             int data_3size, int data_4size, int data_5size, int tileid)
    TRY
    {
@@ -883,5 +886,5 @@
       CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size);
       data = data_tmp;
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -892,10 +895,10 @@
    void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4,
                              int data_0size, int data_1size, int data_2size,
-                             int data_3size, int data_4size, int data_5size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ;
+                             int data_3size, int data_4size, int data_5size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, tileid) ;
     }
    CATCH_DUMP_STACK
@@ -905,5 +908,5 @@
                              int data_0size, int data_1size, int data_2size,
                              int data_3size, int data_4size, int data_5size,
-                             int data_6size)
+                             int data_6size, int tileid)
    TRY
    {
@@ -918,5 +921,5 @@
       CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size);
       data = data_tmp;
-      field->setData(data);
+      field->setData(data, tileid);
 
       CTimer::get("XIOS send field").suspend();
@@ -928,10 +931,11 @@
                              int data_0size, int data_1size, int data_2size,
                              int data_3size, int data_4size, int data_5size,
-                             int data_6size)
-   TRY
-   {
-      std::string fieldid_str;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
-      cxios_write_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ;
+                             int data_6size, int tileid)
+   TRY
+   {
+      std::string fieldid_str;
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      cxios_write_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size,
+                                data_5size, data_6size, tileid) ;
     }
    CATCH_DUMP_STACK
Index: XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 2109)
+++ XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 2131)
@@ -905,4 +905,27 @@
 
 
+  void cxios_set_domain_ntiles(domain_Ptr domain_hdl, int ntiles)
+  {
+    CTimer::get("XIOS").resume();
+    domain_hdl->ntiles.setValue(ntiles);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_ntiles(domain_Ptr domain_hdl, int* ntiles)
+  {
+    CTimer::get("XIOS").resume();
+    *ntiles = domain_hdl->ntiles.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_ntiles(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->ntiles.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_nvertex(domain_Ptr domain_hdl, int nvertex)
   {
@@ -1000,4 +1023,204 @@
 
 
+  void cxios_set_domain_tile_data_ibegin(domain_Ptr domain_hdl, int* tile_data_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_data_ibegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_data_ibegin(domain_Ptr domain_hdl, int* tile_data_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_data_ibegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_data_ibegin(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_data_ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_data_jbegin(domain_Ptr domain_hdl, int* tile_data_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_data_jbegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_data_jbegin(domain_Ptr domain_hdl, int* tile_data_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_data_jbegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_data_jbegin(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_data_jbegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_data_ni(domain_Ptr domain_hdl, int* tile_data_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_data_ni.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_data_ni(domain_Ptr domain_hdl, int* tile_data_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_data_ni.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_data_ni(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_data_ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_data_nj(domain_Ptr domain_hdl, int* tile_data_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_data_nj.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_data_nj(domain_Ptr domain_hdl, int* tile_data_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_data_nj.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_data_nj(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_data_nj.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_ibegin(domain_Ptr domain_hdl, int* tile_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_ibegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_ibegin(domain_Ptr domain_hdl, int* tile_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_ibegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_ibegin(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_jbegin(domain_Ptr domain_hdl, int* tile_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_jbegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_jbegin(domain_Ptr domain_hdl, int* tile_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_jbegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_jbegin(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_jbegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_ni(domain_Ptr domain_hdl, int* tile_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_ni.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_ni(domain_Ptr domain_hdl, int* tile_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_ni.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_ni(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domain_tile_nj(domain_Ptr domain_hdl, int* tile_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
+    domain_hdl->tile_nj.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domain_tile_nj(domain_Ptr domain_hdl, int* tile_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
+    tmp=domain_hdl->tile_nj.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domain_tile_nj(domain_Ptr domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domain_hdl->tile_nj.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domain_type(domain_Ptr domain_hdl, const char * type, int type_size)
   {
Index: XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 2109)
+++ XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 2131)
@@ -931,4 +931,27 @@
 
 
+  void cxios_set_domaingroup_ntiles(domaingroup_Ptr domaingroup_hdl, int ntiles)
+  {
+    CTimer::get("XIOS").resume();
+    domaingroup_hdl->ntiles.setValue(ntiles);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_ntiles(domaingroup_Ptr domaingroup_hdl, int* ntiles)
+  {
+    CTimer::get("XIOS").resume();
+    *ntiles = domaingroup_hdl->ntiles.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_ntiles(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->ntiles.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_nvertex(domaingroup_Ptr domaingroup_hdl, int nvertex)
   {
@@ -1026,4 +1049,204 @@
 
 
+  void cxios_set_domaingroup_tile_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* tile_data_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_data_ibegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_data_ibegin(domaingroup_Ptr domaingroup_hdl, int* tile_data_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ibegin, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_data_ibegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_data_ibegin(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_data_ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* tile_data_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_data_jbegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_data_jbegin(domaingroup_Ptr domaingroup_hdl, int* tile_data_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_jbegin, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_data_jbegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_data_jbegin(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_data_jbegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_data_ni(domaingroup_Ptr domaingroup_hdl, int* tile_data_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_data_ni.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_data_ni(domaingroup_Ptr domaingroup_hdl, int* tile_data_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_ni, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_data_ni.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_data_ni(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_data_ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_data_nj(domaingroup_Ptr domaingroup_hdl, int* tile_data_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_data_nj.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_data_nj(domaingroup_Ptr domaingroup_hdl, int* tile_data_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_data_nj, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_data_nj.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_data_nj(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_data_nj.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_ibegin(domaingroup_Ptr domaingroup_hdl, int* tile_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_ibegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_ibegin(domaingroup_Ptr domaingroup_hdl, int* tile_ibegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ibegin, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_ibegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_ibegin(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_ibegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_jbegin(domaingroup_Ptr domaingroup_hdl, int* tile_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_jbegin.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_jbegin(domaingroup_Ptr domaingroup_hdl, int* tile_jbegin, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_jbegin, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_jbegin.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_jbegin(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_jbegin.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_ni(domaingroup_Ptr domaingroup_hdl, int* tile_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_ni.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_ni(domaingroup_Ptr domaingroup_hdl, int* tile_ni, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_ni, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_ni.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_ni(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_ni.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_domaingroup_tile_nj(domaingroup_Ptr domaingroup_hdl, int* tile_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
+    domaingroup_hdl->tile_nj.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_domaingroup_tile_nj(domaingroup_Ptr domaingroup_hdl, int* tile_nj, int* extent)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<int,1> tmp(tile_nj, shape(extent[0]), neverDeleteData);
+    tmp=domaingroup_hdl->tile_nj.getInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_domaingroup_tile_nj(domaingroup_Ptr domaingroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = domaingroup_hdl->tile_nj.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_domaingroup_type(domaingroup_Ptr domaingroup_hdl, const char * type, int type_size)
   {
Index: XIOS/trunk/src/interface/fortran/idata.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/idata.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran/idata.F90	(revision 2131)
@@ -68,12 +68,13 @@
       END SUBROUTINE cxios_write_data_k80
 
-      SUBROUTINE cxios_write_data_k81_hdl(field_hdl, data_k8, data_Xsize) BIND(C)
+      SUBROUTINE cxios_write_data_k81_hdl(field_hdl, data_k8, data_Xsize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k81_hdl
 
-      SUBROUTINE cxios_write_data_k81(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C)
+      SUBROUTINE cxios_write_data_k81(fieldid, fieldid_size, data_k8, data_Xsize, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -81,14 +82,16 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k81
 
-      SUBROUTINE cxios_write_data_k82_hdl(field_hdl, data_k8, data_Xsize, data_Ysize) BIND(C)
+      SUBROUTINE cxios_write_data_k82_hdl(field_hdl, data_k8, data_Xsize, data_Ysize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k82_hdl
 
-      SUBROUTINE cxios_write_data_k82(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize) BIND(C)
+      SUBROUTINE cxios_write_data_k82(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -96,14 +99,17 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k82
 
-      SUBROUTINE cxios_write_data_k83_hdl(field_hdl, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C)
+      SUBROUTINE cxios_write_data_k83_hdl(field_hdl, data_k8, data_Xsize, data_Ysize, data_Zsize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k83_hdl
 
-      SUBROUTINE cxios_write_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C)
+      SUBROUTINE cxios_write_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize, &
+                                      tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -111,9 +117,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k83
 
       SUBROUTINE cxios_write_data_k84_hdl(field_hdl, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size) BIND(C)
+                                      data_3size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -121,9 +128,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k84_hdl
 
       SUBROUTINE cxios_write_data_k84(fieldid, fieldid_size, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size) BIND(C)
+                                      data_3size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -132,9 +140,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k84
 
       SUBROUTINE cxios_write_data_k85_hdl(field_hdl, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size) BIND(C)
+                                      data_3size, data_4size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -142,9 +151,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k85_hdl
 
       SUBROUTINE cxios_write_data_k85(fieldid, fieldid_size, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size) BIND(C)
+                                      data_3size, data_4size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -153,9 +163,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k85
 
       SUBROUTINE cxios_write_data_k86_hdl(field_hdl, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size, data_5size) BIND(C)
+                                      data_3size, data_4size, data_5size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -163,9 +174,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k86_hdl
 
       SUBROUTINE cxios_write_data_k86(fieldid, fieldid_size, data_k8, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size, data_5size) BIND(C)
+                                      data_3size, data_4size, data_5size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -174,4 +186,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k86
 
@@ -179,5 +192,5 @@
                                       data_0size, data_1size, data_2size, &
                                       data_3size, data_4size, data_5size, &
-                                      data_6size) BIND(C)
+                                      data_6size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -186,4 +199,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
          INTEGER  (kind = C_INT)   , VALUE        :: data_6size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k87_hdl
 
@@ -191,5 +205,5 @@
                                       data_0size, data_1size, data_2size, &
                                       data_3size, data_4size, data_5size, &
-                                      data_6size) BIND(C)
+                                      data_6size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -199,4 +213,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
          INTEGER  (kind = C_INT)   , VALUE        :: data_6size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k87
 
@@ -216,12 +231,13 @@
       END SUBROUTINE cxios_write_data_k40
 
-      SUBROUTINE cxios_write_data_k41_hdl(field_hdl, data_k4, data_Xsize) BIND(C)
+      SUBROUTINE cxios_write_data_k41_hdl(field_hdl, data_k4, data_Xsize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k41_hdl
 
-      SUBROUTINE cxios_write_data_k41(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C)
+      SUBROUTINE cxios_write_data_k41(fieldid, fieldid_size, data_k4, data_Xsize, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -229,14 +245,16 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k41
 
-      SUBROUTINE cxios_write_data_k42_hdl(field_hdl, data_k4, data_Xsize, data_Ysize) BIND(C)
+      SUBROUTINE cxios_write_data_k42_hdl(field_hdl, data_k4, data_Xsize, data_Ysize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k42_hdl
  
-      SUBROUTINE cxios_write_data_k42(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize) BIND(C)
+      SUBROUTINE cxios_write_data_k42(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -244,14 +262,16 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k42
 
-      SUBROUTINE cxios_write_data_k43_hdl(field_hdl, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C)
+      SUBROUTINE cxios_write_data_k43_hdl(field_hdl, data_k4, data_Xsize, data_Ysize, data_Zsize, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
          REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k43_hdl
 
-      SUBROUTINE cxios_write_data_k43(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C)
+      SUBROUTINE cxios_write_data_k43(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, data_Zsize, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -259,9 +279,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: fieldid_size
          INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k43
 
       SUBROUTINE cxios_write_data_k44_hdl(field_hdl, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size) BIND(C)
+                                      data_3size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -269,9 +290,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k44_hdl
 
       SUBROUTINE cxios_write_data_k44(fieldid, fieldid_size, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size) BIND(C)
+                                      data_3size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -280,9 +302,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k44
 
       SUBROUTINE cxios_write_data_k45_hdl(field_hdl, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size) BIND(C)
+                                      data_3size, data_4size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -290,9 +313,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k45_hdl
 
       SUBROUTINE cxios_write_data_k45(fieldid, fieldid_size, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size) BIND(C)
+                                      data_3size, data_4size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -301,9 +325,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k45
 
       SUBROUTINE cxios_write_data_k46_hdl(field_hdl, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size, data_5size) BIND(C)
+                                      data_3size, data_4size, data_5size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -311,9 +336,10 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k46_hdl
  
       SUBROUTINE cxios_write_data_k46(fieldid, fieldid_size, data_k4, &
                                       data_0size, data_1size, data_2size, &
-                                      data_3size, data_4size, data_5size) BIND(C)
+                                      data_3size, data_4size, data_5size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -322,4 +348,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k46
 
@@ -327,5 +354,5 @@
                                       data_0size, data_1size, data_2size, &
                                       data_3size, data_4size, data_5size, &
-                                      data_6size) BIND(C)
+                                      data_6size, tileid) BIND(C)
          USE ISO_C_BINDING
          INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl
@@ -334,4 +361,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
          INTEGER  (kind = C_INT)   , VALUE        :: data_6size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k47_hdl
 
@@ -339,5 +367,5 @@
                                       data_0size, data_1size, data_2size, &
                                       data_3size, data_4size, data_5size, &
-                                      data_6size) BIND(C)
+                                      data_6size, tileid) BIND(C)
          USE ISO_C_BINDING
          CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid
@@ -347,4 +375,5 @@
          INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size
          INTEGER  (kind = C_INT)   , VALUE        :: data_6size
+         INTEGER  (kind = C_INT)   , VALUE        :: tileid
       END SUBROUTINE cxios_write_data_k47
 
@@ -834,5 +863,6 @@
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data1d_k8(:)
-      CALL cxios_write_data_k81_hdl(field_hdl%daddr, data1d_k8, size(data1d_k8, 1))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k81_hdl(field_hdl%daddr, data1d_k8, size(data1d_k8, 1), tileid)
    END SUBROUTINE xios(send_field_r8_1d_hdl)
 
@@ -841,12 +871,22 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data1d_k8(:)
-      CALL cxios_write_data_k81(fieldid, len(fieldid), data1d_k8, size(data1d_k8, 1))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k81(fieldid, len(fieldid), data1d_k8, size(data1d_k8, 1), tileid)
    END SUBROUTINE xios(send_field_r8_1d)
 
+   SUBROUTINE xios(send_field_tiled_r8_1d)(fieldid, data1d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data1d_k8(:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k81(fieldid, len(fieldid), data1d_k8, size(data1d_k8, 1), tileid)
+   END SUBROUTINE xios(send_field_tiled_r8_1d)
+
    SUBROUTINE  xios(send_field_r8_2d_hdl)(field_hdl, data2d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data2d_k8(:,:)
-      CALL cxios_write_data_k82_hdl(field_hdl%daddr, data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k82_hdl(field_hdl%daddr, data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2), tileid)
    END SUBROUTINE  xios(send_field_r8_2d_hdl)
 
@@ -855,12 +895,25 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data2d_k8(:,:)
-      CALL cxios_write_data_k82(fieldid, len(fieldid), data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k82(fieldid, len(fieldid), data2d_k8, size(data2d_k8, 1), &
+                                size(data2d_k8, 2), tileid)
    END SUBROUTINE  xios(send_field_r8_2d)
 
+   SUBROUTINE  xios(send_field_tiled_r8_2d)(fieldid, data2d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data2d_k8(:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k82(fieldid, len(fieldid), data2d_k8, size(data2d_k8, 1), &
+                                size(data2d_k8, 2), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_2d)
+
    SUBROUTINE  xios(send_field_r8_3d_hdl)(field_hdl, data3d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data3d_k8(:,:,:)
-      CALL cxios_write_data_k83_hdl(field_hdl%daddr, data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k83_hdl(field_hdl%daddr, data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3), &
+                                    tileid)
    END SUBROUTINE  xios(send_field_r8_3d_hdl)
 
@@ -869,14 +922,26 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data3d_k8(:,:,:)
-      CALL cxios_write_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3), &
+                                tileid)
    END SUBROUTINE  xios(send_field_r8_3d)
 
+   SUBROUTINE  xios(send_field_tiled_r8_3d)(fieldid, data3d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data3d_k8(:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), &
+                                      size(data3d_k8, 2), size(data3d_k8, 3), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_3d)
+
    SUBROUTINE  xios(send_field_r8_4d_hdl)(field_hdl, data4d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data4d_k8(:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k84_hdl(field_hdl%daddr, data4d_k8, &
                                 size(data4d_k8, 1), size(data4d_k8, 2), size(data4d_k8, 3), &
-                                size(data4d_k8, 4))
+                                size(data4d_k8, 4), tileid)
    END SUBROUTINE  xios(send_field_r8_4d_hdl)
 
@@ -885,16 +950,28 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data4d_k8(:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k84(fieldid, len(fieldid), data4d_k8, &
                                 size(data4d_k8, 1), size(data4d_k8, 2), size(data4d_k8, 3), &
-                                size(data4d_k8, 4))
+                                size(data4d_k8, 4), tileid)
    END SUBROUTINE  xios(send_field_r8_4d)
 
+   SUBROUTINE  xios(send_field_tiled_r8_4d)(fieldid, data4d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data4d_k8(:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k84(fieldid, len(fieldid), data4d_k8, &
+                                size(data4d_k8, 1), size(data4d_k8, 2), size(data4d_k8, 3), &
+                                size(data4d_k8, 4), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_4d)
+
    SUBROUTINE  xios(send_field_r8_5d_hdl)(field_hdl, data5d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data5d_k8(:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k85_hdl(field_hdl%daddr, data5d_k8, &
                                 size(data5d_k8, 1), size(data5d_k8, 2), size(data5d_k8, 3), &
-                                size(data5d_k8, 4), size(data5d_k8, 5))
+                                size(data5d_k8, 4), size(data5d_k8, 5), tileid)
    END SUBROUTINE  xios(send_field_r8_5d_hdl)
 
@@ -903,16 +980,28 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data5d_k8(:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k85(fieldid, len(fieldid), data5d_k8, &
                                 size(data5d_k8, 1), size(data5d_k8, 2), size(data5d_k8, 3), &
-                                size(data5d_k8, 4), size(data5d_k8, 5))
+                                size(data5d_k8, 4), size(data5d_k8, 5), tileid)
    END SUBROUTINE  xios(send_field_r8_5d)
 
+   SUBROUTINE  xios(send_field_tiled_r8_5d)(fieldid, data5d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data5d_k8(:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k85(fieldid, len(fieldid), data5d_k8, &
+                                size(data5d_k8, 1), size(data5d_k8, 2), size(data5d_k8, 3), &
+                                size(data5d_k8, 4), size(data5d_k8, 5), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_5d)
+
    SUBROUTINE  xios(send_field_r8_6d_hdl)(field_hdl, data6d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data6d_k8(:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k86_hdl(field_hdl%daddr, data6d_k8, &
                                 size(data6d_k8, 1), size(data6d_k8, 2), size(data6d_k8, 3), &
-                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6))
+                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6), tileid)
    END SUBROUTINE  xios(send_field_r8_6d_hdl)
 
@@ -921,17 +1010,29 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data6d_k8(:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k86(fieldid, len(fieldid), data6d_k8, &
                                 size(data6d_k8, 1), size(data6d_k8, 2), size(data6d_k8, 3), &
-                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6))
+                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6), tileid)
    END SUBROUTINE  xios(send_field_r8_6d)
 
+   SUBROUTINE  xios(send_field_tiled_r8_6d)(fieldid, data6d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data6d_k8(:,:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k86(fieldid, len(fieldid), data6d_k8, &
+                                size(data6d_k8, 1), size(data6d_k8, 2), size(data6d_k8, 3), &
+                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_6d)
+
    SUBROUTINE  xios(send_field_r8_7d_hdl)(field_hdl, data7d_k8)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data7d_k8(:,:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k87_hdl(field_hdl%daddr, data7d_k8, &
                                 size(data7d_k8, 1), size(data7d_k8, 2), size(data7d_k8, 3), &
                                 size(data7d_k8, 4), size(data7d_k8, 5), size(data7d_k8, 6), &
-                                size(data7d_k8, 7))
+                                size(data7d_k8, 7), tileid)
    END SUBROUTINE  xios(send_field_r8_7d_hdl)
 
@@ -940,9 +1041,21 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data7d_k8(:,:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k87(fieldid, len(fieldid), data7d_k8, &
                                 size(data7d_k8, 1), size(data7d_k8, 2), size(data7d_k8, 3), &
                                 size(data7d_k8, 4), size(data7d_k8, 5), size(data7d_k8, 6), &
-                                size(data7d_k8, 7))
+                                size(data7d_k8, 7), tileid)
    END SUBROUTINE  xios(send_field_r8_7d)
+
+   SUBROUTINE  xios(send_field_tiled_r8_7d)(fieldid, data7d_k8, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data7d_k8(:,:,:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k87(fieldid, len(fieldid), data7d_k8, &
+                                size(data7d_k8, 1), size(data7d_k8, 2), size(data7d_k8, 3), &
+                                size(data7d_k8, 4), size(data7d_k8, 5), size(data7d_k8, 6), &
+                                size(data7d_k8, 7), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r8_7d)
 
    SUBROUTINE xios(send_field_r4_0d_hdl)(field_hdl, data_k4)
@@ -964,5 +1077,6 @@
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data1d_k4(:)
-      CALL cxios_write_data_k41_hdl(field_hdl%daddr, data1d_k4, size(data1d_k4, 1))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k41_hdl(field_hdl%daddr, data1d_k4, size(data1d_k4, 1), tileid)
    END SUBROUTINE xios(send_field_r4_1d_hdl)
 
@@ -971,12 +1085,22 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data1d_k4(:)
-      CALL cxios_write_data_k41(fieldid, len(fieldid), data1d_k4, size(data1d_k4, 1))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k41(fieldid, len(fieldid), data1d_k4, size(data1d_k4, 1), tileid)
    END SUBROUTINE xios(send_field_r4_1d)
 
+   SUBROUTINE xios(send_field_tiled_r4_1d)(fieldid, data1d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data1d_k4(:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k41(fieldid, len(fieldid), data1d_k4, size(data1d_k4, 1), tileid)
+   END SUBROUTINE xios(send_field_tiled_r4_1d)
+
    SUBROUTINE xios(send_field_r4_2d_hdl)(field_hdl, data2d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data2d_k4(:,:)
-      CALL cxios_write_data_k42_hdl(field_hdl%daddr, data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k42_hdl(field_hdl%daddr, data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2), tileid)
    END SUBROUTINE xios(send_field_r4_2d_hdl)
 
@@ -985,12 +1109,23 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data2d_k4(:,:)
-      CALL cxios_write_data_k42(fieldid, len(fieldid), data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k42(fieldid, len(fieldid), data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2), tileid)
    END SUBROUTINE xios(send_field_r4_2d)
 
+   SUBROUTINE xios(send_field_tiled_r4_2d)(fieldid, data2d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data2d_k4(:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k42(fieldid, len(fieldid), data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2), tileid)
+   END SUBROUTINE xios(send_field_tiled_r4_2d)
+
    SUBROUTINE xios(send_field_r4_3d_hdl)(field_hdl, data3d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data3d_k4(:,:,:)
-      CALL cxios_write_data_k43_hdl(field_hdl%daddr, data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k43_hdl(field_hdl%daddr, data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3), &
+                                    tileid)
    END SUBROUTINE xios(send_field_r4_3d_hdl)
 
@@ -999,32 +1134,56 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data3d_k4(:,:,:)
-      CALL cxios_write_data_k43(fieldid, len(fieldid), data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3))
+      INTEGER, PARAMETER                            :: tileid = -1
+      CALL cxios_write_data_k43(fieldid, len(fieldid), data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3), &
+                                tileid)
    END SUBROUTINE xios(send_field_r4_3d)
 
+   SUBROUTINE xios(send_field_tiled_r4_3d)(fieldid, data3d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data3d_k4(:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k43(fieldid, len(fieldid), data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3), &
+                                tileid)
+   END SUBROUTINE xios(send_field_tiled_r4_3d)
+
    SUBROUTINE  xios(send_field_r4_4d_hdl)(field_hdl, data4d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data4d_k4(:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k44_hdl(field_hdl%daddr, data4d_k4, &
                                 size(data4d_k4, 1), size(data4d_k4, 2), size(data4d_k4, 3), &
-                                size(data4d_k4, 4))
+                                size(data4d_k4, 4), tileid)
    END SUBROUTINE  xios(send_field_r4_4d_hdl)
-   
+
    SUBROUTINE  xios(send_field_r4_4d)(fieldid, data4d_k4)
    IMPLICIT NONE
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data4d_k4(:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k44(fieldid, len(fieldid), data4d_k4, &
                                 size(data4d_k4, 1), size(data4d_k4, 2), size(data4d_k4, 3), &
-                                size(data4d_k4, 4))
+                                size(data4d_k4, 4), tileid)
    END SUBROUTINE  xios(send_field_r4_4d)
 
+   SUBROUTINE  xios(send_field_tiled_r4_4d)(fieldid, data4d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data4d_k4(:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k44(fieldid, len(fieldid), data4d_k4, &
+                                size(data4d_k4, 1), size(data4d_k4, 2), size(data4d_k4, 3), &
+                                size(data4d_k4, 4), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r4_4d)
+
    SUBROUTINE  xios(send_field_r4_5d_hdl)(field_hdl, data5d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data5d_k4(:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k45_hdl(field_hdl%daddr, data5d_k4, &
                                 size(data5d_k4, 1), size(data5d_k4, 2), size(data5d_k4, 3), &
-                                size(data5d_k4, 4), size(data5d_k4, 5))
+                                size(data5d_k4, 4), size(data5d_k4, 5), tileid)
    END SUBROUTINE  xios(send_field_r4_5d_hdl)
 
@@ -1033,16 +1192,28 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data5d_k4(:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k45(fieldid, len(fieldid), data5d_k4, &
                                 size(data5d_k4, 1), size(data5d_k4, 2), size(data5d_k4, 3), &
-                                size(data5d_k4, 4), size(data5d_k4, 5))
+                                size(data5d_k4, 4), size(data5d_k4, 5), tileid)
    END SUBROUTINE  xios(send_field_r4_5d)
 
+   SUBROUTINE  xios(send_field_tiled_r4_5d)(fieldid, data5d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data5d_k4(:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k45(fieldid, len(fieldid), data5d_k4, &
+                                size(data5d_k4, 1), size(data5d_k4, 2), size(data5d_k4, 3), &
+                                size(data5d_k4, 4), size(data5d_k4, 5), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r4_5d)
+
    SUBROUTINE  xios(send_field_r4_6d_hdl)(field_hdl, data6d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data6d_k4(:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k46_hdl(field_hdl%daddr, data6d_k4, &
                                 size(data6d_k4, 1), size(data6d_k4, 2), size(data6d_k4, 3), &
-                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6))
+                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6), tileid)
    END SUBROUTINE  xios(send_field_r4_6d_hdl)
    
@@ -1051,17 +1222,29 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data6d_k4(:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k46(fieldid, len(fieldid), data6d_k4, &
                                 size(data6d_k4, 1), size(data6d_k4, 2), size(data6d_k4, 3), &
-                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6))
+                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6), tileid)
    END SUBROUTINE  xios(send_field_r4_6d)
 
+   SUBROUTINE  xios(send_field_tiled_r4_6d)(fieldid, data6d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data6d_k4(:,:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k46(fieldid, len(fieldid), data6d_k4, &
+                                size(data6d_k4, 1), size(data6d_k4, 2), size(data6d_k4, 3), &
+                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r4_6d)
+
    SUBROUTINE  xios(send_field_r4_7d_hdl)(field_hdl, data7d_k4)
    IMPLICIT NONE
       TYPE(txios(field))              :: field_hdl
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data7d_k4(:,:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k47_hdl(field_hdl%daddr, data7d_k4, &
                                 size(data7d_k4, 1), size(data7d_k4, 2), size(data7d_k4, 3), &
                                 size(data7d_k4, 4), size(data7d_k4, 5), size(data7d_k4, 6), &
-                                size(data7d_k4, 7))
+                                size(data7d_k4, 7), tileid)
    END SUBROUTINE  xios(send_field_r4_7d_hdl)
    
@@ -1070,9 +1253,21 @@
       CHARACTER(len = *)               , INTENT(IN) :: fieldid
       REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data7d_k4(:,:,:,:,:,:,:)
+      INTEGER, PARAMETER                            :: tileid = -1
       CALL cxios_write_data_k47(fieldid, len(fieldid), data7d_k4, &
                                 size(data7d_k4, 1), size(data7d_k4, 2), size(data7d_k4, 3), &
                                 size(data7d_k4, 4), size(data7d_k4, 5), size(data7d_k4, 6), &
-                                size(data7d_k4, 7))
+                                size(data7d_k4, 7), tileid)
    END SUBROUTINE  xios(send_field_r4_7d)
+
+   SUBROUTINE  xios(send_field_tiled_r4_7d)(fieldid, data7d_k4, tileid)
+   IMPLICIT NONE
+      CHARACTER(len = *)               , INTENT(IN) :: fieldid
+      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data7d_k4(:,:,:,:,:,:,:)
+      INTEGER                          , INTENT(IN) :: tileid
+      CALL cxios_write_data_k47(fieldid, len(fieldid), data7d_k4, &
+                                size(data7d_k4, 1), size(data7d_k4, 2), size(data7d_k4, 3), &
+                                size(data7d_k4, 4), size(data7d_k4, 5), size(data7d_k4, 6), &
+                                size(data7d_k4, 7), tileid)
+   END SUBROUTINE  xios(send_field_tiled_r4_7d)
 
    ! Receive field functions
Index: XIOS/trunk/src/interface/fortran/ixios_interfaces.F90
===================================================================
--- XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran/ixios_interfaces.F90	(revision 2131)
@@ -15,4 +15,10 @@
                   xios(send_field_r4_0d_hdl), xios(send_field_r4_1d_hdl), xios(send_field_r4_2d_hdl), xios(send_field_r4_3d_hdl), &
                   xios(send_field_r4_4d_hdl), xios(send_field_r4_5d_hdl), xios(send_field_r4_6d_hdl), xios(send_field_r4_7d_hdl), &
+                  xios(send_field_tiled_r8_1d), xios(send_field_tiled_r8_2d), &
+                  xios(send_field_tiled_r8_3d), xios(send_field_tiled_r8_4d), &
+                  xios(send_field_tiled_r8_5d), xios(send_field_tiled_r8_6d), xios(send_field_tiled_r8_7d), &
+                  xios(send_field_tiled_r4_1d), xios(send_field_tiled_r4_2d), &
+                  xios(send_field_tiled_r4_3d), xios(send_field_tiled_r4_4d), &
+                  xios(send_field_tiled_r4_5d), xios(send_field_tiled_r4_6d), xios(send_field_tiled_r4_7d), &
                   xios(recv_field_r8_0d), xios(recv_field_r8_1d), xios(recv_field_r8_2d), xios(recv_field_r8_3d), &
                   xios(recv_field_r8_4d), xios(recv_field_r8_5d), xios(recv_field_r8_6d), xios(recv_field_r8_7d), &
@@ -251,5 +257,11 @@
                    xios(send_field_r8_4d_hdl), xios(send_field_r8_5d_hdl), xios(send_field_r8_6d_hdl), xios(send_field_r8_7d_hdl), &
                    xios(send_field_r4_0d_hdl), xios(send_field_r4_1d_hdl), xios(send_field_r4_2d_hdl), xios(send_field_r4_3d_hdl), &
-                   xios(send_field_r4_4d_hdl), xios(send_field_r4_5d_hdl), xios(send_field_r4_6d_hdl), xios(send_field_r4_7d_hdl)
+                   xios(send_field_r4_4d_hdl), xios(send_field_r4_5d_hdl), xios(send_field_r4_6d_hdl), xios(send_field_r4_7d_hdl), &
+                   xios(send_field_tiled_r8_1d), xios(send_field_tiled_r8_2d), &
+                   xios(send_field_tiled_r8_3d), xios(send_field_tiled_r8_4d), &
+                   xios(send_field_tiled_r8_5d), xios(send_field_tiled_r8_6d), xios(send_field_tiled_r8_7d), &
+                   xios(send_field_tiled_r4_1d), xios(send_field_tiled_r4_2d), &
+                   xios(send_field_tiled_r4_3d), xios(send_field_tiled_r4_4d), &
+                   xios(send_field_tiled_r4_5d), xios(send_field_tiled_r4_6d), xios(send_field_tiled_r4_7d)
 END INTERFACE xios(send_field)
 
Index: XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran_attr/domain_interface_attr.F90	(revision 2131)
@@ -744,4 +744,23 @@
 
 
+    SUBROUTINE cxios_set_domain_ntiles(domain_hdl, ntiles) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: ntiles
+    END SUBROUTINE cxios_set_domain_ntiles
+
+    SUBROUTINE cxios_get_domain_ntiles(domain_hdl, ntiles) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+      INTEGER (KIND=C_INT)             :: ntiles
+    END SUBROUTINE cxios_get_domain_ntiles
+
+    FUNCTION cxios_is_defined_domain_ntiles(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_ntiles
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_ntiles
+
+
     SUBROUTINE cxios_set_domain_nvertex(domain_hdl, nvertex) BIND(C)
       USE ISO_C_BINDING
@@ -822,4 +841,172 @@
 
 
+    SUBROUTINE cxios_set_domain_tile_data_ibegin(domain_hdl, tile_data_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_data_ibegin
+
+    SUBROUTINE cxios_get_domain_tile_data_ibegin(domain_hdl, tile_data_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_data_ibegin
+
+    FUNCTION cxios_is_defined_domain_tile_data_ibegin(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_data_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_data_ibegin
+
+
+    SUBROUTINE cxios_set_domain_tile_data_jbegin(domain_hdl, tile_data_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_data_jbegin
+
+    SUBROUTINE cxios_get_domain_tile_data_jbegin(domain_hdl, tile_data_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_data_jbegin
+
+    FUNCTION cxios_is_defined_domain_tile_data_jbegin(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_data_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_data_jbegin
+
+
+    SUBROUTINE cxios_set_domain_tile_data_ni(domain_hdl, tile_data_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_data_ni
+
+    SUBROUTINE cxios_get_domain_tile_data_ni(domain_hdl, tile_data_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_data_ni
+
+    FUNCTION cxios_is_defined_domain_tile_data_ni(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_data_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_data_ni
+
+
+    SUBROUTINE cxios_set_domain_tile_data_nj(domain_hdl, tile_data_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_data_nj
+
+    SUBROUTINE cxios_get_domain_tile_data_nj(domain_hdl, tile_data_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_data_nj
+
+    FUNCTION cxios_is_defined_domain_tile_data_nj(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_data_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_data_nj
+
+
+    SUBROUTINE cxios_set_domain_tile_ibegin(domain_hdl, tile_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_ibegin
+
+    SUBROUTINE cxios_get_domain_tile_ibegin(domain_hdl, tile_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_ibegin
+
+    FUNCTION cxios_is_defined_domain_tile_ibegin(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_ibegin
+
+
+    SUBROUTINE cxios_set_domain_tile_jbegin(domain_hdl, tile_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_jbegin
+
+    SUBROUTINE cxios_get_domain_tile_jbegin(domain_hdl, tile_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_jbegin
+
+    FUNCTION cxios_is_defined_domain_tile_jbegin(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_jbegin
+
+
+    SUBROUTINE cxios_set_domain_tile_ni(domain_hdl, tile_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_ni
+
+    SUBROUTINE cxios_get_domain_tile_ni(domain_hdl, tile_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_ni
+
+    FUNCTION cxios_is_defined_domain_tile_ni(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_ni
+
+
+    SUBROUTINE cxios_set_domain_tile_nj(domain_hdl, tile_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domain_tile_nj
+
+    SUBROUTINE cxios_get_domain_tile_nj(domain_hdl, tile_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domain_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domain_tile_nj
+
+    FUNCTION cxios_is_defined_domain_tile_nj(domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domain_tile_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domain_hdl
+    END FUNCTION cxios_is_defined_domain_tile_nj
+
+
     SUBROUTINE cxios_set_domain_type(domain_hdl, type, type_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran_attr/domaingroup_interface_attr.F90	(revision 2131)
@@ -765,4 +765,23 @@
 
 
+    SUBROUTINE cxios_set_domaingroup_ntiles(domaingroup_hdl, ntiles) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      INTEGER (KIND=C_INT)      , VALUE :: ntiles
+    END SUBROUTINE cxios_set_domaingroup_ntiles
+
+    SUBROUTINE cxios_get_domaingroup_ntiles(domaingroup_hdl, ntiles) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+      INTEGER (KIND=C_INT)             :: ntiles
+    END SUBROUTINE cxios_get_domaingroup_ntiles
+
+    FUNCTION cxios_is_defined_domaingroup_ntiles(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_ntiles
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_ntiles
+
+
     SUBROUTINE cxios_set_domaingroup_nvertex(domaingroup_hdl, nvertex) BIND(C)
       USE ISO_C_BINDING
@@ -843,4 +862,172 @@
 
 
+    SUBROUTINE cxios_set_domaingroup_tile_data_ibegin(domaingroup_hdl, tile_data_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_data_ibegin
+
+    SUBROUTINE cxios_get_domaingroup_tile_data_ibegin(domaingroup_hdl, tile_data_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_data_ibegin
+
+    FUNCTION cxios_is_defined_domaingroup_tile_data_ibegin(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_data_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_data_ibegin
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_data_jbegin(domaingroup_hdl, tile_data_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_data_jbegin
+
+    SUBROUTINE cxios_get_domaingroup_tile_data_jbegin(domaingroup_hdl, tile_data_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_data_jbegin
+
+    FUNCTION cxios_is_defined_domaingroup_tile_data_jbegin(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_data_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_data_jbegin
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_data_ni(domaingroup_hdl, tile_data_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_data_ni
+
+    SUBROUTINE cxios_get_domaingroup_tile_data_ni(domaingroup_hdl, tile_data_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_data_ni
+
+    FUNCTION cxios_is_defined_domaingroup_tile_data_ni(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_data_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_data_ni
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_data_nj(domaingroup_hdl, tile_data_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_data_nj
+
+    SUBROUTINE cxios_get_domaingroup_tile_data_nj(domaingroup_hdl, tile_data_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_data_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_data_nj
+
+    FUNCTION cxios_is_defined_domaingroup_tile_data_nj(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_data_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_data_nj
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_ibegin(domaingroup_hdl, tile_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_ibegin
+
+    SUBROUTINE cxios_get_domaingroup_tile_ibegin(domaingroup_hdl, tile_ibegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ibegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_ibegin
+
+    FUNCTION cxios_is_defined_domaingroup_tile_ibegin(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_ibegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_ibegin
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_jbegin(domaingroup_hdl, tile_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_jbegin
+
+    SUBROUTINE cxios_get_domaingroup_tile_jbegin(domaingroup_hdl, tile_jbegin, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_jbegin
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_jbegin
+
+    FUNCTION cxios_is_defined_domaingroup_tile_jbegin(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_jbegin
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_jbegin
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_ni(domaingroup_hdl, tile_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_ni
+
+    SUBROUTINE cxios_get_domaingroup_tile_ni(domaingroup_hdl, tile_ni, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_ni
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_ni
+
+    FUNCTION cxios_is_defined_domaingroup_tile_ni(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_ni
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_ni
+
+
+    SUBROUTINE cxios_set_domaingroup_tile_nj(domaingroup_hdl, tile_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_set_domaingroup_tile_nj
+
+    SUBROUTINE cxios_get_domaingroup_tile_nj(domaingroup_hdl, tile_nj, extent) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: domaingroup_hdl
+      INTEGER (KIND=C_INT)     , DIMENSION(*) :: tile_nj
+      INTEGER (kind = C_INT), DIMENSION(*)     :: extent
+    END SUBROUTINE cxios_get_domaingroup_tile_nj
+
+    FUNCTION cxios_is_defined_domaingroup_tile_nj(domaingroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_domaingroup_tile_nj
+      INTEGER (kind = C_INTPTR_T), VALUE :: domaingroup_hdl
+    END FUNCTION cxios_is_defined_domaingroup_tile_nj
+
+
     SUBROUTINE cxios_set_domaingroup_type(domaingroup_hdl, type, type_size) BIND(C)
       USE ISO_C_BINDING
Index: XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran_attr/idomain_attr.F90	(revision 2131)
@@ -16,5 +16,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -59,8 +60,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
@@ -72,5 +82,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(set_domain_attr)
@@ -81,5 +92,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -123,8 +135,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
@@ -134,5 +155,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(set_domain_attr_hdl)
@@ -143,6 +165,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
     , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -186,8 +209,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo_
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles_
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex_
       INTEGER  , OPTIONAL, INTENT(IN) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj_(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
 
@@ -376,4 +408,9 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        CALL cxios_set_domain_ntiles &
+      (domain_hdl%daddr, ntiles_)
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         CALL cxios_set_domain_nvertex &
@@ -394,4 +431,44 @@
         CALL cxios_set_domain_standard_name &
       (domain_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        CALL cxios_set_domain_tile_data_ibegin &
+      (domain_hdl%daddr, tile_data_ibegin_, SHAPE(tile_data_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        CALL cxios_set_domain_tile_data_jbegin &
+      (domain_hdl%daddr, tile_data_jbegin_, SHAPE(tile_data_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        CALL cxios_set_domain_tile_data_ni &
+      (domain_hdl%daddr, tile_data_ni_, SHAPE(tile_data_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        CALL cxios_set_domain_tile_data_nj &
+      (domain_hdl%daddr, tile_data_nj_, SHAPE(tile_data_nj_))
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        CALL cxios_set_domain_tile_ibegin &
+      (domain_hdl%daddr, tile_ibegin_, SHAPE(tile_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        CALL cxios_set_domain_tile_jbegin &
+      (domain_hdl%daddr, tile_jbegin_, SHAPE(tile_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        CALL cxios_set_domain_tile_ni &
+      (domain_hdl%daddr, tile_ni_, SHAPE(tile_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        CALL cxios_set_domain_tile_nj &
+      (domain_hdl%daddr, tile_nj_, SHAPE(tile_nj_))
       ENDIF
 
@@ -408,5 +485,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -451,8 +529,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
@@ -464,5 +551,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(get_domain_attr)
@@ -473,5 +561,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -515,8 +604,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
@@ -526,5 +624,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(get_domain_attr_hdl)
@@ -535,6 +634,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
     , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -578,8 +678,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex_
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj_(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
 
@@ -768,4 +877,9 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        CALL cxios_get_domain_ntiles &
+      (domain_hdl%daddr, ntiles_)
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         CALL cxios_get_domain_nvertex &
@@ -786,4 +900,44 @@
         CALL cxios_get_domain_standard_name &
       (domain_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        CALL cxios_get_domain_tile_data_ibegin &
+      (domain_hdl%daddr, tile_data_ibegin_, SHAPE(tile_data_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        CALL cxios_get_domain_tile_data_jbegin &
+      (domain_hdl%daddr, tile_data_jbegin_, SHAPE(tile_data_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        CALL cxios_get_domain_tile_data_ni &
+      (domain_hdl%daddr, tile_data_ni_, SHAPE(tile_data_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        CALL cxios_get_domain_tile_data_nj &
+      (domain_hdl%daddr, tile_data_nj_, SHAPE(tile_data_nj_))
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        CALL cxios_get_domain_tile_ibegin &
+      (domain_hdl%daddr, tile_ibegin_, SHAPE(tile_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        CALL cxios_get_domain_tile_jbegin &
+      (domain_hdl%daddr, tile_jbegin_, SHAPE(tile_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        CALL cxios_get_domain_tile_ni &
+      (domain_hdl%daddr, tile_ni_, SHAPE(tile_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        CALL cxios_get_domain_tile_nj &
+      (domain_hdl%daddr, tile_nj_, SHAPE(tile_nj_))
       ENDIF
 
@@ -800,5 +954,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -877,4 +1032,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
       LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles
+      LOGICAL(KIND=C_BOOL) :: ntiles_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
@@ -885,4 +1042,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni
+      LOGICAL(KIND=C_BOOL) :: tile_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj
+      LOGICAL(KIND=C_BOOL) :: tile_nj_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
@@ -895,5 +1068,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(is_defined_domain_attr)
@@ -904,5 +1078,6 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
     , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-    , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+    , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
     IMPLICIT NONE
@@ -980,4 +1155,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
       LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles
+      LOGICAL(KIND=C_BOOL) :: ntiles_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
@@ -988,4 +1165,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni
+      LOGICAL(KIND=C_BOOL) :: tile_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj
+      LOGICAL(KIND=C_BOOL) :: tile_nj_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
@@ -996,5 +1189,6 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, i_index, ibegin, j_index, jbegin, lat_name, latvalue_1d  &
       , latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d, name, ni, ni_glo  &
-      , nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin, tile_data_jbegin  &
+      , tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type )
 
   END SUBROUTINE xios(is_defined_domain_attr_hdl)
@@ -1005,6 +1199,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, i_index_, ibegin_, j_index_, jbegin_  &
     , lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_, mask_1d_  &
-    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_, type_  &
-     )
+    , mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -1082,4 +1277,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo_
       LOGICAL(KIND=C_BOOL) :: nj_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles_
+      LOGICAL(KIND=C_BOOL) :: ntiles__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_
       LOGICAL(KIND=C_BOOL) :: nvertex__tmp
@@ -1090,4 +1287,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
       LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin_
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin_
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni_
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj_
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin_
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin_
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni_
+      LOGICAL(KIND=C_BOOL) :: tile_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj_
+      LOGICAL(KIND=C_BOOL) :: tile_nj__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type_
       LOGICAL(KIND=C_BOOL) :: type__tmp
@@ -1309,4 +1522,10 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        ntiles__tmp = cxios_is_defined_domain_ntiles &
+      (domain_hdl%daddr)
+        ntiles_ = ntiles__tmp
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         nvertex__tmp = cxios_is_defined_domain_nvertex &
@@ -1333,4 +1552,52 @@
       ENDIF
 
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        tile_data_ibegin__tmp = cxios_is_defined_domain_tile_data_ibegin &
+      (domain_hdl%daddr)
+        tile_data_ibegin_ = tile_data_ibegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        tile_data_jbegin__tmp = cxios_is_defined_domain_tile_data_jbegin &
+      (domain_hdl%daddr)
+        tile_data_jbegin_ = tile_data_jbegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        tile_data_ni__tmp = cxios_is_defined_domain_tile_data_ni &
+      (domain_hdl%daddr)
+        tile_data_ni_ = tile_data_ni__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        tile_data_nj__tmp = cxios_is_defined_domain_tile_data_nj &
+      (domain_hdl%daddr)
+        tile_data_nj_ = tile_data_nj__tmp
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        tile_ibegin__tmp = cxios_is_defined_domain_tile_ibegin &
+      (domain_hdl%daddr)
+        tile_ibegin_ = tile_ibegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        tile_jbegin__tmp = cxios_is_defined_domain_tile_jbegin &
+      (domain_hdl%daddr)
+        tile_jbegin_ = tile_jbegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        tile_ni__tmp = cxios_is_defined_domain_tile_ni &
+      (domain_hdl%daddr)
+        tile_ni_ = tile_ni__tmp
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        tile_nj__tmp = cxios_is_defined_domain_tile_nj &
+      (domain_hdl%daddr)
+        tile_nj_ = tile_nj__tmp
+      ENDIF
+
       IF (PRESENT(type_)) THEN
         type__tmp = cxios_is_defined_domain_type &
Index: XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90
===================================================================
--- XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 2109)
+++ XIOS/trunk/src/interface/fortran_attr/idomaingroup_attr.F90	(revision 2131)
@@ -16,5 +16,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -60,8 +62,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
@@ -73,5 +84,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(set_domaingroup_attr)
@@ -82,5 +95,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -125,8 +140,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex
       INTEGER  , OPTIONAL, INTENT(IN) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
@@ -136,5 +160,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(set_domaingroup_attr_hdl)
@@ -145,6 +171,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
     , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -189,8 +216,17 @@
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_
       INTEGER  , OPTIONAL, INTENT(IN) :: nj_glo_
+      INTEGER  , OPTIONAL, INTENT(IN) :: ntiles_
       INTEGER  , OPTIONAL, INTENT(IN) :: nvertex_
       INTEGER  , OPTIONAL, INTENT(IN) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(IN) :: radius_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: standard_name_
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_data_nj_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(IN) :: tile_nj_(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
 
@@ -384,4 +420,9 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        CALL cxios_set_domaingroup_ntiles &
+      (domaingroup_hdl%daddr, ntiles_)
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         CALL cxios_set_domaingroup_nvertex &
@@ -402,4 +443,44 @@
         CALL cxios_set_domaingroup_standard_name &
       (domaingroup_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        CALL cxios_set_domaingroup_tile_data_ibegin &
+      (domaingroup_hdl%daddr, tile_data_ibegin_, SHAPE(tile_data_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        CALL cxios_set_domaingroup_tile_data_jbegin &
+      (domaingroup_hdl%daddr, tile_data_jbegin_, SHAPE(tile_data_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        CALL cxios_set_domaingroup_tile_data_ni &
+      (domaingroup_hdl%daddr, tile_data_ni_, SHAPE(tile_data_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        CALL cxios_set_domaingroup_tile_data_nj &
+      (domaingroup_hdl%daddr, tile_data_nj_, SHAPE(tile_data_nj_))
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        CALL cxios_set_domaingroup_tile_ibegin &
+      (domaingroup_hdl%daddr, tile_ibegin_, SHAPE(tile_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        CALL cxios_set_domaingroup_tile_jbegin &
+      (domaingroup_hdl%daddr, tile_jbegin_, SHAPE(tile_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        CALL cxios_set_domaingroup_tile_ni &
+      (domaingroup_hdl%daddr, tile_ni_, SHAPE(tile_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        CALL cxios_set_domaingroup_tile_nj &
+      (domaingroup_hdl%daddr, tile_nj_, SHAPE(tile_nj_))
       ENDIF
 
@@ -416,5 +497,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -460,8 +543,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
@@ -473,5 +565,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(get_domaingroup_attr)
@@ -482,5 +576,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -525,8 +621,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
@@ -536,5 +641,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(get_domaingroup_attr_hdl)
@@ -545,6 +652,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
     , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -589,8 +697,17 @@
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nj_glo_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: ntiles_
       INTEGER  , OPTIONAL, INTENT(OUT) :: nvertex_
       INTEGER  , OPTIONAL, INTENT(OUT) :: prec_
       REAL (KIND=8) , OPTIONAL, INTENT(OUT) :: radius_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: standard_name_
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_data_nj_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ibegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_jbegin_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_ni_(:)
+      INTEGER  , OPTIONAL, INTENT(OUT) :: tile_nj_(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
 
@@ -784,4 +901,9 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        CALL cxios_get_domaingroup_ntiles &
+      (domaingroup_hdl%daddr, ntiles_)
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         CALL cxios_get_domaingroup_nvertex &
@@ -802,4 +924,44 @@
         CALL cxios_get_domaingroup_standard_name &
       (domaingroup_hdl%daddr, standard_name_, len(standard_name_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        CALL cxios_get_domaingroup_tile_data_ibegin &
+      (domaingroup_hdl%daddr, tile_data_ibegin_, SHAPE(tile_data_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        CALL cxios_get_domaingroup_tile_data_jbegin &
+      (domaingroup_hdl%daddr, tile_data_jbegin_, SHAPE(tile_data_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        CALL cxios_get_domaingroup_tile_data_ni &
+      (domaingroup_hdl%daddr, tile_data_ni_, SHAPE(tile_data_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        CALL cxios_get_domaingroup_tile_data_nj &
+      (domaingroup_hdl%daddr, tile_data_nj_, SHAPE(tile_data_nj_))
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        CALL cxios_get_domaingroup_tile_ibegin &
+      (domaingroup_hdl%daddr, tile_ibegin_, SHAPE(tile_ibegin_))
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        CALL cxios_get_domaingroup_tile_jbegin &
+      (domaingroup_hdl%daddr, tile_jbegin_, SHAPE(tile_jbegin_))
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        CALL cxios_get_domaingroup_tile_ni &
+      (domaingroup_hdl%daddr, tile_ni_, SHAPE(tile_ni_))
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        CALL cxios_get_domaingroup_tile_nj &
+      (domaingroup_hdl%daddr, tile_nj_, SHAPE(tile_nj_))
       ENDIF
 
@@ -816,5 +978,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -895,4 +1059,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
       LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles
+      LOGICAL(KIND=C_BOOL) :: ntiles_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
@@ -903,4 +1069,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni
+      LOGICAL(KIND=C_BOOL) :: tile_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj
+      LOGICAL(KIND=C_BOOL) :: tile_nj_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
@@ -913,5 +1095,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr)
@@ -922,5 +1106,7 @@
     , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
     , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-    , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+    , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+    , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+     )
 
     IMPLICIT NONE
@@ -1000,4 +1186,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo
       LOGICAL(KIND=C_BOOL) :: nj_glo_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles
+      LOGICAL(KIND=C_BOOL) :: ntiles_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex
       LOGICAL(KIND=C_BOOL) :: nvertex_tmp
@@ -1008,4 +1196,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name
       LOGICAL(KIND=C_BOOL) :: standard_name_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni
+      LOGICAL(KIND=C_BOOL) :: tile_ni_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj
+      LOGICAL(KIND=C_BOOL) :: tile_nj_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type
       LOGICAL(KIND=C_BOOL) :: type_tmp
@@ -1016,5 +1220,7 @@
       , data_nj, dim_i_name, dim_j_name, domain_ref, group_ref, i_index, ibegin, j_index, jbegin, lat_name  &
       , latvalue_1d, latvalue_2d, lon_name, long_name, lonvalue_1d, lonvalue_2d, mask_1d, mask_2d  &
-      , name, ni, ni_glo, nj, nj_glo, nvertex, prec, radius, standard_name, type )
+      , name, ni, ni_glo, nj, nj_glo, ntiles, nvertex, prec, radius, standard_name, tile_data_ibegin  &
+      , tile_data_jbegin, tile_data_ni, tile_data_nj, tile_ibegin, tile_jbegin, tile_ni, tile_nj, type  &
+       )
 
   END SUBROUTINE xios(is_defined_domaingroup_attr_hdl)
@@ -1025,6 +1231,7 @@
     , data_ni_, data_nj_, dim_i_name_, dim_j_name_, domain_ref_, group_ref_, i_index_, ibegin_, j_index_  &
     , jbegin_, lat_name_, latvalue_1d_, latvalue_2d_, lon_name_, long_name_, lonvalue_1d_, lonvalue_2d_  &
-    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, nvertex_, prec_, radius_, standard_name_  &
-    , type_ )
+    , mask_1d_, mask_2d_, name_, ni_, ni_glo_, nj_, nj_glo_, ntiles_, nvertex_, prec_, radius_, standard_name_  &
+    , tile_data_ibegin_, tile_data_jbegin_, tile_data_ni_, tile_data_nj_, tile_ibegin_, tile_jbegin_  &
+    , tile_ni_, tile_nj_, type_ )
 
     IMPLICIT NONE
@@ -1104,4 +1311,6 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: nj_glo_
       LOGICAL(KIND=C_BOOL) :: nj_glo__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: ntiles_
+      LOGICAL(KIND=C_BOOL) :: ntiles__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: nvertex_
       LOGICAL(KIND=C_BOOL) :: nvertex__tmp
@@ -1112,4 +1321,20 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: standard_name_
       LOGICAL(KIND=C_BOOL) :: standard_name__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ibegin_
+      LOGICAL(KIND=C_BOOL) :: tile_data_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_jbegin_
+      LOGICAL(KIND=C_BOOL) :: tile_data_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_ni_
+      LOGICAL(KIND=C_BOOL) :: tile_data_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_data_nj_
+      LOGICAL(KIND=C_BOOL) :: tile_data_nj__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ibegin_
+      LOGICAL(KIND=C_BOOL) :: tile_ibegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_jbegin_
+      LOGICAL(KIND=C_BOOL) :: tile_jbegin__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_ni_
+      LOGICAL(KIND=C_BOOL) :: tile_ni__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: tile_nj_
+      LOGICAL(KIND=C_BOOL) :: tile_nj__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: type_
       LOGICAL(KIND=C_BOOL) :: type__tmp
@@ -1337,4 +1562,10 @@
       ENDIF
 
+      IF (PRESENT(ntiles_)) THEN
+        ntiles__tmp = cxios_is_defined_domaingroup_ntiles &
+      (domaingroup_hdl%daddr)
+        ntiles_ = ntiles__tmp
+      ENDIF
+
       IF (PRESENT(nvertex_)) THEN
         nvertex__tmp = cxios_is_defined_domaingroup_nvertex &
@@ -1361,4 +1592,52 @@
       ENDIF
 
+      IF (PRESENT(tile_data_ibegin_)) THEN
+        tile_data_ibegin__tmp = cxios_is_defined_domaingroup_tile_data_ibegin &
+      (domaingroup_hdl%daddr)
+        tile_data_ibegin_ = tile_data_ibegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_jbegin_)) THEN
+        tile_data_jbegin__tmp = cxios_is_defined_domaingroup_tile_data_jbegin &
+      (domaingroup_hdl%daddr)
+        tile_data_jbegin_ = tile_data_jbegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_ni_)) THEN
+        tile_data_ni__tmp = cxios_is_defined_domaingroup_tile_data_ni &
+      (domaingroup_hdl%daddr)
+        tile_data_ni_ = tile_data_ni__tmp
+      ENDIF
+
+      IF (PRESENT(tile_data_nj_)) THEN
+        tile_data_nj__tmp = cxios_is_defined_domaingroup_tile_data_nj &
+      (domaingroup_hdl%daddr)
+        tile_data_nj_ = tile_data_nj__tmp
+      ENDIF
+
+      IF (PRESENT(tile_ibegin_)) THEN
+        tile_ibegin__tmp = cxios_is_defined_domaingroup_tile_ibegin &
+      (domaingroup_hdl%daddr)
+        tile_ibegin_ = tile_ibegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_jbegin_)) THEN
+        tile_jbegin__tmp = cxios_is_defined_domaingroup_tile_jbegin &
+      (domaingroup_hdl%daddr)
+        tile_jbegin_ = tile_jbegin__tmp
+      ENDIF
+
+      IF (PRESENT(tile_ni_)) THEN
+        tile_ni__tmp = cxios_is_defined_domaingroup_tile_ni &
+      (domaingroup_hdl%daddr)
+        tile_ni_ = tile_ni__tmp
+      ENDIF
+
+      IF (PRESENT(tile_nj_)) THEN
+        tile_nj__tmp = cxios_is_defined_domaingroup_tile_nj &
+      (domaingroup_hdl%daddr)
+        tile_nj_ = tile_nj__tmp
+      ENDIF
+
       IF (PRESENT(type_)) THEN
         type__tmp = cxios_is_defined_domaingroup_type &
Index: XIOS/trunk/src/node/domain.cpp
===================================================================
--- XIOS/trunk/src/node/domain.cpp	(revision 2109)
+++ XIOS/trunk/src/node/domain.cpp	(revision 2131)
@@ -35,4 +35,5 @@
       , clients(), hasLatInReadFile_(false), hasBoundsLatInReadFile_(false)
       , hasLonInReadFile_(false), hasBoundsLonInReadFile_(false)
+      , isTiled_(false), isTiledOnly_(false)
    {
    }
@@ -48,4 +49,5 @@
       , clients(), hasLatInReadFile_(false), hasBoundsLatInReadFile_(false)
       , hasLonInReadFile_(false), hasBoundsLonInReadFile_(false)
+      , isTiled_(false), isTiledOnly_(false)
    {
     }
@@ -246,4 +248,34 @@
    {
       return isCompressible_;
+   }
+   CATCH
+
+   bool CDomain::isTiled(void) const
+   TRY
+   {
+      return isTiled_;
+   }
+   CATCH
+
+   bool CDomain::isTiledOnly(void) const
+   TRY
+   {
+      return isTiledOnly_;
+   }
+   CATCH
+
+   int CDomain::getTileId(int i, int j) const
+   TRY
+   {
+     int tileId = 0;
+     bool stop = false;
+     while (!stop)
+     {
+       if ((i >= tile_ibegin(tileId) ) && (i < tile_ni(tileId)+tile_ibegin(tileId) )
+           && (j >= tile_jbegin(tileId) ) && (j < tile_nj(tileId)+tile_jbegin(tileId) ) )
+         stop = true;
+       ++tileId;
+     }
+     return (tileId - 1);
    }
    CATCH
@@ -1260,4 +1292,37 @@
         }
       }
+   }
+   CATCH_DUMP_ATTR
+
+   //----------------------------------------------------------------
+
+   /*!
+    * For tiled domains, data_i/j_index should not take into
+    * account parameters defining data (data_ni/nj, data_i/jbegin...)
+    * \param [out] dataIndexI
+    * \param [out] dataIndexJ
+    * \param [out] infoIndexI
+    * \param [out] infoIndexJ
+    */
+
+   void CDomain::computeCompressionTiled(CArray<int,1>& dataIndexI, CArray<int,1>& dataIndexJ,
+                                         CArray<int,1>& infoIndexI, CArray<int,1>& infoIndexJ)
+   TRY
+   {
+     const int dsize = ni * nj;
+     dataIndexI.resize(dsize);
+     dataIndexJ.resize(dsize);
+
+     dataIndexJ = 0;
+     for (int k = 0; k < ni * nj; ++k)
+       dataIndexI(k) = k;
+
+     infoIndexI.resize(ni*nj);
+     for (int j = 0; j < nj; ++j)
+       for (int i = 0; i < ni; ++i) infoIndexI(i+j*ni) = i+ibegin;
+
+     infoIndexJ.resize(ni*nj);
+     for (int j = 0; j < nj; ++j)
+       for (int i = 0; i < ni; ++i) infoIndexJ(i+j*ni) = j+jbegin;
    }
    CATCH_DUMP_ATTR
@@ -1723,4 +1788,86 @@
    CATCH_DUMP_ATTR
 
+   //----------------------------------------------------------------
+   void CDomain::checkTiles()
+   TRY
+   {
+     if (!ntiles.isEmpty() && ntiles.getValue() >=1) isTiled_ = true;
+     if (!tile_only.isEmpty() && tile_only.getValue() == true) {
+       isTiled_ = true;
+       isTiledOnly_ = true;
+     }
+
+     if (isTiled_)
+     {
+
+       // Attributes tile_ni/nj and tile_i/jbegin are mandatory for tiled domains
+       if (tile_ni.numElements() != ntiles || tile_ibegin.numElements() != ntiles)
+           ERROR("CDomain::checkTiles()",
+                 << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+                 << "'tile_ni' or 'tile_ibegin' are ill defined: these attributes must be specified for tiled domains and be of the size 'ntiles'." << std::endl
+                 << "The number of tiles is  " << ntiles.getValue() << " while the size of 'tile_ni' is " << tile_ni.numElements() 
+                 << " and the size of 'tile_ibegin' is " << tile_ibegin.numElements() << ".");
+
+       if (tile_nj.numElements() != ntiles || tile_jbegin.numElements() != ntiles)
+           ERROR("CDomain::checkTiles()",
+                 << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+                 << "'tile_nj' or 'tile_jbegin' are ill defined: these attributes must be specified for tiled domains and be of the size 'ntiles'." << std::endl
+                 << "The number of tiles is  " << ntiles.getValue() << " while the size of 'tile_nj' is " << tile_nj.numElements()
+                 << " and the size of 'tile_jbegin' is " << tile_jbegin.numElements() << ".");
+
+       // Check on consistency of individual tile sizes and local domain size
+       int sizeTiles = 0;
+       for (int iTile = 0; iTile < ntiles.getValue(); ++iTile)
+       {
+         sizeTiles += tile_ni(iTile) * tile_nj(iTile);
+       }
+       if (sizeTiles != (ni*nj))
+           ERROR("CDomain::checkTiles()",
+                 << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+                 << "tiles should cover the entire local domain and cannot overlap." << std::endl << ".");
+
+
+       // Fill in tile_data_ni/nj and tile_data_i/jbegin if they are not specified
+       if (tile_data_ni.numElements() == 0 || tile_data_nj.numElements() == 0)
+       {
+         tile_data_ni.resize(ntiles);
+         tile_data_nj.resize(ntiles);
+         for (int iTile = 0; iTile < ntiles.getValue(); ++iTile)
+         {
+           tile_data_ni(iTile) = tile_ni(iTile);
+           tile_data_nj(iTile) = tile_nj(iTile);
+         }
+       }
+
+       if (tile_data_ibegin.numElements() == 0 || tile_data_jbegin.numElements() == 0)
+       {
+         tile_data_ibegin.resize(ntiles);
+         tile_data_jbegin.resize(ntiles);
+         tile_data_ibegin = 0;
+         tile_data_jbegin = 0;
+       }
+
+     } // isTiled_
+   }
+   CATCH_DUMP_ATTR
+
+   //----------------------------------------------------------------
+   int CDomain::getTileDataISize(int tileId) const
+   TRY
+   {
+     int retvalue = (tile_data_ni(tileId) > tile_ni(tileId)) ? tile_data_ni(tileId) : tile_ni(tileId);
+     return retvalue;
+   }
+   CATCH_DUMP_ATTR
+
+   //----------------------------------------------------------------
+   int CDomain::getTileDataJSize(int tileId) const
+   TRY
+   {
+     int retvalue = (tile_data_nj(tileId) > tile_nj(tileId)) ? tile_data_nj(tileId) : tile_nj(tileId);
+     return retvalue;
+   }
+   CATCH_DUMP_ATTR
+
    void CDomain::checkAttributesOnClientAfterTransformation()
    TRY
@@ -1756,4 +1903,5 @@
         this->checkArea();
         this->checkLonLat();
+        this->checkTiles();
       }
 
Index: XIOS/trunk/src/node/domain.hpp
===================================================================
--- XIOS/trunk/src/node/domain.hpp	(revision 2109)
+++ XIOS/trunk/src/node/domain.hpp	(revision 2131)
@@ -104,5 +104,13 @@
          bool isDistributed(void) const;
          bool isCompressible(void) const; 
- 
+
+         bool isTiled(void) const;
+         bool isTiledOnly(void) const;
+         int getTileId(int i, int j) const;
+         int getTileDataISize(int tileId) const;
+         int getTileDataJSize(int tileId) const;
+         void computeCompressionTiled(CArray<int,1>& dataIndexI, CArray<int,1>& dataIndexJ,
+                                      CArray<int,1>& infoIndexI, CArray<int,1>& infoIndexJ);
+
          std::vector<int> getNbGlob();
          bool isEqual(CDomain* domain);
@@ -170,4 +178,5 @@
          void checkArea(void);
          void checkLonLat();
+         void checkTiles();
 
          void setTransformations(const TransMapTypes&);         
@@ -223,5 +232,5 @@
          std::map<int, std::vector<int> > connectedServerRank_;
 
-         //! True if and only if the data defined on the domain can be outputted in a compressed way
+//! True if and only if the data defined on the domain can be outputted in a compressed way
          bool isCompressible_;
          bool isRedistributed_;
@@ -229,5 +238,10 @@
          bool isUnstructed_;
          std::unordered_map<size_t,size_t> globalLocalIndexMap_;
-       
+
+//! True if tiled data is defined on the domain
+         bool isTiled_;
+//! True if ONLY tiled data is defined on the domain
+         bool isTiledOnly_;
+
        private:
          static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m);
Index: XIOS/trunk/src/node/field.cpp
===================================================================
--- XIOS/trunk/src/node/field.cpp	(revision 2109)
+++ XIOS/trunk/src/node/field.cpp	(revision 2131)
@@ -2059,5 +2059,5 @@
      {
        //if(file->output_freq.getValue() < freq_op.getValue())
-       if((isFieldRead || isFieldWrite) && (freq_op.getValue() > file->output_freq.getValue()) )
+       if((isFieldRead || isFieldWrite) && (file!=nullptr) && (freq_op.getValue() > file->output_freq.getValue() ))
        {
          ERROR("void CField::checkTimeAttributes(void)",
Index: XIOS/trunk/src/node/field.hpp
===================================================================
--- XIOS/trunk/src/node/field.hpp	(revision 2109)
+++ XIOS/trunk/src/node/field.hpp	(revision 2131)
@@ -160,5 +160,5 @@
          static ENodeType GetType(void);
 
-        template <int N> void setData(const CArray<double, N>& _data);
+        template <int N> void setData(const CArray<double, N>& _data, int ntile = -1);
         static bool dispatchEvent(CEventServer& event);
         void sendAllAttributesToServer(CContextClient* client) ; 
Index: XIOS/trunk/src/node/field_decl.cpp
===================================================================
--- XIOS/trunk/src/node/field_decl.cpp	(revision 2109)
+++ XIOS/trunk/src/node/field_decl.cpp	(revision 2131)
@@ -3,11 +3,11 @@
 namespace xios
 {
-  template void CField::setData<1>(const CArray<double, 1>& _data);
-  template void CField::setData<2>(const CArray<double, 2>& _data);
-  template void CField::setData<3>(const CArray<double, 3>& _data);
-  template void CField::setData<4>(const CArray<double, 4>& _data);
-  template void CField::setData<5>(const CArray<double, 5>& _data);
-  template void CField::setData<6>(const CArray<double, 6>& _data);
-  template void CField::setData<7>(const CArray<double, 7>& _data);
+  template void CField::setData<1>(const CArray<double, 1>& _data, int ntile);
+  template void CField::setData<2>(const CArray<double, 2>& _data, int ntile);
+  template void CField::setData<3>(const CArray<double, 3>& _data, int ntile);
+  template void CField::setData<4>(const CArray<double, 4>& _data, int ntile);
+  template void CField::setData<5>(const CArray<double, 5>& _data, int ntile);
+  template void CField::setData<6>(const CArray<double, 6>& _data, int ntile);
+  template void CField::setData<7>(const CArray<double, 7>& _data, int ntile);
 
   template void CField::getData<1>(CArray<double, 1>& _data) const;
Index: XIOS/trunk/src/node/field_impl.hpp
===================================================================
--- XIOS/trunk/src/node/field_impl.hpp	(revision 2109)
+++ XIOS/trunk/src/node/field_impl.hpp	(revision 2131)
@@ -16,5 +16,5 @@
 
   template <int N>
-  void CField::setData(const CArray<double, N>& _data)
+  void CField::setData(const CArray<double, N>& _data, int tileid)
   TRY
   {
@@ -22,5 +22,8 @@
     {
       if (check_if_active.isEmpty() || (!check_if_active.isEmpty() && (!check_if_active) || isActive(true)))
-        clientSourceFilter->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
+        if (tileid > -1)
+          clientSourceFilter->streamTile(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data, tileid); // tiled domain
+        else
+          clientSourceFilter->streamData(CContext::getCurrent()->getCalendar()->getCurrentDate(), _data);
     }
     else if (instantDataFilter)
Index: XIOS/trunk/src/node/grid.cpp
===================================================================
--- XIOS/trunk/src/node/grid.cpp	(revision 2109)
+++ XIOS/trunk/src/node/grid.cpp	(revision 2131)
@@ -39,4 +39,7 @@
       , computedWrittenIndex_(false)
       , clients()
+      , nTiles_(0)
+      , isTiled_(false), isTiledOnly_(false)
+      , storeTileIndex()
    {
      setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group"));
@@ -60,4 +63,7 @@
       , computedWrittenIndex_(false)
       , clients()
+      , nTiles_(0)
+      , isTiled_(false), isTiledOnly_(false)
+      , storeTileIndex()
    {
      setVirtualDomainGroup(CDomainGroup::create(getId() + "_virtual_domain_group"));
@@ -102,4 +108,74 @@
    }
    CATCH
+
+   //---------------------------------------------------------------
+   /*!
+    * Returns size of tile data
+    */
+
+   StdSize CGrid::getTileDataSize(int tileId)
+   TRY
+   {
+     StdSize tileGridSize =1 ;
+     int numElement = axis_domain_order.numElements();
+
+     std::vector<CAxis*> axisListP = this->getAxis();
+     std::vector<CDomain*> domainListP = this->getDomains();
+
+     int axisIndex = 0, domIndex = 0;
+     for (int idx = 0; idx < numElement; ++idx)
+     {
+       int eleDim = axis_domain_order(idx);
+       if (2 == eleDim)
+       {
+         tileGridSize *= domainListP[domIndex]->tile_data_ni(tileId);
+         tileGridSize *= domainListP[domIndex]->tile_data_nj(tileId);
+         ++domIndex;
+          }
+       else if (1 == eleDim)
+       {
+         tileGridSize *= axisListP[axisIndex]->n.getValue();
+         ++axisIndex;
+       }
+     } // loop over grid elements
+     return tileGridSize;
+   }
+   CATCH
+
+   //---------------------------------------------------------------
+   /*!
+    * Returns tile size
+    */
+
+   StdSize CGrid::getTileSize(int tileId)
+   TRY
+   {
+     StdSize tileGridSize =1 ;
+     int numElement = axis_domain_order.numElements();
+
+     std::vector<CAxis*> axisListP = this->getAxis();
+     std::vector<CDomain*> domainListP = this->getDomains();
+
+     int axisIndex = 0, domIndex = 0;
+     for (int idx = 0; idx < numElement; ++idx)
+     {
+       int eleDim = axis_domain_order(idx);
+       if (2 == eleDim)
+       {
+         tileGridSize *= domainListP[domIndex]->tile_ni(tileId);
+         tileGridSize *= domainListP[domIndex]->tile_nj(tileId);
+         ++domIndex;
+          }
+       else if (1 == eleDim)// So it's an axis
+       {
+         tileGridSize *= axisListP[axisIndex]->n.getValue();
+         ++axisIndex;
+       }
+     } // loop over grid elements
+     return tileGridSize;
+   }
+   CATCH
+
+   //---------------------------------------------------------------
 
    /*!
@@ -561,4 +637,6 @@
           if (sendAtt) domListP[i]->sendCheckedAttributes();
           else domListP[i]->checkAttributesOnClient();
+          if (domListP[i]->isTiled()) this->isTiled_ = true;
+          if (domListP[i]->isTiledOnly()) this->isTiledOnly_ = true;
         }
       }
@@ -725,4 +803,76 @@
           outLocalIndexStoreOnClient.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements())));
           CArray<size_t,1>& localIndex = outLocalIndexStoreOnClient[rank];
+          size_t nbIndex = 0;
+
+          // Keep this code for this moment but it should be removed (or moved to DEBUG) to improve performance
+          for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
+          {
+            if (itGloe != globalDataIndex.find(globalIndex(idx)))
+            {
+              ++nbIndex;
+            }
+          }
+
+          if (doGridHaveDataDistributed(client) && (nbIndex != localIndex.numElements()))
+               ERROR("void CGrid::computeClientIndex()",
+                  << "Number of local index on client is different from number of received global index"
+                  << "Rank of sent client " << rank <<"."
+                  << "Number of local index " << nbIndex << ". "
+                  << "Number of received global index " << localIndex.numElements() << ".");
+
+          nbIndex = 0;
+          for (size_t idx = 0; idx < globalIndex.numElements(); ++idx)
+          {
+            if (itGloe != globalDataIndex.find(globalIndex(idx)))
+            {
+              localIndex(idx) = globalDataIndex[globalIndex(idx)];
+            }
+          }
+        }
+      }
+   }
+   CATCH_DUMP_ATTR
+
+   //---------------------------------------------------------------
+
+   /*
+     Compute the global index and its local index taking account mask and data index.
+     These global indexes will be used to compute the connection of this client (sender) to its servers (receivers)
+     (via function computeConnectedClient)
+     These global indexes also correspond to data sent to servers (if any)
+   */
+   void CGrid::computeClientIndexTiled()
+   TRY
+   {
+     CContext* context = CContext::getCurrent();
+
+     CContextClient* client = context->client;
+     int rank = client->clientRank;
+
+     clientDistributionTiled_ = new CDistributionClient(rank, this, true);
+     // Get local data index on client
+     int nbStoreIndex = clientDistributionTiled_->getLocalDataIndexOnClient().size();
+     int nbStoreGridMask = clientDistributionTiled_->getLocalMaskIndexOnClient().size();
+     // nbStoreGridMask = nbStoreIndex if grid mask is defined, and 0 otherwise
+     storeIndexTiled_client.resize(nbStoreIndex);
+     storeMaskTiled_client.resize(nbStoreGridMask);
+     for (int idx = 0; idx < nbStoreIndex; ++idx) storeIndexTiled_client(idx) = (clientDistributionTiled_->getLocalDataIndexOnClient())[idx];
+     for (int idx = 0; idx < nbStoreGridMask; ++idx) storeMaskTiled_client(idx) = (clientDistributionTiled_->getLocalMaskIndexOnClient())[idx];
+
+     if (0 == serverDistribution_) isDataDistributed_= clientDistributionTiled_->isDataDistributed();
+     else
+     {
+        // Mapping global index received from clients to the storeIndex_client
+        CDistributionClient::GlobalLocalDataMap& globalDataIndex = clientDistributionTiled_->getGlobalDataIndexOnClient();
+        CDistributionClient::GlobalLocalDataMap::const_iterator itGloe = globalDataIndex.end();
+        map<int, CArray<size_t, 1> >::iterator itb = outGlobalIndexFromClientTiled.begin(),
+                                               ite = outGlobalIndexFromClientTiled.end(), it;
+
+        for (it = itb; it != ite; ++it)
+        {
+          int rank = it->first;
+          CArray<size_t,1>& globalIndex = outGlobalIndexFromClientTiled[rank];
+          outLocalIndexStoreOnClientTiled.insert(make_pair(rank, CArray<size_t,1>(globalIndex.numElements())));
+          CArray<size_t,1>& localIndex = outLocalIndexStoreOnClientTiled[rank];
           size_t nbIndex = 0;
 
@@ -901,5 +1051,14 @@
      else
      {
-       computeClientIndex();
+       if (this->isTiled_)
+       {
+         computeClientIndexTiled();
+         if (!this->isTiledOnly_)
+           computeClientIndex();
+       }
+       else
+         computeClientIndex();
+
+       if (this->isTiled_) computeTileIndex();
        if (context->hasClient)
        {
@@ -1097,4 +1256,111 @@
    }
    CATCH_DUMP_ATTR
+
+   //---------------------------------------------------------------
+
+   /*
+   */
+   void CGrid::computeTileIndex()
+   TRY
+   {
+     int numElement = axis_domain_order.numElements();
+     storeTileIndex.resize(nTiles_);
+
+     std::vector<CAxis*> axisListP = this->getAxis();
+     std::vector<CDomain*> domainListP = this->getDomains();
+
+     // First, allocate storeTileIndex[0..ntiles]
+     for (int iTile = 0; iTile < nTiles_; ++iTile)
+     {
+       int tileGridSize = 1;
+       int axisIndex = 0, domIndex = 0;
+       for (int idx = 0; idx < numElement; ++idx)
+       {
+         int eleDim = axis_domain_order(idx);
+         if (2 == eleDim)
+         {
+           tileGridSize *= domainListP[domIndex]->getTileDataISize(iTile);
+           tileGridSize *= domainListP[domIndex]->getTileDataJSize(iTile);
+           ++domIndex;
+         }
+         else if (1 == eleDim)// So it's an axis
+         {
+           tileGridSize *= axisListP[axisIndex]->n.getValue();
+           ++axisIndex;
+         }
+       } // loop over grid elements
+       storeTileIndex[iTile].resize(tileGridSize);
+       storeTileIndex[iTile] = -1;
+     } // loop over tiles
+
+     // Now fill in storeTileIndex
+     // Currently assuming two possible situations : (1) domain x axis or (2) domain
+     std::vector<int> tileIndexCount (nTiles_,0);
+     int axisSize = 1;
+     if (axisListP.size() != 0) axisSize = axisListP[0]->n.getValue();
+     int ni = domainListP[0]->ni.getValue();
+     int nj = domainListP[0]->nj.getValue();
+
+     for (int idxAxis = 0; idxAxis < axisSize; ++idxAxis)
+     {
+       for (int jIdxDom = 0; jIdxDom < nj; ++jIdxDom)
+       {
+         for (int iIdxDom = 0; iIdxDom < ni; ++iIdxDom)
+         {
+           int tile = domainListP[0]->getTileId(iIdxDom, jIdxDom);
+           int tileOffset =  domainListP[0]->tile_data_ibegin(tile);  // only sign of offset matters
+
+           // case 1: data size corresponds to tile size
+           if (tileOffset == 0)
+           {
+             storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom * ni + iIdxDom;
+             ++tileIndexCount[tile];
+           }
+           // case 2: masked data
+           else if (tileOffset > 0)
+           {
+             int iBegin = domainListP[0]->tile_ibegin(tile) + domainListP[0]->tile_data_ibegin(tile); // tile data relative to domain
+             int jBegin = domainListP[0]->tile_jbegin(tile) + domainListP[0]->tile_data_jbegin(tile); // tile data relative to domain
+             int iEnd = iBegin + domainListP[0]->tile_data_ni(tile);
+             int jEnd = jBegin + domainListP[0]->tile_data_nj(tile);
+             if ((jIdxDom >= jBegin) && (jIdxDom < jEnd) && (iIdxDom >= iBegin) && (iIdxDom < iEnd))
+             {
+               storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom * ni + iIdxDom;
+             }
+             ++tileIndexCount[tile];
+           }
+           // case 3: ghost zones
+           else
+           {
+             int tileDataNi = domainListP[0]->tile_data_ni(tile);
+             int tileDataNj = domainListP[0]->tile_data_nj(tile);
+             int tileDomSize = tileDataNi * tileDataNj;
+             int tileNi = domainListP[0]->tile_ni(tile);
+             int iBegin = domainListP[0]->tile_data_ibegin(tile);
+             int jBegin = domainListP[0]->tile_data_jbegin(tile);
+
+             // add the ghost zone at the beginning of a domain tile
+             if (tileIndexCount[tile] % tileDomSize == 0)
+               tileIndexCount[tile] += (abs(jBegin)*tileDataNi + abs(iBegin));
+
+             storeTileIndex[tile](tileIndexCount[tile]) = idxAxis*nj*ni + jIdxDom*ni + iIdxDom;
+             
+             // add two ghost zones at the right end of a tile
+             if ( (iIdxDom+1) % tileNi == 0 )
+               tileIndexCount[tile] += (2*abs(iBegin));
+
+             // add ghost zone at the end of a domain tile
+             if ((tileIndexCount[tile] + abs(jBegin)*tileDataNi-abs(iBegin) + 1) % tileDomSize == 0)
+               tileIndexCount[tile] += (abs(jBegin)*tileDataNi -abs(iBegin));
+
+             ++tileIndexCount[tile];
+           }
+         } // loop over domain first dimension
+       } // loop over domain second dimension
+     } // loop over axis dimension
+
+   }
+   CATCH_DUMP_ATTR
+
 //----------------------------------------------------------------
 
@@ -1358,15 +1624,55 @@
    CATCH
 
-   void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored) const
-   {
-      const StdSize size = storeIndex_client.numElements();
+   void CGrid::maskField_arr(const double* const data, CArray<double, 1>& stored, bool isTiled) const
+   TRY
+   {
+      const CArray<int, 1>& storeIndex_clientP = isTiled ? storeIndexTiled_client : storeIndex_client;
+      const CArray<bool, 1>& storeMask_clientP = isTiled ? storeMaskTiled_client : storeMask_client;
+      const StdSize size = storeIndex_clientP.numElements();
       stored.resize(size);
       const double nanValue = std::numeric_limits<double>::quiet_NaN();
 
-      if (storeMask_client.numElements() != 0)
-        for(StdSize i = 0; i < size; i++) stored(i) = (storeMask_client(i)) ? data[storeIndex_client(i)] : nanValue;
+      if (storeMask_clientP.numElements() != 0)
+        for(StdSize i = 0; i < size; i++) stored(i) = (storeMask_clientP(i)) ? data[storeIndex_clientP(i)] : nanValue;
       else
-        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)];
-   }
+        for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_clientP(i)];
+   }
+   CATCH
+
+   void CGrid::copyTile_arr(const double* const tileData, CArray<double, 1>& stored, int tileId)
+   TRY
+   {
+     StdSize tileSize = this->getTileSize(tileId);
+     const StdSize tileDataSize = this->getTileDataSize(tileId);
+
+     // case 1: data correspond in size to a tile
+     if (tileSize == tileDataSize)
+     {
+       for(StdSize i = 0; i < tileDataSize; i++)
+         stored(storeTileIndex[tileId](i)) = tileData[i];
+     }
+     // case 2: masked data
+     else if (tileSize > tileDataSize)
+     {
+       int tileDataCount = 0;
+       for(StdSize i = 0; i < tileSize; i++)
+         if (storeTileIndex[tileId](i) >= 0)
+         {
+           stored(storeTileIndex[tileId](i)) = tileData[tileDataCount];
+           ++tileDataCount;
+         }
+     }
+     // case 3: ghost zones
+     else
+     {
+       for(StdSize i = 0; i < tileDataSize; i++)
+         if (storeTileIndex[tileId](i) >= 0)
+         {
+           stored(storeTileIndex[tileId](i)) = tileData[i];
+         }
+
+     }
+   }
+   CATCH
 
    void CGrid::uncompressField_arr(const double* const data, CArray<double, 1>& out) const
@@ -2253,4 +2559,5 @@
         pDom->solveRefInheritance(apply);
         pDom->solveInheritanceTransformation();
+        if (!pDom->ntiles.isEmpty() && pDom->ntiles.getValue()>0) nTiles_=pDom->ntiles.getValue();
       }
     }
@@ -2281,4 +2588,25 @@
   }
   CATCH_DUMP_ATTR
+
+  int CGrid::getNTiles()
+  TRY
+  {
+    return nTiles_;
+  }
+  CATCH_DUMP_ATTR
+
+  bool CGrid::isTiled(void) const
+  TRY
+  {
+     return isTiled_;
+  }
+  CATCH
+
+  bool CGrid::isTiledOnly(void) const
+  TRY
+  {
+     return isTiledOnly_;
+  }
+  CATCH
 
   bool CGrid::isTransformed()
Index: XIOS/trunk/src/node/grid.hpp
===================================================================
--- XIOS/trunk/src/node/grid.hpp	(revision 2109)
+++ XIOS/trunk/src/node/grid.hpp	(revision 2131)
@@ -91,13 +91,19 @@
          StdSize  getDataSize(void) const;
 
+         StdSize  getTileDataSize(int tileId);
+
+         StdSize  getTileSize(int tileId);
+
          /// Entrees-sorties de champs
          template <int n>
          void inputField(const CArray<double,n>& field, CArray<double,1>& stored) const;
          template <int n>
-         void maskField(const CArray<double,n>& field, CArray<double,1>& stored) const;
+         void maskField(const CArray<double,n>& field, CArray<double,1>& stored, bool isTiled = false) const;
          template <int n>
          void outputField(const CArray<double,1>& stored, CArray<double,n>& field) const;  
          template <int n>
          void uncompressField(const CArray<double,n>& data, CArray<double,1>& outData) const; 
+         template <int n>
+         void copyTile(const CArray<double,n>& tileData, CArray<double, 1>& stored, int tileId);
 
          virtual void parse(xml::CXMLNode& node);
@@ -205,5 +211,7 @@
       public:
          CArray<int, 1> storeIndex_client;
+         CArray<int, 1> storeIndexTiled_client;
          CArray<bool, 1> storeMask_client;
+         CArray<bool, 1> storeMaskTiled_client;
 
 /** Map containing indexes that will be sent in sendIndex(). */
@@ -223,4 +231,7 @@
 /** Map storing received indexes. Key = sender rank, value = index array. */
          map<int, CArray<size_t, 1> > outGlobalIndexFromClient;
+
+/** Map storing received indexes. Key = sender rank, value = index array for tiled domains */
+         map<int, CArray<size_t, 1> > outGlobalIndexFromClientTiled;
 
 // Manh Ha's comment: " A client receives global index from other clients (via recvIndex)
@@ -232,4 +243,9 @@
  *  The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData() */
          map<int, CArray<size_t, 1> > outLocalIndexStoreOnClient; 
+
+/** Map storing received data. Key = sender rank, value = data array.
+ *  The map is created in CGrid::computeClientIndex and filled upon receiving data in CField::recvUpdateData() */
+         map<int, CArray<size_t, 1> > outLocalIndexStoreOnClientTiled;
+
 
 /** Indexes calculated based on server-like distribution.
@@ -255,4 +271,8 @@
                                          const std::vector<CScalar*>& scalars,
                                          const CArray<int,1>& axisDomainOrder);
+
+         int getNTiles();
+         bool isTiled(void) const;
+         bool isTiledOnly(void) const;
 
       private:
@@ -272,5 +292,6 @@
         void restoreField_arr(const CArray<double, 1>& stored, double* const data) const;
         void uncompressField_arr(const double* const data, CArray<double, 1>& outData) const;
-        void maskField_arr(const double* const data, CArray<double, 1>& stored) const;
+        void maskField_arr(const double* const data, CArray<double, 1>& stored, bool isTiled = false) const;
+        void copyTile_arr(const double* const tileData, CArray<double, 1>& stored, int tileId);
 
         void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
@@ -299,8 +320,11 @@
 
         void computeClientIndex();
+        void computeClientIndexTiled();
         void computeConnectedClients();
         void computeClientIndexScalarGrid(); 
         void computeConnectedClientsScalarGrid(); 
 
+        void computeTileIndex();
+
       private:
 
@@ -312,4 +336,13 @@
         bool isDomainAxisChecked;
         bool isIndexSent;
+
+        int nTiles_;
+/** True if tiled data is defined on the grid */
+        bool isTiled_;
+/** True if ONLY tiled data is defined on the grid */
+        bool isTiledOnly_;
+
+/** Vector containing local domain indexes for each tile */
+        std::vector<CArray<int,1> > storeTileIndex;
 
         CDomainGroup* vDomainGroup_;
@@ -321,4 +354,8 @@
 /** Client-like distribution calculated based on the knowledge of the entire grid */
         CDistributionClient* clientDistribution_;
+
+/** Client-like distribution calculated based on the knowledge of the entire grid in case of a tiled domain */
+        CDistributionClient* clientDistributionTiled_;
+
 
 /** Server-like distribution calculated upon receiving indexes */
@@ -387,9 +424,15 @@
 
    template <int n>
-   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored) const
+   void CGrid::copyTile(const CArray<double,n>& tileData, CArray<double,1>& storedData, int tileId)
+   {
+      this->copyTile_arr(tileData.dataFirst(), storedData, tileId);
+   }
+
+   template <int n>
+   void CGrid::maskField(const CArray<double,n>& field, CArray<double,1>& stored, bool isTiled) const
    {
 //#ifdef __XIOS_DEBUG
       if (this->getDataSize() != field.numElements())
-         ERROR("void CGrid::inputField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
+         ERROR("void CGrid::maskField(const  CArray<double,n>& field, CArray<double,1>& stored) const",
                 << "[ Awaiting data of size = " << this->getDataSize() << ", "
                 << "Received data size = "      << field.numElements() << " ] "
@@ -397,5 +440,5 @@
                 << "Grid = " << this->getId())
 //#endif
-      this->maskField_arr(field.dataFirst(), stored);
+      this->maskField_arr(field.dataFirst(), stored, isTiled);
    }
 
Index: XIOS/trunk/src/test/test_tiled_domain.f90
===================================================================
--- XIOS/trunk/src/test/test_tiled_domain.f90	(revision 2131)
+++ XIOS/trunk/src/test/test_tiled_domain.f90	(revision 2131)
@@ -0,0 +1,197 @@
+PROGRAM test_tiled_domain
+
+  USE xios
+  USE mod_wait
+  IMPLICIT NONE
+  INCLUDE "mpif.h"
+  INTEGER :: rank
+  INTEGER :: size
+  INTEGER :: ierr
+
+  CHARACTER(len=*),PARAMETER :: id="client"
+  INTEGER :: comm
+  TYPE(xios_duration) :: dtime
+  CHARACTER(len=20) :: dtime_str
+  TYPE(xios_date) :: date
+  CHARACTER(len=20) :: date_str
+  CHARACTER(len=15) :: calendar_type
+  TYPE(xios_context) :: ctx_hdl
+  INTEGER,PARAMETER :: ni_glo=10!100
+  INTEGER,PARAMETER :: nj_glo=10!100
+  INTEGER,PARAMETER :: llm=5
+  DOUBLE PRECISION  :: lval(llm)=1, scalar = 5
+
+  integer, parameter :: ntiles=2
+  integer, dimension (ntiles) :: tile_ni, tile_nj, tile_ibegin, tile_jbegin
+  integer, dimension (ntiles) :: tile_data_ni, tile_data_nj, tile_data_ibegin, tile_data_jbegin  
+
+  TYPE(xios_field) :: field_hdl
+  TYPE(xios_fieldgroup) :: fieldgroup_hdl
+  TYPE(xios_file) :: file_hdl
+  LOGICAL :: ok
+
+  DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
+  DOUBLE PRECISION :: field_3d_glo(ni_glo,nj_glo,llm)
+  DOUBLE PRECISION,ALLOCATABLE :: field_3d(:,:,:)
+  DOUBLE PRECISION,ALLOCATABLE :: field_3d_tile(:,:,:)
+  INTEGER :: ni,ibegin,iend,nj,jbegin,jend
+  INTEGER :: i,j,l,ts,n
+  INTEGER :: ioffset, joffset
+
+  namelist /tile_data_def/ ioffset, joffset
+
+!!! MPI Initialization
+
+  CALL MPI_INIT(ierr)
+
+  CALL init_wait
+
+!!! XIOS Initialization (get the local communicator)
+
+  CALL xios_initialize(id,return_comm=comm)
+
+  CALL MPI_COMM_RANK(comm,rank,ierr)
+  CALL MPI_COMM_SIZE(comm,size,ierr)
+
+!!! Fill in global data array
+
+  DO l=1,llm
+    DO j=1,nj_glo
+      DO i=1,ni_glo
+        field_3d_glo(i,j,l)=(l-1)*ni_glo*nj_glo+(j-1)*ni_glo+(i-1)
+      ENDDO
+    ENDDO
+  ENDDO
+  ni=ni_glo ; ibegin=0
+
+!!! MPI domain decomposition
+
+  jbegin=0
+  DO n=0,size-1
+    nj=nj_glo/size
+    IF (n<MOD(nj_glo,size)) nj=nj+1
+    IF (n==rank) exit
+    jbegin=jbegin+nj
+  ENDDO
+
+  iend=ibegin+ni-1 ; jend=jbegin+nj-1
+
+!!! Fill in local data array
+
+  ALLOCATE(field_3d(ni,nj,llm))
+  field_3d(1:ni,1:nj,:)=field_3d_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
+
+!!! Tile domain decomposition
+  tile_ni(:)=ni
+  tile_ibegin(:)=0
+  tile_jbegin(1)=0
+  do n=0,ntiles-1
+    tile_nj(n+1)=nj/ntiles
+    if (n<MOD(nj,ntiles)) tile_nj(n+1)=tile_nj(n+1)+1
+  enddo
+
+  do n=2,ntiles
+    tile_jbegin(n)=tile_jbegin(n-1)+tile_nj(n-1)
+  enddo
+
+!!! Define tile data size
+
+  open(10,file='tile_data_def.nml')
+  read(10,nml=tile_data_def)
+  close(10)
+
+  ! Option 1: data correspond in size to a tile
+  if (ioffset == 0) then
+    tile_data_ni(:)=tile_ni(:)
+    tile_data_nj(:)=tile_nj(:)
+    tile_data_ibegin(:)=0
+    tile_data_jbegin(:)=0
+  
+  ! Option 2: masked data
+  else if (ioffset > 0) then
+    do n=1,ntiles
+      tile_data_ni(n)=tile_ni(n)-ioffset*2
+      tile_data_nj(n)=tile_nj(n)-joffset*2
+    enddo
+    tile_data_ibegin(:)=ioffset
+    tile_data_jbegin(:)=joffset
+
+  ! Option 3: data contain ghost zones
+  else
+    do n=1,ntiles
+      tile_data_ni(n)=tile_ni(n)+abs(ioffset)*2
+      tile_data_nj(n)=tile_nj(n)+abs(joffset)*2
+    enddo
+    tile_data_ibegin(:)=ioffset
+    tile_data_jbegin(:)=joffset
+  endif
+
+  CALL xios_context_initialize("test",comm)
+  CALL xios_get_handle("test",ctx_hdl)
+  CALL xios_set_current_context(ctx_hdl)
+
+  CALL xios_set_axis_attr("axis",n_glo=llm ,value=lval) ;
+  CALL xios_set_domain_attr("domain",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj,type='curvilinear')
+  CALL xios_set_domain_attr("domain",ntiles=ntiles, tile_ni=tile_ni, tile_nj=tile_nj, tile_ibegin=tile_ibegin, tile_jbegin=tile_jbegin)
+  CALL xios_set_domain_attr("domain",tile_data_ni=tile_data_ni,tile_data_nj=tile_data_nj)
+  CALL xios_set_domain_attr("domain",tile_data_ibegin=tile_data_ibegin,tile_data_jbegin=tile_data_jbegin)
+
+  dtime%second = 3600
+  CALL xios_set_timestep(dtime)
+
+  ! The calendar is created as soon as the calendar type is defined. This way
+  ! calendar operations can be used before the context definition is closed
+  dtime%timestep = 1
+  dtime = 0.5 * dtime
+  
+  CALL xios_close_context_definition()
+  PRINT *,"close context definition: ok "
+
+  DO ts=1,10
+    CALL xios_update_calendar(ts)
+
+    do n=1,ntiles
+      ALLOCATE(field_3d_tile(tile_data_ibegin(n):tile_data_ibegin(n)+tile_data_ni(n)-1,&
+                             tile_data_jbegin(n):tile_data_jbegin(n)+tile_data_nj(n)-1,llm))
+      
+      if (ioffset == 0) then
+      ! Option 1: data correspond in size to a tile 
+      field_3d_tile(:,:,:)=field_3d(tile_ibegin(n)+1:tile_ibegin(n)+1+tile_ni(n),&
+                                  tile_jbegin(n)+1:tile_jbegin(n)+1+tile_nj(n),:)
+      
+      else if (ioffset > 0) then
+      ! Option 2: masked data
+      field_3d_tile(:,:,:)=field_3d(tile_ibegin(n)+1:tile_ibegin(n)+1+tile_ni(n),&
+                                  tile_jbegin(n)+1:tile_jbegin(n)+1+tile_nj(n),:)
+
+      else
+      ! Option 3: data contain ghost zones
+      field_3d_tile(:,:,:)=2.0
+      field_3d_tile(0:tile_ni(n)-1, 0:tile_nj(n)-1,:)=&
+                    field_3d(tile_ibegin(n)+1:tile_ibegin(n)+tile_ni(n),&
+                             tile_jbegin(n)+1:tile_jbegin(n)+tile_nj(n),:)
+      end if
+
+      CALL xios_send_field("field_3d",field_3d_tile,n-1)
+      DEALLOCATE(field_3d_tile)
+    enddo
+
+    CALL wait_us(5000) ;
+  ENDDO
+
+  CALL xios_context_finalize()
+
+  DEALLOCATE(field_3d)
+
+  CALL MPI_COMM_FREE(comm, ierr)
+
+  CALL xios_finalize()
+
+  CALL MPI_FINALIZE(ierr)
+
+END PROGRAM test_tiled_domain
+
+
+
+
+
