Changeset 567

Timestamp:

03/10/15 10:49:02 (9 years ago)

Author:

mhnguyen

Message:

Implementing a grid formed by only one axis or group of axis

+) Add several new attributes to axis. From now on, each axis can be distributed on client side
+) Modify mask of grid to make it more flexible to different dimension
+) Fix some bugs relating to calculation of local data index on client
+) Clean some redundant codes

Test
+) On Curie, only test_new_features.f90
+) Test cases:

• Grid composed of: 1 domain and 1 axis, 3 axis, 1 axis
• Mode: Attached and connected
• No of client-server: 6-2(Connected), 2 (Attached)

+) All tests passed and results are correct

Location:

XIOS/trunk

Files:

• inputs/Version2/iodef.xml (modified) (4 diffs)
• src/attribute_array_decl.cpp (modified) (1 diff)
• src/client_server_mapping.cpp (modified) (3 diffs)
• src/client_server_mapping.hpp (modified) (2 diffs)
• src/config/grid_attribute.conf (modified) (1 diff)
• src/interface/c_attr/icgrid_attr.cpp (modified) (1 diff)
• src/interface/c_attr/icgridgroup_attr.cpp (modified) (1 diff)
• src/interface/fortran_attr/grid_interface_attr.F90 (modified) (1 diff)
• src/interface/fortran_attr/gridgroup_interface_attr.F90 (modified) (1 diff)
• src/interface/fortran_attr/igrid_attr.F90 (modified) (16 diffs)
• src/interface/fortran_attr/igridgroup_attr.F90 (modified) (16 diffs)
• src/node/axis.cpp (modified) (7 diffs, 1 prop)
• src/node/axis.hpp (modified) (3 diffs)
• src/node/context.cpp (modified) (9 diffs)
• src/node/distribution_client.cpp (modified) (20 diffs)
• src/node/distribution_client.hpp (modified) (5 diffs)
• src/node/distribution_server.cpp (modified) (4 diffs)
• src/node/distribution_server.hpp (modified) (2 diffs)
• src/node/field.cpp (modified) (8 diffs, 1 prop)
• src/node/field.hpp (modified) (2 diffs)
• src/node/file.cpp (modified) (3 diffs)
• src/node/grid.cpp (modified) (23 diffs)
• src/node/grid.hpp (modified) (7 diffs)
• src/output/nc4_data_output.cpp (modified) (9 diffs)
• src/test/test_new_features.f90 (modified) (6 diffs)

XIOS/trunk/inputs/Version2/iodef.xml

@@ -6 +6 @@
 
 
-   <field_definition level="1" enabled=".FALSE.">
+   <field_definition level="1" enabled=".TRUE.">
 <!--     <field id="field_A"  operation="average" freq_op="3600s" domain_ref="domain_A"  axis_ref="axis_A" />-->
      <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A" />
+     <field id="field_Axis"  operation="average" freq_op="3600s" grid_ref="grid_Axis" />
+     <field id="field_All_Axis" operation="average" freq_op="3600s" grid_ref="grid_All_Axis" />
    </field_definition>
 
@@ -16 +18 @@
         <field field_ref="field_A" />
      </file>
+     <file id="output_Axis" name="output_Axis">
+        <field field_ref="field_Axis" />
+        <field field_ref="field_All_Axis" />
+     </file>
    </file_definition>
 
 
    <axis_definition>
-     <axis id="axis_A" zoom_size="2" zoom_end="2"/>
-     <axis id="axis_B" zoom_size="2" zoom_end="3" />
+     <axis id="axis_A" />
+     <axis id="axis_B" />
+     <axis id="axis_C" zoom_size="2" zoom_end="2" />
+     <axis id="axis_D" zoom_size="2" zoom_end="3"/>
    </axis_definition>
 
@@ -32 +40 @@
        <grid id="grid_A">
          <domain domain_ref="domain_A" />
+         <axis axis_ref="axis_C" />
+       </grid>
+       <grid id="grid_Axis">
+         <axis axis_ref="axis_D" />
+       </grid>
+       <grid id="grid_All_Axis">
          <axis axis_ref="axis_A" />
-       <!--       <axis axis_ref="axis_A" />-->
-<!--       <domain id="domain_A" />-->
-<!--       <axis axis_ref="axis_B" />-->
-      <!--       <axis id="axis_A" />-->
-<!--       <axis id="axis_B" />-->
+         <axis axis_ref="axis_B" />
+         <axis axis_ref="axis_C" />
        </grid>
      </grid_group>
@@ -57 +68 @@
         <variable_group id="buffer">
             <variable id="optimal_buffer_size" type="string">performance</variable>
-            <variable id="buffer_factor_size" type="double">1.0</variable>
+            <variable id="buffer_factor_size" type="double">10.0</variable>
          </variable_group>
 

XIOS/trunk/src/attribute_array_decl.cpp

@@ -12 +12 @@
   template class CAttributeArray<bool,2> ;
   template class CAttributeArray<bool,3> ;
+//  template class CAttributeArray<bool,4> ;
+//  template class CAttributeArray<bool,5> ;
+//  template class CAttributeArray<bool,6> ;
+//  template class CAttributeArray<bool,7> ;
 }

XIOS/trunk/src/client_server_mapping.cpp

@@ -26 +26 @@
 }
 
+void CClientServerMapping::computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
+                                                     const CArray<int,1>& localIndexOnClient,
+                                                     const std::vector<CArray<size_t,1>* >& globalIndexOnServer)
+{
+  defaultComputeServerIndexMapping(globalIndexOnClient, globalIndexOnServer, &localIndexOnClient);
+}
+
 /*!
    Compute index of data which are sent to server and index global on server side
@@ -32 +39 @@
 */
 void CClientServerMapping::defaultComputeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-                                                            const std::vector<CArray<size_t,1>* >& globalIndexServer)
+                                                            const std::vector<CArray<size_t,1>* >& globalIndexServer,
+                                                            const CArray<int,1>* localIndexOnClient)
 {
   int nServer = globalIndexServer.size();
@@ -52 +60 @@
         // Just try to calculate local index server on client side
         (indexGlobalOnServer_[j]).push_back((globalIndexOnClient)(i));
-        (localIndexSend2Server_[j]).push_back(i);
+        if (0 != localIndexOnClient) (localIndexSend2Server_[j]).push_back((*localIndexOnClient)(i));
+        else
+          (localIndexSend2Server_[j]).push_back(i);
         continue;
       }

XIOS/trunk/src/client_server_mapping.hpp

@@ -33 +33 @@
                                            const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
 
+    virtual void computeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
+                                           const CArray<int,1>& localIndexOnClient,
+                                           const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
+
     std::map<int,int> computeConnectedClients(int nbServer, int nbClient,
                                               MPI_Comm& clientIntraComm,
@@ -42 +46 @@
   protected:
     void defaultComputeServerIndexMapping(const CArray<size_t,1>& globalIndexOnClient,
-                                          const std::vector<CArray<size_t,1>* >& globalIndexOnServer);
+                                          const std::vector<CArray<size_t,1>* >& globalIndexOnServer,
+                                          const CArray<int,1>* localIndexOnClient = 0);
 
   private:

XIOS/trunk/src/config/grid_attribute.conf

@@ -1 +1 @@
 DECLARE_ATTRIBUTE(StdString, name)
 DECLARE_ATTRIBUTE(StdString, description)
-//DECLARE_ATTRIBUTE(StdString, domain_ref)
-//DECLARE_ATTRIBUTE(StdString, axis_ref)
-DECLARE_ARRAY(bool, 3 , mask)
+
+DECLARE_ARRAY(bool, 1 , mask1)
+DECLARE_ARRAY(bool, 2 , mask2)
+DECLARE_ARRAY(bool, 3 , mask3)
 //DECLARE_ARRAY(bool, 4 , mask4)
 //DECLARE_ARRAY(bool, 5 , mask5)

XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp

@@ -69 +69 @@
   
   
-  void cxios_set_grid_mask(grid_Ptr grid_hdl, bool* mask, int extent1, int extent2, int extent3)
+  void cxios_set_grid_mask1(grid_Ptr grid_hdl, bool* mask1, int extent1)
   {
     CTimer::get("XIOS").resume();
-    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ;
-    grid_hdl->mask.reference(tmp.copy());
+    CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ;
+    grid_hdl->mask1.reference(tmp.copy());
      CTimer::get("XIOS").suspend();
   }
   
-  void cxios_get_grid_mask(grid_Ptr grid_hdl, bool* mask, int extent1, int extent2, int extent3)
+  void cxios_get_grid_mask1(grid_Ptr grid_hdl, bool* mask1, int extent1)
   {
     CTimer::get("XIOS").resume();
-    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ;
-    tmp=grid_hdl->mask.getInheritedValue() ;
+    CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ;
+    tmp=grid_hdl->mask1.getInheritedValue() ;
      CTimer::get("XIOS").suspend();
   }
   
-  bool cxios_is_defined_grid_mask(grid_Ptr grid_hdl )
+  bool cxios_is_defined_grid_mask1(grid_Ptr grid_hdl )
   {
      CTimer::get("XIOS").resume();
-    return grid_hdl->mask.hasInheritedValue();
+    return grid_hdl->mask1.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_grid_mask2(grid_Ptr grid_hdl, bool* mask2, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ;
+    grid_hdl->mask2.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_grid_mask2(grid_Ptr grid_hdl, bool* mask2, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ;
+    tmp=grid_hdl->mask2.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_grid_mask2(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return grid_hdl->mask2.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_grid_mask3(grid_Ptr grid_hdl, bool* mask3, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ;
+    grid_hdl->mask3.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_grid_mask3(grid_Ptr grid_hdl, bool* mask3, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ;
+    tmp=grid_hdl->mask3.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_grid_mask3(grid_Ptr grid_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return grid_hdl->mask3.hasInheritedValue();
      CTimer::get("XIOS").suspend();
   }

XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp

@@ -95 +95 @@
   
   
-  void cxios_set_gridgroup_mask(gridgroup_Ptr gridgroup_hdl, bool* mask, int extent1, int extent2, int extent3)
+  void cxios_set_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl, bool* mask1, int extent1)
   {
     CTimer::get("XIOS").resume();
-    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ;
-    gridgroup_hdl->mask.reference(tmp.copy());
+    CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ;
+    gridgroup_hdl->mask1.reference(tmp.copy());
      CTimer::get("XIOS").suspend();
   }
   
-  void cxios_get_gridgroup_mask(gridgroup_Ptr gridgroup_hdl, bool* mask, int extent1, int extent2, int extent3)
+  void cxios_get_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl, bool* mask1, int extent1)
   {
     CTimer::get("XIOS").resume();
-    CArray<bool,3> tmp(mask,shape(extent1,extent2,extent3),neverDeleteData) ;
-    tmp=gridgroup_hdl->mask.getInheritedValue() ;
+    CArray<bool,1> tmp(mask1,shape(extent1),neverDeleteData) ;
+    tmp=gridgroup_hdl->mask1.getInheritedValue() ;
      CTimer::get("XIOS").suspend();
   }
   
-  bool cxios_is_defined_gridgroup_mask(gridgroup_Ptr gridgroup_hdl )
+  bool cxios_is_defined_gridgroup_mask1(gridgroup_Ptr gridgroup_hdl )
   {
      CTimer::get("XIOS").resume();
-    return gridgroup_hdl->mask.hasInheritedValue();
+    return gridgroup_hdl->mask1.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl, bool* mask2, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ;
+    gridgroup_hdl->mask2.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl, bool* mask2, int extent1, int extent2)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,2> tmp(mask2,shape(extent1,extent2),neverDeleteData) ;
+    tmp=gridgroup_hdl->mask2.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_gridgroup_mask2(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return gridgroup_hdl->mask2.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+  }
+  
+  
+  
+  void cxios_set_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl, bool* mask3, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ;
+    gridgroup_hdl->mask3.reference(tmp.copy());
+     CTimer::get("XIOS").suspend();
+  }
+  
+  void cxios_get_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl, bool* mask3, int extent1, int extent2, int extent3)
+  {
+    CTimer::get("XIOS").resume();
+    CArray<bool,3> tmp(mask3,shape(extent1,extent2,extent3),neverDeleteData) ;
+    tmp=gridgroup_hdl->mask3.getInheritedValue() ;
+     CTimer::get("XIOS").suspend();
+  }
+  
+  bool cxios_is_defined_gridgroup_mask3(gridgroup_Ptr gridgroup_hdl )
+  {
+     CTimer::get("XIOS").resume();
+    return gridgroup_hdl->mask3.hasInheritedValue();
      CTimer::get("XIOS").suspend();
   }

XIOS/trunk/src/interface/fortran_attr/grid_interface_attr.F90

@@ -52 +52 @@
     
     
-    SUBROUTINE cxios_set_grid_mask(grid_hdl, mask, extent1, extent2, extent3) BIND(C)
+    SUBROUTINE cxios_set_grid_mask1(grid_hdl, mask1, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask1
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_grid_mask1
+    
+    SUBROUTINE cxios_get_grid_mask1(grid_hdl, mask1, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask1
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_grid_mask1
+    
+    FUNCTION cxios_is_defined_grid_mask1(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask1
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_mask1
+    
+    
+    SUBROUTINE cxios_set_grid_mask2(grid_hdl, mask2, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask2
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_grid_mask2
+    
+    SUBROUTINE cxios_get_grid_mask2(grid_hdl, mask2, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask2
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_grid_mask2
+    
+    FUNCTION cxios_is_defined_grid_mask2(grid_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask2
+      INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
+    END FUNCTION cxios_is_defined_grid_mask2
+    
+    
+    SUBROUTINE cxios_set_grid_mask3(grid_hdl, mask3, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask3
       INTEGER (kind = C_INT), VALUE  :: extent1
       INTEGER (kind = C_INT), VALUE  :: extent2
       INTEGER (kind = C_INT), VALUE  :: extent3
-    END SUBROUTINE cxios_set_grid_mask
+    END SUBROUTINE cxios_set_grid_mask3
     
-    SUBROUTINE cxios_get_grid_mask(grid_hdl, mask, extent1, extent2, extent3) BIND(C)
+    SUBROUTINE cxios_get_grid_mask3(grid_hdl, mask3, extent1, extent2, extent3) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: grid_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask3
       INTEGER (kind = C_INT), VALUE  :: extent1
       INTEGER (kind = C_INT), VALUE  :: extent2
       INTEGER (kind = C_INT), VALUE  :: extent3
-    END SUBROUTINE cxios_get_grid_mask
+    END SUBROUTINE cxios_get_grid_mask3
     
-    FUNCTION cxios_is_defined_grid_mask(grid_hdl ) BIND(C)
+    FUNCTION cxios_is_defined_grid_mask3(grid_hdl ) BIND(C)
       USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_grid_mask3
       INTEGER (kind = C_INTPTR_T), VALUE :: grid_hdl
-    END FUNCTION cxios_is_defined_grid_mask
+    END FUNCTION cxios_is_defined_grid_mask3
     
     

XIOS/trunk/src/interface/fortran_attr/gridgroup_interface_attr.F90

@@ -73 +73 @@
     
     
-    SUBROUTINE cxios_set_gridgroup_mask(gridgroup_hdl, mask, extent1, extent2, extent3) BIND(C)
+    SUBROUTINE cxios_set_gridgroup_mask1(gridgroup_hdl, mask1, extent1) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask1
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_set_gridgroup_mask1
+    
+    SUBROUTINE cxios_get_gridgroup_mask1(gridgroup_hdl, mask1, extent1) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask1
+      INTEGER (kind = C_INT), VALUE  :: extent1
+    END SUBROUTINE cxios_get_gridgroup_mask1
+    
+    FUNCTION cxios_is_defined_gridgroup_mask1(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask1
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_mask1
+    
+    
+    SUBROUTINE cxios_set_gridgroup_mask2(gridgroup_hdl, mask2, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask2
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_set_gridgroup_mask2
+    
+    SUBROUTINE cxios_get_gridgroup_mask2(gridgroup_hdl, mask2, extent1, extent2) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask2
+      INTEGER (kind = C_INT), VALUE  :: extent1
+      INTEGER (kind = C_INT), VALUE  :: extent2
+    END SUBROUTINE cxios_get_gridgroup_mask2
+    
+    FUNCTION cxios_is_defined_gridgroup_mask2(gridgroup_hdl ) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask2
+      INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
+    END FUNCTION cxios_is_defined_gridgroup_mask2
+    
+    
+    SUBROUTINE cxios_set_gridgroup_mask3(gridgroup_hdl, mask3, extent1, extent2, extent3) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask3
       INTEGER (kind = C_INT), VALUE  :: extent1
       INTEGER (kind = C_INT), VALUE  :: extent2
       INTEGER (kind = C_INT), VALUE  :: extent3
-    END SUBROUTINE cxios_set_gridgroup_mask
+    END SUBROUTINE cxios_set_gridgroup_mask3
     
-    SUBROUTINE cxios_get_gridgroup_mask(gridgroup_hdl, mask, extent1, extent2, extent3) BIND(C)
+    SUBROUTINE cxios_get_gridgroup_mask3(gridgroup_hdl, mask3, extent1, extent2, extent3) BIND(C)
       USE ISO_C_BINDING
       INTEGER (kind = C_INTPTR_T), VALUE       :: gridgroup_hdl
-      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask
+      LOGICAL (KIND=C_BOOL)     , DIMENSION(*) :: mask3
       INTEGER (kind = C_INT), VALUE  :: extent1
       INTEGER (kind = C_INT), VALUE  :: extent2
       INTEGER (kind = C_INT), VALUE  :: extent3
-    END SUBROUTINE cxios_get_gridgroup_mask
+    END SUBROUTINE cxios_get_gridgroup_mask3
     
-    FUNCTION cxios_is_defined_gridgroup_mask(gridgroup_hdl ) BIND(C)
+    FUNCTION cxios_is_defined_gridgroup_mask3(gridgroup_hdl ) BIND(C)
       USE ISO_C_BINDING
-      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_gridgroup_mask3
       INTEGER (kind = C_INTPTR_T), VALUE :: gridgroup_hdl
-    END FUNCTION cxios_is_defined_gridgroup_mask
+    END FUNCTION cxios_is_defined_gridgroup_mask3
     
     

XIOS/trunk/src/interface/fortran_attr/igrid_attr.F90

@@ -12 +12 @@
   
   SUBROUTINE xios(set_grid_attr)  &
-    ( grid_id, axisDomainOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -20 +20 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(set_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(set_grid_attr)
   
   SUBROUTINE xios(set_grid_attr_hdl)  &
-    ( grid_hdl, axisDomainOrder, description, mask, name )
+    ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -38 +42 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       
       CALL xios(set_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(set_grid_attr_hdl)
   
   SUBROUTINE xios(set_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    ( grid_hdl, axisDomainOrder_, description_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -55 +63 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2__tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3_(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3__tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       
@@ -69 +81 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1),size(mask_,2),size(mask_,3)))
-        mask__tmp=mask_
-        CALL cxios_set_grid_mask(grid_hdl%daddr, mask__tmp,size(mask_,1),size(mask_,2),size(mask_,3))
+      IF (PRESENT(mask1_)) THEN
+        ALLOCATE(mask1__tmp(size(mask1_,1)))
+        mask1__tmp=mask1_
+        CALL cxios_set_grid_mask1(grid_hdl%daddr, mask1__tmp,size(mask1_,1))
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        ALLOCATE(mask2__tmp(size(mask2_,1),size(mask2_,2)))
+        mask2__tmp=mask2_
+        CALL cxios_set_grid_mask2(grid_hdl%daddr, mask2__tmp,size(mask2_,1),size(mask2_,2))
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        ALLOCATE(mask3__tmp(size(mask3_,1),size(mask3_,2),size(mask3_,3)))
+        mask3__tmp=mask3_
+        CALL cxios_set_grid_mask3(grid_hdl%daddr, mask3__tmp,size(mask3_,1),size(mask3_,2),size(mask3_,3))
       ENDIF
       
@@ -84 +108 @@
   
   SUBROUTINE xios(get_grid_attr)  &
-    ( grid_id, axisDomainOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -92 +116 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(get_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(get_grid_attr)
   
   SUBROUTINE xios(get_grid_attr_hdl)  &
-    ( grid_hdl, axisDomainOrder, description, mask, name )
+    ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -110 +138 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder_tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       
       CALL xios(get_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(get_grid_attr_hdl)
   
   SUBROUTINE xios(get_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    ( grid_hdl, axisDomainOrder_, description_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -127 +159 @@
       LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: axisDomainOrder__tmp(:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2__tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3_(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3__tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       
@@ -141 +177 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1),size(mask_,2),size(mask_,3)))
-        CALL cxios_get_grid_mask(grid_hdl%daddr, mask__tmp,size(mask_,1),size(mask_,2),size(mask_,3))
-        mask_=mask__tmp
+      IF (PRESENT(mask1_)) THEN
+        ALLOCATE(mask1__tmp(size(mask1_,1)))
+        CALL cxios_get_grid_mask1(grid_hdl%daddr, mask1__tmp,size(mask1_,1))
+        mask1_=mask1__tmp
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        ALLOCATE(mask2__tmp(size(mask2_,1),size(mask2_,2)))
+        CALL cxios_get_grid_mask2(grid_hdl%daddr, mask2__tmp,size(mask2_,1),size(mask2_,2))
+        mask2_=mask2__tmp
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        ALLOCATE(mask3__tmp(size(mask3_,1),size(mask3_,2),size(mask3_,3)))
+        CALL cxios_get_grid_mask3(grid_hdl%daddr, mask3__tmp,size(mask3_,1),size(mask3_,2),size(mask3_,3))
+        mask3_=mask3__tmp
       ENDIF
       
@@ -156 +204 @@
   
   SUBROUTINE xios(is_defined_grid_attr)  &
-    ( grid_id, axisDomainOrder, description, mask, name )
+    ( grid_id, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -165 +213 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1
+      LOGICAL(KIND=C_BOOL) :: mask1_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2
+      LOGICAL(KIND=C_BOOL) :: mask2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3
+      LOGICAL(KIND=C_BOOL) :: mask3_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -172 +224 @@
       CALL xios(get_grid_handle)(grid_id,grid_hdl)
       CALL xios(is_defined_grid_attr_hdl_)   &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(is_defined_grid_attr)
   
   SUBROUTINE xios(is_defined_grid_attr_hdl)  &
-    ( grid_hdl, axisDomainOrder, description, mask, name )
+    ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -185 +237 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: description
       LOGICAL(KIND=C_BOOL) :: description_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1
+      LOGICAL(KIND=C_BOOL) :: mask1_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2
+      LOGICAL(KIND=C_BOOL) :: mask2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3
+      LOGICAL(KIND=C_BOOL) :: mask3_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
       
       CALL xios(is_defined_grid_attr_hdl_)  &
-      ( grid_hdl, axisDomainOrder, description, mask, name )
+      ( grid_hdl, axisDomainOrder, description, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(is_defined_grid_attr_hdl)
   
   SUBROUTINE xios(is_defined_grid_attr_hdl_)   &
-    ( grid_hdl, axisDomainOrder_, description_, mask_, name_ )
+    ( grid_hdl, axisDomainOrder_, description_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -204 +260 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: description_
       LOGICAL(KIND=C_BOOL) :: description__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
-      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1_
+      LOGICAL(KIND=C_BOOL) :: mask1__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2_
+      LOGICAL(KIND=C_BOOL) :: mask2__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3_
+      LOGICAL(KIND=C_BOOL) :: mask3__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
@@ -219 +279 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        mask__tmp=cxios_is_defined_grid_mask(grid_hdl%daddr)
-        mask_=mask__tmp
+      IF (PRESENT(mask1_)) THEN
+        mask1__tmp=cxios_is_defined_grid_mask1(grid_hdl%daddr)
+        mask1_=mask1__tmp
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        mask2__tmp=cxios_is_defined_grid_mask2(grid_hdl%daddr)
+        mask2_=mask2__tmp
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        mask3__tmp=cxios_is_defined_grid_mask3(grid_hdl%daddr)
+        mask3_=mask3__tmp
       ENDIF
       

XIOS/trunk/src/interface/fortran_attr/igridgroup_attr.F90

@@ -12 +12 @@
   
   SUBROUTINE xios(set_gridgroup_attr)  &
-    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -21 +21 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(set_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(set_gridgroup_attr)
   
   SUBROUTINE xios(set_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -40 +44 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name
       
       CALL xios(set_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(set_gridgroup_attr_hdl)
   
   SUBROUTINE xios(set_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -58 +66 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: description_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
-      LOGICAL  , OPTIONAL, INTENT(IN) :: mask_(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask1_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask2_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2__tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(IN) :: mask3_(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3__tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: name_
       
@@ -76 +88 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1),size(mask_,2),size(mask_,3)))
-        mask__tmp=mask_
-        CALL cxios_set_gridgroup_mask(gridgroup_hdl%daddr, mask__tmp,size(mask_,1),size(mask_,2),size(mask_,3))
+      IF (PRESENT(mask1_)) THEN
+        ALLOCATE(mask1__tmp(size(mask1_,1)))
+        mask1__tmp=mask1_
+        CALL cxios_set_gridgroup_mask1(gridgroup_hdl%daddr, mask1__tmp,size(mask1_,1))
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        ALLOCATE(mask2__tmp(size(mask2_,1),size(mask2_,2)))
+        mask2__tmp=mask2_
+        CALL cxios_set_gridgroup_mask2(gridgroup_hdl%daddr, mask2__tmp,size(mask2_,1),size(mask2_,2))
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        ALLOCATE(mask3__tmp(size(mask3_,1),size(mask3_,2),size(mask3_,3)))
+        mask3__tmp=mask3_
+        CALL cxios_set_gridgroup_mask3(gridgroup_hdl%daddr, mask3__tmp,size(mask3_,1),size(mask3_,2),size(mask3_,3))
       ENDIF
       
@@ -91 +115 @@
   
   SUBROUTINE xios(get_gridgroup_attr)  &
-    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -100 +124 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(get_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(get_gridgroup_attr)
   
   SUBROUTINE xios(get_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -119 +147 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask_tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1_tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2_tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3_tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name
       
       CALL xios(get_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(get_gridgroup_attr_hdl)
   
   SUBROUTINE xios(get_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -137 +169 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: description_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
-      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask_(:,:,:)
-      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask__tmp(:,:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask1_(:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask1__tmp(:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask2_(:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask2__tmp(:,:)
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: mask3_(:,:,:)
+      LOGICAL (KIND=C_BOOL) , ALLOCATABLE :: mask3__tmp(:,:,:)
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: name_
       
@@ -155 +191 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        ALLOCATE(mask__tmp(size(mask_,1),size(mask_,2),size(mask_,3)))
-        CALL cxios_get_gridgroup_mask(gridgroup_hdl%daddr, mask__tmp,size(mask_,1),size(mask_,2),size(mask_,3))
-        mask_=mask__tmp
+      IF (PRESENT(mask1_)) THEN
+        ALLOCATE(mask1__tmp(size(mask1_,1)))
+        CALL cxios_get_gridgroup_mask1(gridgroup_hdl%daddr, mask1__tmp,size(mask1_,1))
+        mask1_=mask1__tmp
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        ALLOCATE(mask2__tmp(size(mask2_,1),size(mask2_,2)))
+        CALL cxios_get_gridgroup_mask2(gridgroup_hdl%daddr, mask2__tmp,size(mask2_,1),size(mask2_,2))
+        mask2_=mask2__tmp
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        ALLOCATE(mask3__tmp(size(mask3_,1),size(mask3_,2),size(mask3_,3)))
+        CALL cxios_get_gridgroup_mask3(gridgroup_hdl%daddr, mask3__tmp,size(mask3_,1),size(mask3_,2),size(mask3_,3))
+        mask3_=mask3__tmp
       ENDIF
       
@@ -170 +218 @@
   
   SUBROUTINE xios(is_defined_gridgroup_attr)  &
-    ( gridgroup_id, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_id, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -181 +229 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1
+      LOGICAL(KIND=C_BOOL) :: mask1_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2
+      LOGICAL(KIND=C_BOOL) :: mask2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3
+      LOGICAL(KIND=C_BOOL) :: mask3_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
@@ -188 +240 @@
       CALL xios(get_gridgroup_handle)(gridgroup_id,gridgroup_hdl)
       CALL xios(is_defined_gridgroup_attr_hdl_)   &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(is_defined_gridgroup_attr)
   
   SUBROUTINE xios(is_defined_gridgroup_attr_hdl)  &
-    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+    ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
     IMPLICIT NONE
@@ -203 +255 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask
-      LOGICAL(KIND=C_BOOL) :: mask_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1
+      LOGICAL(KIND=C_BOOL) :: mask1_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2
+      LOGICAL(KIND=C_BOOL) :: mask2_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3
+      LOGICAL(KIND=C_BOOL) :: mask3_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name
       LOGICAL(KIND=C_BOOL) :: name_tmp
       
       CALL xios(is_defined_gridgroup_attr_hdl_)  &
-      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask, name )
+      ( gridgroup_hdl, axisDomainOrder, description, group_ref, mask1, mask2, mask3, name )
     
   END SUBROUTINE xios(is_defined_gridgroup_attr_hdl)
   
   SUBROUTINE xios(is_defined_gridgroup_attr_hdl_)   &
-    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask_, name_ )
+    ( gridgroup_hdl, axisDomainOrder_, description_, group_ref_, mask1_, mask2_, mask3_, name_ )
     
     IMPLICIT NONE
@@ -224 +280 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
       LOGICAL(KIND=C_BOOL) :: group_ref__tmp
-      LOGICAL, OPTIONAL, INTENT(OUT) :: mask_
-      LOGICAL(KIND=C_BOOL) :: mask__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask1_
+      LOGICAL(KIND=C_BOOL) :: mask1__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask2_
+      LOGICAL(KIND=C_BOOL) :: mask2__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: mask3_
+      LOGICAL(KIND=C_BOOL) :: mask3__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: name_
       LOGICAL(KIND=C_BOOL) :: name__tmp
@@ -244 +304 @@
       ENDIF
       
-      IF (PRESENT(mask_)) THEN
-        mask__tmp=cxios_is_defined_gridgroup_mask(gridgroup_hdl%daddr)
-        mask_=mask__tmp
+      IF (PRESENT(mask1_)) THEN
+        mask1__tmp=cxios_is_defined_gridgroup_mask1(gridgroup_hdl%daddr)
+        mask1_=mask1__tmp
+      ENDIF
+      
+      IF (PRESENT(mask2_)) THEN
+        mask2__tmp=cxios_is_defined_gridgroup_mask2(gridgroup_hdl%daddr)
+        mask2_=mask2__tmp
+      ENDIF
+      
+      IF (PRESENT(mask3_)) THEN
+        mask3__tmp=cxios_is_defined_gridgroup_mask3(gridgroup_hdl%daddr)
+        mask3_=mask3__tmp
       ENDIF
       

XIOS/trunk/src/node/axis.cpp

@@ -6 +6 @@
 #include "message.hpp"
 #include "type.hpp"
+#include "context.hpp"
+#include "context_client.hpp"
 #include "xmlioserver_spl.hpp"
 
@@ -14 +16 @@
    CAxis::CAxis(void)
       : CObjectTemplate<CAxis>()
-      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject()
+      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
    { /* Ne rien faire de plus */ }
 
    CAxis::CAxis(const StdString & id)
       : CObjectTemplate<CAxis>(id)
-      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject()
+      , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
    { /* Ne rien faire de plus */ }
 
@@ -52 +54 @@
    void CAxis::checkAttributes(void)
    {
-      if (this->isChecked) return;
       if (this->size.isEmpty())
          ERROR("CAxis::checkAttributes(void)",
@@ -76 +77 @@
       else this->ni.setValue(size);
 
-      StdSize zoom_begin,zoom_end, zoom_size;
-
-      // Maybe index begins at 0 (zero)
-      zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue();
-      zoom_end = (this->zoom_end.isEmpty()) ?  size-1 : this->zoom_end.getValue();
-      zoom_size = (this->zoom_size.isEmpty()) ?  size : this->zoom_size.getValue();
-
-      if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1;
-      if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1;
-      if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1;
-
-      if ( (zoom_begin < 0) || (zoom_begin > size-1) || (zoom_end<0) || (zoom_end>size-1) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
-        ERROR("CAxis::checkAttributes(void)",
               << "One or more attributes among <zoom_begin>, <zoom_end>, <zoom_size> of axis [ id = '" << getId() << "' , context = '" << CObjectFactory::GetCurrentContextId() << "' ] are not well specified");
-
-      this->zoom_begin.setValue(zoom_begin);
-      this->zoom_end.setValue(zoom_end);
-      this->zoom_size.setValue(zoom_size);
-
       StdSize true_size = value.numElements();
       if (size != true_size)
@@ -102 +85 @@
       this->checkData();
       this->checkMask();
-      this->isChecked = true;
+      this->checkZoom();
    }
 
@@ -122 +105 @@
         for (int i = 0; i < dn; ++i) data_index(i) = (i+1);
       }
+   }
+
+   void CAxis::checkZoom(void)
+   {
+      StdSize zoom_begin,zoom_end, zoom_size;
+
+      zoom_begin = (this->zoom_begin.isEmpty()) ?  0 : this->zoom_begin.getValue() ;
+      zoom_size  = (this->zoom_size.isEmpty()) ?  size.getValue() : this->zoom_size.getValue() ;
+      zoom_end   = (this->zoom_end.isEmpty()) ?  (size.getValue() - 1) : this->zoom_end.getValue() ;
+
+      if (this->zoom_begin.isEmpty()) zoom_begin=zoom_end-zoom_size+1 ;
+      if (this->zoom_end.isEmpty()) zoom_end=zoom_begin+zoom_size-1 ;
+      if (this->zoom_size.isEmpty()) zoom_size=zoom_end-zoom_begin+1 ;
+
+      if ( (zoom_begin < 0) || (zoom_begin > size-1) || (zoom_end<0) || (zoom_end>size-1) || (zoom_size<1) || (zoom_size>size) || (zoom_begin>zoom_end))
+        ERROR("CAxis::checkAttributes(void)",<< "One or more attribut of <zoom_begin>, <zoom_end>, <zoom_size>, are not well specified") ;
+
+      this->zoom_begin.setValue(zoom_begin) ;
+      this->zoom_end.setValue(zoom_end) ;
+      this->zoom_size.setValue(zoom_size) ;
+
+      // compute client zoom indices
+//      zoom_begin_client = ibegin_client > zoom_begin ? begin_client : zoom_begin ;
+//      zoom_end_client   = iend_client < zoom_end ? iend_client : zoom_end ;
+//      zoom_size_client  = zoom_end_client-zoom_begin_client+1 ;
+//      if (zoom_ni_client<0) zoom_ni_client=0 ;
    }
 
@@ -166 +175 @@
    }
 
+  bool CAxis::dispatchEvent(CEventServer& event)
+   {
+      if (SuperClass::dispatchEvent(event)) return true ;
+      else
+      {
+        switch(event.type)
+        {
+           case EVENT_ID_SERVER_ATTRIBUT :
+             recvServerAttribut(event) ;
+             return true ;
+             break ;
+           default :
+             ERROR("bool CContext::dispatchEvent(CEventServer& event)",
+                    <<"Unknown Event") ;
+           return false ;
+         }
+      }
+   }
+
+   void CAxis::checkAttributesOnClient(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                       CServerDistributionDescription::ServerDistributionType distType)
+   {
+     if (this->areClientAttributesChecked_) return;
+     this->checkAttributes();
+
+     CContext* context=CContext::getCurrent() ;
+     if (context->hasClient)
+     {
+       computeServerIndex(globalDim, orderPositionInGrid, distType);
+     }
+
+     this->areClientAttributesChecked_ = true;
+   }
+
+   void CAxis::computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                  CServerDistributionDescription::ServerDistributionType distType)
+   {
+     CServerDistributionDescription serverDescription(globalDim);
+
+     CContext* context=CContext::getCurrent() ;
+     CContextClient* client=context->client ;
+     int nbServer=client->serverSize ;
+     int serverRank=client->getServerLeader() ;
+
+     serverDescription.computeServerDistribution(nbServer, false, distType);
+     std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin();
+     std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes();
+     begin_srv = (serverIndexBegin[serverRank])[orderPositionInGrid];
+     ni_srv = serverDimensionSizes[serverRank][orderPositionInGrid];
+     end_srv = begin_srv+ni_srv-1;
+   }
+
+   // Send all checked attributes to server
+   void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                     CServerDistributionDescription::ServerDistributionType distType)
+   {
+     if (!this->areClientAttributesChecked_) checkAttributesOnClient(globalDim,
+                                                                     orderPositionInGrid,
+                                                                     distType);
+     CContext* context=CContext::getCurrent() ;
+
+     if (this->isChecked) return;
+     if (context->hasClient)
+     {
+       sendServerAttribut() ;
+     }
+
+     this->isChecked = true;
+   }
+
+  void CAxis::sendServerAttribut(void)
+  {
+    CContext* context=CContext::getCurrent();
+    CContextClient* client=context->client;
+
+    CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT) ;
+    if (client->isServerLeader())
+    {
+      CMessage msg ;
+      msg<<this->getId() ;
+      msg<<ni_srv<<begin_srv<<end_srv;
+      event.push(client->getServerLeader(),1,msg) ;
+      client->sendEvent(event) ;
+    }
+    else client->sendEvent(event) ;
+  }
+
+  void CAxis::recvServerAttribut(CEventServer& event)
+  {
+    CBufferIn* buffer=event.subEvents.begin()->buffer;
+    string axisId ;
+    *buffer>>axisId ;
+    get(axisId)->recvServerAttribut(*buffer) ;
+  }
+
+  void CAxis::recvServerAttribut(CBufferIn& buffer)
+  {
+    int zoom_end = zoom_begin.getValue()+zoom_size.getValue()-1;
+    int ni_srv, begin_srv, end_srv;
+
+    buffer>>ni_srv>>begin_srv>>end_srv;
+
+    zoom_begin_srv = zoom_begin.getValue() > begin_srv ? zoom_begin.getValue() : begin_srv ;
+    zoom_end_srv   = zoom_end < end_srv ? zoom_end : end_srv ;
+    zoom_size_srv  = zoom_end_srv-zoom_begin_srv+1 ;
+
+    if (zoom_size_srv<=0)
+    {
+      zoom_begin_srv=0 ; zoom_end_srv=0 ; zoom_size_srv=0 ;
+    }
+  }
+
    DEFINE_REF_FUNC(Axis,axis)
 

XIOS/trunk/src/node/axis.hpp

@@ -11 +11 @@
 #include "attribute_enum.hpp"
 #include "attribute_enum_impl.hpp"
+#include "server_distribution_description.hpp"
 
 namespace xios {
@@ -33 +34 @@
       , public CAxisAttributes
    {
+         enum EEventId
+         {
+           EVENT_ID_SERVER_ATTRIBUT
+         } ;
+
          /// typedef ///
          typedef CObjectTemplate<CAxis>   SuperClass;
@@ -66 +72 @@
          static StdString GetName(void);
          static StdString GetDefName(void);
-
          static ENodeType GetType(void);
 
+         void sendServerAttribut(void);
+         static bool dispatchEvent(CEventServer& event);
+         static void recvServerAttribut(CEventServer& event);
+         void recvServerAttribut(CBufferIn& buffer) ;
+         void checkAttributesOnClient(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                      CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
+         void sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                    CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
+      public:
+        int zoom_begin_srv, zoom_end_srv, zoom_size_srv;
+        int ni_srv, begin_srv, end_srv;
       private :
          void checkData();
          void checkMask();
+         void checkZoom();
+         void computeServerIndex(const std::vector<int>& globalDim, int orderPositionInGrid,
+                                 CServerDistributionDescription::ServerDistributionType disType);
+      private:
+
          bool isChecked;
+         bool areClientAttributesChecked_;
          std::set<StdString> relFiles;
 

XIOS/trunk/src/node/context.cpp

@@ -308 +308 @@
      if (hasClient)
      {
-//       std::cout << "Current context " << *this << std::endl;
        // After xml is parsed, there are some more works with post processing
        postProcessing();
@@ -317 +316 @@
      if (hasClient && !hasServer)
      {
-       // After xml is parsed, there are some more works with post processing
-//       postProcessing();
-
-//       setClientServerBuffer();
-
       // Send all attributes of current context to server
       this->sendAllAttributesToServer();
@@ -336 +330 @@
 
       // At last, we have all info of domain and axis, then send them
-       sendRefDomainsAxis();
+//       sendRefDomainsAxis();
 
       // After that, send all grid (if any)
        sendRefGrid();
-
-
     }
 
@@ -416 +408 @@
    }
 
-//    void CContext::processEnabledFiles(void)
-//   {
-//     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-//     this->enabledFiles[i]->processEnabledFile();
-//   }
-
-
    void CContext::solveAllRefOfEnabledFields(bool sendToServer)
    {
@@ -440 +425 @@
      }
    }
-
-//   void CContext::solveAllGridRef(void)
-//   {
-//     for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-//     this->enabledFiles[i]->solveEFGridRef();
-//   }
-//
-//   void CContext::solveAllOperation(void)
-//   {
-//      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-//      this->enabledFiles[i]->solveEFOperation();
-//   }
-//
-//   void CContext::solveAllExpression(void)
-//   {
-//      for (unsigned int i = 0; i < this->enabledFiles.size(); i++)
-//      this->enabledFiles[i]->solveEFExpression();
-//   }
 
    void CContext::solveAllInheritance(bool apply)
@@ -671 +638 @@
       CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar();
       postProcessing();
-//      std::cout << "server context " << *this << std::endl;
    }
 
@@ -719 +685 @@
    std::map<int, StdSize>& CContext::getDataSize()
    {
-     std::set<StdString> domainIds;
+     // Set of grid used by enabled fields
+     std::set<StdString> usedGrid;
 
      // Find all reference domain and axis of all active fields
@@ -729 +696 @@
        for (int j = 0; j < numEnabledFields; ++j)
        {
-         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
+//         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
+         StdString currentGrid = enabledFields[j]->grid->getId();
          const std::map<int, StdSize> mapSize = enabledFields[j]->getGridDataSize();
          if (dataSize_.empty())
          {
            dataSize_ = mapSize;
-           domainIds.insert(prDomAxisId.first);
+           usedGrid.insert(currentGrid);
+//           domainIds.insert(prDomAxisId.first);
          }
          else
          {
            std::map<int, StdSize>::const_iterator it = mapSize.begin(), itE = mapSize.end();
-           if (domainIds.find(prDomAxisId.first) == domainIds.end())
+           if (usedGrid.find(currentGrid) == usedGrid.end())
            {
              for (; it != itE; ++it)
@@ -830 +799 @@
 
    //! Client side: Send information of reference domain and axis of active fields
-   void CContext::sendRefDomainsAxis()
-   {
-     std::set<StdString> domainIds;
-     std::set<StdString> axisIds;
-
-     // Find all reference domain and axis of all active fields
-     int numEnabledFiles = this->enabledFiles.size();
-     for (int i = 0; i < numEnabledFiles; ++i)
-     {
-       std::vector<CField*> enabledFields = this->enabledFiles[i]->getEnabledFields();
-       int numEnabledFields = enabledFields.size();
-       for (int j = 0; j < numEnabledFields; ++j)
-       {
-         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
-         domainIds.insert(prDomAxisId.first);
-         axisIds.insert(prDomAxisId.second);
-       }
-     }
-
-     // Create all reference axis on server side
-     std::set<StdString>::iterator itDom, itAxis;
-     std::set<StdString>::const_iterator itE;
-
-     StdString axiDefRoot("axis_definition");
-     CAxisGroup* axisPtr = CAxisGroup::get(axiDefRoot);
-     itE = axisIds.end();
-     for (itAxis = axisIds.begin(); itAxis != itE; ++itAxis)
-     {
-       if (!itAxis->empty())
-       {
-         axisPtr->sendCreateChild(*itAxis);
-         CAxis::get(*itAxis)->sendAllAttributesToServer();
-       }
-     }
-
-     // Create all reference domains on server side
-     StdString domDefRoot("domain_definition");
-     CDomainGroup* domPtr = CDomainGroup::get(domDefRoot);
-     itE = domainIds.end();
-     for (itDom = domainIds.begin(); itDom != itE; ++itDom)
-     {
-       if (!itDom->empty()) {
-          domPtr->sendCreateChild(*itDom);
-          CDomain::get(*itDom)->sendAllAttributesToServer();
-       }
-     }
-   }
+//   void CContext::sendRefDomainsAxis()
+//   {
+//     std::set<StdString> domainIds;
+//     std::set<StdString> axisIds;
+//
+//     // Find all reference domain and axis of all active fields
+//     int numEnabledFiles = this->enabledFiles.size();
+//     for (int i = 0; i < numEnabledFiles; ++i)
+//     {
+//       std::vector<CField*> enabledFields = this->enabledFiles[i]->getEnabledFields();
+//       int numEnabledFields = enabledFields.size();
+//       for (int j = 0; j < numEnabledFields; ++j)
+//       {
+//         const std::pair<StdString, StdString>& prDomAxisId = enabledFields[j]->getDomainAxisIds();
+//         domainIds.insert(prDomAxisId.first);
+//         axisIds.insert(prDomAxisId.second);
+//       }
+//     }
+//
+//     // Create all reference axis on server side
+//     std::set<StdString>::iterator itDom, itAxis;
+//     std::set<StdString>::const_iterator itE;
+//
+//     StdString axiDefRoot("axis_definition");
+//     CAxisGroup* axisPtr = CAxisGroup::get(axiDefRoot);
+//     itE = axisIds.end();
+//     for (itAxis = axisIds.begin(); itAxis != itE; ++itAxis)
+//     {
+//       if (!itAxis->empty())
+//       {
+//         axisPtr->sendCreateChild(*itAxis);
+//         CAxis::get(*itAxis)->sendAllAttributesToServer();
+//       }
+//     }
+//
+//     // Create all reference domains on server side
+//     StdString domDefRoot("domain_definition");
+//     CDomainGroup* domPtr = CDomainGroup::get(domDefRoot);
+//     itE = domainIds.end();
+//     for (itDom = domainIds.begin(); itDom != itE; ++itDom)
+//     {
+//       if (!itDom->empty()) {
+//          domPtr->sendCreateChild(*itDom);
+//          CDomain::get(*itDom)->sendAllAttributesToServer();
+//       }
+//     }
+//   }
 
    //! Update calendar in each time step

XIOS/trunk/src/node/distribution_client.cpp

@@ -16 +16 @@
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
-   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
+   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_(),
+   isDataDistributed_(true), axisNum_(0), domainNum_(0), localDataIndexSendToServer_(0)
 {
 }
@@ -25 +26 @@
    nLocal_(), nGlob_(), nBeginLocal_(), nBeginGlobal_(),nZoomBegin_(), nZoomEnd_(),
    dataNIndex_(), dataDims_(), dataBegin_(), dataIndex_(), domainMasks_(), axisMasks_(),
-   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_()
+   gridMask_(), localDomainIndex_(), localAxisIndex_(), indexMap_(), indexDomainData_(), indexAxisData_(),
+   isDataDistributed_(true), axisNum_(0), domainNum_(0), localDataIndexSendToServer_(0)
 {
   readDistributionInfo(grid);
@@ -34 +36 @@
 {
   if (0 != localDataIndex_) delete localDataIndex_;
+  if (0 != localDataIndexSendToServer_) delete localDataIndexSendToServer_;
 }
 
@@ -46 +49 @@
   std::vector<CDomain*> domList = grid->getDomains();
   std::vector<CAxis*> axisList = grid->getAxis();
-  CArray<bool,1>& axisDomainOrder = grid->axisDomainOrder;
+  CArray<bool,1> axisDomainOrder = grid->axisDomainOrder;
 
   std::vector<CDomain*>::iterator itbDom, iteDom, itDom;
@@ -55 +58 @@
 
   // First of all, every attribute of domain and axis should be checked
-  for (;itDom != iteDom; ++itDom) (*itDom)->checkAttributesOnClient();
-  for (;itAxis != iteAxis; ++itAxis) (*itAxis)->checkAttributes();
+//  for (;itDom != iteDom; ++itDom) (*itDom)->checkAttributesOnClient();
+//  for (;itAxis != iteAxis; ++itAxis) (*itAxis)->checkAttributesOnClient();
+
+  readDistributionInfo(domList, axisList, axisDomainOrder);
 
   // Then check mask of grid
+  int gridDim = domList.size()*2 + axisList.size();
   grid->checkMask();
-  CArray<bool,3>& gridMask = grid->mask;
-
-  ////////////////////////////////////////////////////////
-
-  int gridDim = domList.size()*2 + axisList.size();
-
-  // For now, just suppose that gridMask is all true, but we need to cope with this problem
-  //  std::vector<std::vector<bool> > gridMask(gridDim);
-//  int idxDomain = 0, idxAxis = 0;
-//  for (int i = 0; i < axisDomainOrder.size(); ++i)
-//  {
-//    if (axisDomainOrder(i))
-//    {
-//      gridMask[idxDomain*2+i].resize(domList[idxDomain]->ni);
-//      gridMask[idxDomain*2+i+1].resize(domList[idxDomain]->nj);
-//      ++idxDomain;
-//    }
-//    else
-//    {
-//      gridMask[i].resize(axisList[idxAxis]->ni);
-//      ++idxAxis;
-//    }
-//  }
-
-  readDistributionInfo(domList, axisList, axisDomainOrder, gridMask);
+  switch (gridDim) {
+    case 1:
+      readGridMaskInfo(grid->mask1);
+      break;
+    case 2:
+      readGridMaskInfo(grid->mask2);
+      break;
+    case 3:
+      readGridMaskInfo(grid->mask3);
+      break;
+    default:
+      break;
+  }
 }
 
@@ -96 +90 @@
   \param [in] axisList List of axis of grid
   \param [in] axisDomainOrder order of axis and domain inside a grid. True if domain, false if axis
-  \param [in] gridMask Mask of grid, for now, keep it 3 dimension, but it needs changing
+//  \param [in] gridMask Mask of grid, for now, keep it 3 dimension, but it needs changing
 */
 void CDistributionClient::readDistributionInfo(const std::vector<CDomain*>& domList,
                                                const std::vector<CAxis*>& axisList,
-                                               const CArray<bool,1>& axisDomainOrder,
-                                               const CArray<bool,3>& gridMask)
-{
+                                               const CArray<bool,1>& axisDomainOrder)
+{
+  domainNum_ = domList.size();
+  axisNum_   = axisList.size();
   numElement_ = axisDomainOrder.numElements(); // Number of element, e.x: Axis, Domain
 
@@ -109 +104 @@
 
   // Each domain or axis has its mask, of course
-  domainMasks_.resize(domList.size());
-  for (int i = 0; i < domainMasks_.size();++i)
+  domainMasks_.resize(domainNum_);
+  for (int i = 0; i < domainNum_;++i)
   {
     domainMasks_[i].resize(domList[i]->mask.extent(0), domList[i]->mask.extent(1));
@@ -116 +111 @@
   }
 
-  axisMasks_.resize(axisList.size());
-  for (int i = 0; i < axisMasks_.size(); ++i)
+  axisMasks_.resize(axisNum_);
+  for (int i = 0; i < axisNum_; ++i)
   {
     axisMasks_[i].resize(axisList[i]->mask.numElements());
     axisMasks_[i] = axisList[i]->mask;
   }
-
-  gridMask_.resize(gridMask.extent(0), gridMask.extent(1), gridMask.extent(2));
-  gridMask_ = gridMask;
 
   // Because domain and axis can be in any order (axis1, domain1, axis2, axis3, )
@@ -139 +131 @@
       idx += 2;
     }
+    else ++idx;
   }
 
@@ -215 +208 @@
     ++idx;
   }
+
+  // Grid has only one axis and it is not distributed
+  bool isDataNotDistributed = true;
+  for (int i = 0; i < this->dims_; ++i)
+    isDataNotDistributed &= (nLocal_[i] == nGlob_[i]);
+  isDataDistributed_ = !isDataNotDistributed;
 }
 
@@ -343 +342 @@
 
     // Find out outer index
+    // Depending the inner-most element is axis or domain,
+    // The outer loop index begins correspondingly at one (1) or zero (0)
     idxDomain = idxAxis = 0;
+    if (axisDomainOrder_(0)) ++idxDomain;
+    else ++idxAxis;
     for (int i = 1; i < numElement_; ++i)
     {
@@ -359 +362 @@
     }
 
+    int maskIndex = currentIndex[0];
+    for (int j = 0; j < this->dims_; ++j)
+
     // Inner most index
     idxDomain = idxAxis = 0;
@@ -370 +376 @@
       else currentIndex[0]   = localAxisIndex_[idxAxis][i];
 
-      if (gridMask_(currentIndex[0], currentIndex[1], currentIndex[2]))
+      int gridMaskIndex = currentIndex[0];
+      int mulDimMask = 1;
+      for (int k = 1; k < this->dims_; ++k)
+      {
+        mulDimMask *= nLocal_[k-1];
+        gridMaskIndex += (currentIndex[k])*mulDimMask;
+      }
+
+      if (gridMask_(gridMaskIndex)) //(gridMask_(currentIndex[0], currentIndex[1], currentIndex[2]))
       {
         ++indexLocalDataOnClientCount;
@@ -389 +403 @@
   this->globalIndex_ = new CArray<size_t,1>(indexSend2ServerCount);
   localDataIndex_ = new CArray<int,1>(indexLocalDataOnClientCount);
+  localDataIndexSendToServer_ = new CArray<int,1>(indexSend2ServerCount);
 
   // We need to loop with data index
-  innerLoopSize = dataNIndex_[0];
-  ssize = 1; for (int i = 0; i < numElement_; ++i) ssize *= dataNIndex_[i];
   idxLoop.assign(numElement_,0);
   idx = indexLocalDataOnClientCount = indexSend2ServerCount = 0;
-  int count = 0, correctOuterIndexDomain = 0, correctOuterIndexAxis = 0;
+  ssize = 1; for (int i = 0; i < numElement_; ++i) ssize *= dataNIndex_[i];
+  innerLoopSize = dataNIndex_[0];
+  int countLocalData = 0;
+  std::vector<int> correctOuterIndex(numElement_,0);
   while (idx < ssize)
   {
@@ -403 +419 @@
       {
         idxLoop[i] = 0;
+        correctOuterIndex[i] = 0;
         ++idxLoop[i+1];
-      }
-    }
-
-    // Outer index
+        ++correctOuterIndex[i+1];
+      }
+    }
+
+    // Depending the inner-most element axis or domain,
+    // The outer loop index begins correspondingly at one (1) or zero (0)
     idxDomain = idxAxis = 0;
-    bool isIndexDomainDataCorrect = false;
-    bool isIndexAxisDataCorrect = false;
+    if (axisDomainOrder_(0)) ++idxDomain;
+    else ++idxAxis;
+    bool isIndexDomainDataCorrect = true;
+    bool isIndexAxisDataCorrect = true;
 
     for (int i = 1; i < numElement_; ++i)
@@ -418 +439 @@
         if (indexDomainData_[idxDomain][idxLoop[i]])
         {
-          currentIndex[indexMap_[i]]   = localDomainIndex_[idxDomain][correctOuterIndexDomain];
-          currentIndex[indexMap_[i]+1] = localDomainIndex_[idxDomain*2+1][correctOuterIndexDomain];
-          isIndexDomainDataCorrect = true;
-          ++correctOuterIndexDomain;
-        }
+          currentIndex[indexMap_[i]]   = localDomainIndex_[idxDomain][correctOuterIndex[i]];
+          currentIndex[indexMap_[i]+1] = localDomainIndex_[idxDomain*2+1][correctOuterIndex[i]];
+        }
+        else isIndexDomainDataCorrect = false;
         ++idxDomain;
       }
@@ -429 +449 @@
         if (indexAxisData_[idxAxis][idxLoop[i]])
         {
-          currentIndex[indexMap_[i]]   = localAxisIndex_[idxAxis][correctOuterIndexAxis];
-          isIndexAxisDataCorrect = true;
-          ++correctOuterIndexAxis;
-        }
+          currentIndex[indexMap_[i]]   = localAxisIndex_[idxAxis][correctOuterIndex[i]];
+        }
+        else isIndexAxisDataCorrect = false;
         ++idxAxis;
       }
@@ -464 +483 @@
       }
 
+      int gridMaskIndex = currentIndex[0];
+      int mulDimMask = 1;
+      for (int k = 1; k < this->dims_; ++k)
+      {
+        mulDimMask *= nLocal_[k-1];
+        gridMaskIndex += (currentIndex[k])*mulDimMask;
+      }
+
       if (isIndexDomainDataCorrect &&
           isIndexAxisDataCorrect &&
-          gridMask_(currentIndex[0], currentIndex[1], currentIndex[2]))
-      {
-        (*localDataIndex_)(indexLocalDataOnClientCount) = count;
-        ++indexLocalDataOnClientCount;
+          gridMask_(gridMaskIndex))
+      {
+        (*localDataIndex_)(indexLocalDataOnClientCount) = countLocalData;
 
         bool isIndexOnServer = true;
@@ -486 +512 @@
           }
           (*this->globalIndex_)(indexSend2ServerCount) = globalIndex;
+          (*localDataIndexSendToServer_)(indexSend2ServerCount) = indexLocalDataOnClientCount;
           ++indexSend2ServerCount;
         }
-      }
-      ++count;
+        ++indexLocalDataOnClientCount;
+      }
+      ++countLocalData;
     }
     idxLoop[0] += innerLoopSize;
@@ -546 +574 @@
 }
 
+const CArray<int,1>& CDistributionClient::getLocalDataIndexSendToServerOnClient() const
+{
+  return (*localDataIndexSendToServer_);
+}
+
 } // namespace xios

XIOS/trunk/src/node/distribution_client.hpp

@@ -37 +37 @@
 
     virtual const CArray<int,1>& getLocalDataIndexOnClient() const;
+    virtual const CArray<int,1>& getLocalDataIndexSendToServerOnClient() const;
+
     std::vector<int> getNGlob() { return nGlob_; }
+    std::vector<int> getDataNIndex() { return dataNIndex_; }
+    bool isDataDistributed() { return isDataDistributed_; }
 
   protected:
@@ -44 +48 @@
     void readDistributionInfo(const std::vector<CDomain*>& domList,
                               const std::vector<CAxis*>& axisList,
-                              const CArray<bool,1>& axisDomainOrder,
-                              const CArray<bool,3>& gridMask);
-
+                              const CArray<bool,1>& axisDomainOrder);
   private:
     //! Create local index of a domain
@@ -59 +61 @@
     inline int getAxisIndex(const int& dataIndex, const int& dataBegin, const int& ni);
 
+    template<int N>
+    void readGridMaskInfo(const CArray<bool,N>& gridMask);
+
   private:
     //!< LocalData index on client
     CArray<int,1>* localDataIndex_;
+    CArray<int,1>* localDataIndexSendToServer_;
 
   private:
@@ -85 +91 @@
     std::vector<CArray<bool,1> > axisMasks_; //!< Axis mask
 
-    // Just suppose that grid mask has 3 dimension. Need change
-    CArray<bool,3> gridMask_; // TODO: more general grid mask
-
     std::vector<std::vector<int> > localDomainIndex_;
     std::vector<std::vector<int> > localAxisIndex_;
@@ -96 +99 @@
     std::vector<std::vector<bool> > indexAxisData_;
 
+    //!< (Only for grid with one axis or scalar)Flag to determine whether data is distributed or not
+    bool isDataDistributed_;
+    int axisNum_;
+    int domainNum_;
+
+  private:
+    // Just suppose that grid mask has 3 dimension. Need change
+    CArray<bool,1> gridMask_; //!< Mask of grid
+
   private:
     CDistributionClient(const CDistributionClient& distClient); //! Not implement
 };
 
+template<int N>
+void CDistributionClient::readGridMaskInfo(const CArray<bool,N>& gridMask)
+{
+  int dim = gridMask.dimensions();
+  std::vector<int> dimensionSizes(dim);
+  for (int i = 0; i < dim; ++i) dimensionSizes[i] = gridMask.extent(i);
+
+  std::vector<int> idxLoop(dim,0);
+  int ssize = gridMask.numElements(), idx = 0;
+  gridMask_.resize(ssize);
+  while (idx < ssize)
+  {
+    for (int i = 0; i < dim-1; ++i)
+    {
+      if (idxLoop[i] == dimensionSizes[i])
+      {
+        idxLoop[i] = 0;
+        ++idxLoop[i+1];
+      }
+    }
+
+    int maskIndex = idxLoop[0];
+    int mulDim = 1;
+    for (int k = 1; k < dim; ++k)
+    {
+      mulDim *= dimensionSizes[k-1];
+      maskIndex += idxLoop[k]*mulDim;
+    }
+    gridMask_(maskIndex) = *(gridMask.dataFirst()+maskIndex);
+
+    ++idxLoop[0];
+    ++idx;
+  }
+}
+
+
 } // namespace xios
 #endif // __XIOS_DISTRIBUTIONCLIENT_HPP__

XIOS/trunk/src/node/distribution_server.cpp

@@ -19 +19 @@
                                          const std::vector<int>& nZoomSize, const std::vector<int>& nGlobal)
   : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomSize_(nZoomSize), nZoomBegin_(nZoomBegin)
+{
+  createGlobalIndex();
+}
+
+CDistributionServer::CDistributionServer(int rank, const std::vector<int>& nZoomBegin,
+                                         const std::vector<int>& nZoomSize,
+                                         const std::vector<int>& nZoomBeginGlobal,
+                                         const std::vector<int>& nGlobal)
+  : CDistribution(rank, nGlobal.size()), nGlobal_(nGlobal), nZoomBeginGlobal_(nZoomBeginGlobal),
+    nZoomSize_(nZoomSize), nZoomBegin_(nZoomBegin)
 {
   createGlobalIndex();
@@ -89 +99 @@
   for (int i = 0; i < ssize; ++i)
   {
-    it = std::lower_bound(it, itEnd, globalIndex(i));
+    it = std::find(itBegin, itEnd, globalIndex(i));
+//    it = std::lower_bound(it, itEnd, globalIndex(i));
     if (itEnd != it)
     {
@@ -114 +125 @@
   for (int i = 0; i < ssize; ++i)
   {
-    it = std::lower_bound(it, itEnd, globalIndex(i));
+    it = std::find(itBegin, itEnd, globalIndex(i));
+//    it = std::lower_bound(it, itEnd, globalIndex(i));
     if (itEnd != it)
     {
@@ -125 +137 @@
 }
 
+
+std::vector<int> CDistributionServer::getZoomBeginGlobal() const
+{
+  return nZoomBeginGlobal_;
+}
+
+std::vector<int> CDistributionServer::getZoomBeginServer() const
+{
+  return nZoomBegin_;
+}
+
+std::vector<int> CDistributionServer::getZoomSizeServer() const
+{
+  return nZoomSize_;
+}
 } // namespace xios

XIOS/trunk/src/node/distribution_server.hpp

@@ -24 +24 @@
     /** Default constructor */
     CDistributionServer(int rank, int dims, CArray<size_t,1>* globalIndex = 0);
-    CDistributionServer(int rank, const std::vector<int>& nZoomBegin,
-                        const std::vector<int>& nZoomSize, const std::vector<int>& nGlobal);
+    CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer,
+                        const std::vector<int>& nZoomSizeServer, const std::vector<int>& nGlobal);
+    CDistributionServer(int rank, const std::vector<int>& nZoomBeginServer,
+                        const std::vector<int>& nZoomSizeServer,
+                        const std::vector<int>& nZoomBeginGlobal,
+                        const std::vector<int>& nGlobal);
 
     /** Default destructor */
     virtual ~CDistributionServer();
+
+    std::vector<int> getZoomBeginGlobal() const;
+    std::vector<int> getZoomBeginServer() const;
+    std::vector<int> getZoomSizeServer() const;
 
     virtual CArray<size_t,1> computeLocalIndex(const CArray<size_t,1>& globalIndex);
@@ -37 +45 @@
   private:
     std::vector<int> nGlobal_;
+    std::vector<int> nZoomBeginGlobal_;
     std::vector<int> nZoomSize_;
     std::vector<int> nZoomBegin_;
+
 };
 

XIOS/trunk/src/node/field.cpp

@@ -152 +152 @@
     list< CArray<double,1>* > list_data;
 
-     for (it = grid->storeIndex_toSrv.begin(); it != grid->storeIndex_toSrv.end(); it++)
-    {
-      int rank = (*it).first;
-      CArray<int,1>& index = *(it->second);
-      CArray<double,1> data_tmp(index.numElements());
-      for (int n = 0; n < data_tmp.numElements(); n++) data_tmp(n) = data(index(n));
-      list_msg.push_back(shared_ptr<CMessage>(new CMessage));
-      list_data.push_back(new CArray<double,1>(data_tmp));
-      *list_msg.back() << getId() << *list_data.back();
-      event.push(rank,grid->nbSenders[rank],*list_msg.back());
-    }
-    client->sendEvent(event);
+    if (!grid->doGridHaveDataDistributed())
+    {
+       if (0 == client->getClientRank())
+       {
+          for(it=grid->storeIndex_toSrv.begin();it!=grid->storeIndex_toSrv.end();it++)
+          {
+            int rank=(*it).first ;
+            CArray<int,1>& index = *(it->second) ;
+            CArray<double,1> data_tmp(index.numElements()) ;
+            for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ;
+
+            list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
+            list_data.push_back(new CArray<double,1>(data_tmp)) ;
+            *list_msg.back()<<getId()<<*list_data.back() ;
+            event.push(rank,1,*list_msg.back()) ;
+          }
+          client->sendEvent(event) ;
+       } else client->sendEvent(event);
+    }
+    else
+    {
+      for(it=grid->storeIndex_toSrv.begin();it!=grid->storeIndex_toSrv.end();it++)
+      {
+        int rank=(*it).first ;
+        CArray<int,1>& index = *(it->second) ;
+        CArray<double,1> data_tmp(index.numElements()) ;
+        for(int n=0;n<data_tmp.numElements();n++) data_tmp(n)=data(index(n)) ;
+        list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
+        list_data.push_back(new CArray<double,1>(data_tmp)) ;
+        *list_msg.back()<<getId()<<*list_data.back() ;
+        event.push(rank,grid->nbSenders[rank],*list_msg.back()) ;
+      }
+      client->sendEvent(event) ;
+    }
 
     for (list< CArray<double,1>* >::iterator it = list_data.begin(); it != list_data.end(); it++) delete *it;
@@ -189 +211 @@
   void  CField::recvUpdateData(vector<int>& ranks, vector<CBufferIn*>& buffers)
   {
-
     if (data_srv.empty())
     {
-//      for (map<int, CArray<int, 1>* >::iterator it = grid->out_i_fromClient.begin(); it != grid->out_i_fromClient.end(); it++)
       for (map<int, CArray<size_t, 1>* >::iterator it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
       {
@@ -234 +254 @@
   {
     if (!getRelFile()->allDomainEmpty)
-      if (!grid->domain->isEmpty() || getRelFile()->type == CFile::type_attr::one_file)
+      if (grid->doGridHaveDataToWrite() || getRelFile()->type == CFile::type_attr::one_file) //      if (! grid->domain->isEmpty() || getRelFile()->type == CFile::type_attr::one_file)
       {
         getRelFile()->checkFile();
@@ -553 +573 @@
       }
 
-//     if (!grid_ref.isEmpty())
-//     {
-//       domain = grid->domain;
-//       axis = grid->axis;
-//     }
-
-//     CType<string> goodDomain;
-//     CType<string> goodAxis;
-//     if (!grid_ref.isEmpty())
-//     {
-//       if (!grid->domain_ref.isEmpty()) goodDomain = grid->domain_ref;
-//       if (!grid->axis_ref.isEmpty()) goodAxis = grid->axis_ref;
-//     }
-//     if (!domain_ref.isEmpty()) goodDomain = domain_ref;
-//     if (!axis_ref.isEmpty()) goodAxis = axis_ref;
-
-//     CArray<std::string,1> domListTmp = grid->domainList.getValue();
-//     CArray<std::string,1> axisListTmp = grid->axisList.getValue();
 
      if (domList.empty() && axisList.empty())
@@ -576 +578 @@
        this->grid = CGrid::createGrid(vecDom, vecAxis);
      }
-
-//     std::string goodDomain = domListTmp[0];
-//     std::string goodAxis = axisListTmp[0];
-
-//     if (goodDomain.isEmpty())
-//     if (goodDomain.empty())
-//     {
-//       ERROR("CField::solveGridReference(void)", << "The horizontal domain for this field is not defined");
-//     }
-//     else
-//     {
-//       if (CDomain::has(goodDomain)) domain = CDomain::get(goodDomain);
-//       else ERROR("CField::solveGridReference(void)",<< "Reference to the domain \'"
-//                  << goodDomain << "\' is wrong");
-////                << goodDomain.get() << "\' is wrong");
-//     }
-//
-////     if (!goodAxis.isEmpty())
-//     if (!goodAxis.empty())
-//     {
-//       if (CAxis::has(goodAxis))  axis = CAxis::get(goodAxis);
-//       else  ERROR("CField::solveGridReference(void)", << "Reference to the axis \'"
-//                   << goodAxis <<"\' is wrong");
-//                   << goodAxis.get() <<"\' is wrong");
-//     }
-
-//     bool nothingToDo = false;
-//
-//     if (!grid_ref.isEmpty())
-//     {
-//       if (!grid->domain_ref.isEmpty() && goodDomain.get() == grid->domain_ref.get())
-//         if (goodAxis.isEmpty()) nothingToDo = true;
-//         else if (!grid->axis_ref.isEmpty())
-//                 if (grid->axis_ref.get() == goodAxis.get()) nothingToDo = true;
-//     }
-//
-//     nothingToDo = true;
-//     if (!nothingToDo)
-//     {
-//       if (!goodAxis.isEmpty())
-//       {
-//         this->grid = CGrid::createGrid(domain, axis);
-//         this->grid_ref.setValue(this->grid->getId());
-//       }
-//       else
-//       {
-//         this->grid = CGrid::createGrid(domain);
-//         this->grid_ref.setValue(this->grid->getId());
-//       }
-//     }
-
-//     grid->solveReference();
-//     grid->solveDomainAxisRef();
-//     grid->checkMaskIndex();
    }
 
@@ -682 +630 @@
         grid->outputField(it->first,*it->second, fieldOut.dataFirst());
       }
-
-//         grid->outputField(it->first,*it->second, fieldOut.);
    }
 
@@ -689 +635 @@
    {
       map<int, CArray<double,1>* >::iterator it;
+      for(it=data_srv.begin();it!=data_srv.end();it++)
+      {
+         grid->outputField(it->first,*it->second, fieldOut.dataFirst()) ;
+      }
+   }
+
+   void CField::outputField(CArray<double,1>& fieldOut)
+   {
+      map<int, CArray<double,1>* >::iterator it;
 
       for (it = data_srv.begin(); it != data_srv.end(); it++)
       {
-         grid->outputField(it->first, *it->second, fieldOut);
+         grid->outputField(it->first,*it->second, fieldOut.dataFirst()) ;
       }
    }
@@ -844 +799 @@
    \return pair of Domain and Axis id
    */
-   const std::pair<StdString,StdString>& CField::getDomainAxisIds()
-   {
-     CGrid* cgPtr = getRelGrid();
-     if (NULL != cgPtr)
-     {
-       if (NULL != cgPtr->getRelDomain()) domAxisIds_.first = cgPtr->getRelDomain()->getId();
-       if (NULL != cgPtr->getRelAxis()) domAxisIds_.second = cgPtr->getRelAxis()->getId();
-     }
-
-     return domAxisIds_;
-   }
+//   const std::pair<StdString,StdString>& CField::getDomainAxisIds()
+//   {
+//     CGrid* cgPtr = getRelGrid();
+//     if (NULL != cgPtr)
+//     {
+//       if (NULL != cgPtr->getRelDomain()) domAxisIds_.first = cgPtr->getRelDomain()->getId();
+//       if (NULL != cgPtr->getRelAxis()) domAxisIds_.second = cgPtr->getRelAxis()->getId();
+//     }
+//
+//     return (domAxisIds_);
+//   }
 
    CVariable* CField::addVariable(const string& id)

XIOS/trunk/src/node/field.hpp

@@ -135 +135 @@
         void outputField(CArray<double,3>& fieldOut) ;
         void outputField(CArray<double,2>& fieldOut) ;
+        void outputField(CArray<double,1>& fieldOut) ;
         void scaleFactorAddOffset(double scaleFactor, double addOffset) ;
         void parse(xml::CXMLNode & node) ;
@@ -156 +157 @@
 
 
-        const std::pair<StdString, StdString>& getDomainAxisIds();
+//        const std::pair<StdString, StdString>& getDomainAxisIds();
       public :
          /// Propriétés privées ///

XIOS/trunk/src/node/file.cpp

@@ -212 +212 @@
 
       allDomainEmpty=true ;
+
       set<CDomain*> setDomain ;
 
@@ -218 +219 @@
       {
          CField* field = *it;
-         allDomainEmpty&=field->grid->domain->isEmpty() ;
-         setDomain.insert(field->grid->domain) ;
+//         allDomainEmpty&=field->grid->domain->isEmpty() ;
+         allDomainEmpty&=(!field->grid->doGridHaveDataToWrite());
+         std::vector<CDomain*> vecDomain = field->grid->getDomains();
+         for (int i = 0; i < vecDomain.size(); ++i)
+            setDomain.insert(vecDomain[i]);
+//            setDomain.insert(field->grid->domain) ;
       }
       nbDomain=setDomain.size() ;
@@ -320 +325 @@
 
         bool append = !this->append.isEmpty() && this->append.getValue();
-        
+
          bool useClassicFormat = !format.isEmpty() && format == format_attr::netcdf4_classic;
 

XIOS/trunk/src/node/grid.cpp

@@ -20 +20 @@
    CGrid::CGrid(void)
       : CObjectTemplate<CGrid>(), CGridAttributes()
-      , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain()
-      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
+      , isChecked(false), isDomainAxisChecked(false), storeIndex(1)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_()
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_()
    {
      setVirtualDomainGroup();
@@ -31 +30 @@
    CGrid::CGrid(const StdString & id)
       : CObjectTemplate<CGrid>(id), CGridAttributes()
-      , withAxis(false), isChecked(false), isDomainAxisChecked(false), axis(), domain()
-      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1), isDomConServerComputed_(false)
+      , isChecked(false), isDomainAxisChecked(false), storeIndex(1)
       , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_()
+      , serverDistribution_(0), serverDistributionDescription_(0), clientServerMap_(), writtenDataSize_(0), globalDim_()
    {
      setVirtualDomainGroup();
@@ -42 +40 @@
    CGrid::~CGrid(void)
    {
- //     this->axis.reset() ;
-//      this->domain.reset() ;
     deque< CArray<int, 1>* >::iterator it ;
 
     for(deque< CArray<int,1>* >::iterator it=storeIndex.begin(); it!=storeIndex.end();it++)  delete *it ;
-    for(deque< CArray<int,1>* >::iterator it=out_i_index.begin();it!=out_i_index.end();it++) delete *it ;
-    for(deque< CArray<int,1>* >::iterator it=out_j_index.begin();it!=out_j_index.end();it++) delete *it ;
-    for(deque< CArray<int,1>* >::iterator it=out_l_index.begin();it!=out_l_index.end();it++) delete *it ;
-
-    for(map<int,CArray<int,1>* >::iterator it=out_i_fromClient.begin();it!=out_i_fromClient.end();it++) delete it->second ;
-    for(map<int,CArray<int,1>* >::iterator it=out_j_fromClient.begin();it!=out_j_fromClient.end();it++) delete it->second ;
-    for(map<int,CArray<int,1>* >::iterator it=out_l_fromClient.begin();it!=out_l_fromClient.end();it++) delete it->second ;
-
     for(map<int,CArray<size_t,1>* >::iterator it=outIndexFromClient.begin();it!=outIndexFromClient.end();++it) delete (it->second);
 
@@ -60 +48 @@
     if (0 != serverDistribution_) delete serverDistribution_;
     if (0 != serverDistributionDescription_) delete serverDistributionDescription_;
-
    }
 
@@ -77 +64 @@
 
    //---------------------------------------------------------------
-
-   const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const
-   {
-      return (this->out_i_index );
-   }
+//
+//   const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const
+//   {
+//      return (this->out_i_index );
+//   }
+//
+//   //---------------------------------------------------------------
+//
+//   const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const
+//   {
+//      return (this->out_j_index );
+//   }
+//
+//   //---------------------------------------------------------------
+//
+//   const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const
+//   {
+//      return (this->out_l_index );
+//   }
+//
+//   //---------------------------------------------------------------
+//
+//   const CAxis*   CGrid::getRelAxis  (void) const
+//   {
+//      return (this->axis );
+//   }
+
+//   //---------------------------------------------------------------
+//
+//   const CDomain* CGrid::getRelDomain(void) const
+//   {
+//      return (this->domain );
+//   }
 
    //---------------------------------------------------------------
 
-   const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const
-   {
-      return (this->out_j_index );
-   }
+//   bool CGrid::hasAxis(void) const
+//   {
+//      return (this->withAxis);
+//   }
 
    //---------------------------------------------------------------
 
-   const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const
-   {
-      return (this->out_l_index );
-   }
-
-   //---------------------------------------------------------------
-
-   const CAxis*   CGrid::getRelAxis  (void) const
-   {
-      return (this->axis );
-   }
-
-   //---------------------------------------------------------------
-
-   const CDomain* CGrid::getRelDomain(void) const
-   {
-      return (this->domain );
-   }
-
-   //---------------------------------------------------------------
-
-   bool CGrid::hasAxis(void) const
-   {
-      return (this->withAxis);
-   }
-
-   //---------------------------------------------------------------
-
    StdSize CGrid::getDimension(void) const
    {
-      return ((this->withAxis)?3:2);
+      return (globalDim_.size());
    }
 
@@ -176 +163 @@
    StdSize CGrid::getDataSize(void) const
    {
-      StdSize retvalue=domain->data_ni.getValue() ;
-      if (domain->data_dim.getValue()==2) retvalue*=domain->data_nj.getValue() ;
-      if (this->withAxis) retvalue*=this->axis->size.getValue() ;
-
+      std::vector<int> dataNindex = clientDistribution_->getDataNIndex();
+      StdSize retvalue = 1;
+      for (int i = 0; i < dataNindex.size(); ++i) retvalue *= dataNindex[i];
       return (retvalue);
    }
@@ -201 +187 @@
 
 
-   //---------------------------------------------------------------
-
-//   void CGrid::solveReference(void)
-//   {
-//      if (this->isChecked) return;
-//      CContext* context = CContext::getCurrent() ;
-//      CContextClient* client=context->client ;
-//
-//      this->solveDomainRef() ;
-//      this->solveAxisRef() ;
-//
-//      if (context->hasClient)
-//      {
-//         checkMask() ;
-//         this->computeIndex() ;
-//
-//         this->storeIndex.push_front(new CArray<int,1>() );
-//         this->out_i_index.push_front(new CArray<int,1>());
-//         this->out_j_index.push_front(new CArray<int,1>());
-//         this->out_l_index.push_front(new CArray<int,1>());
-//      }
-////      this->computeIndexServer();
-//      this->isChecked = true;
-//   }
-
    void CGrid::solveDomainAxisRef(bool areAttributesChecked)
    {
@@ -250 +211 @@
         checkMask() ;
         this->computeIndex() ;
-
         this->storeIndex.push_front(new CArray<int,1>() );
-        this->out_i_index.push_front(new CArray<int,1>());
-        this->out_j_index.push_front(new CArray<int,1>());
-        this->out_l_index.push_front(new CArray<int,1>());
      }
-//      this->computeIndexServer();
      this->isChecked = true;
    }
 
-
    void CGrid::checkMask(void)
    {
       using namespace std;
-
-      unsigned int niu = domain->ni, nju = domain->nj;
-      unsigned int nlu = 1 ;
-      if (hasAxis()) nlu=axis->size ;
-
-      if (!mask.isEmpty())
-      {
-         if ((mask.extent(0) != niu) ||
-             (mask.extent(1) != nju) ||
-             (mask.extent(2) != nlu))
-             ERROR("CGrid::checkAttributes(void)",
-                  <<"The mask has not the same size than the local grid"<<endl
-                  <<"Local size is "<<niu<<"x"<<nju<<"x"<<nlu<<endl
-                  <<"Mask size is "<<mask.extent(0)<<"x"<<mask.extent(1)<<"x"<<mask.extent(2));
-      }
-      else
-      {
-        mask.resize(niu,nju,nlu) ;
-        mask=true  ;
-      }
-
-      CArray<bool,2>& domainMask = domain->mask ;
-      for (int l=0; l < nlu ; l++)
-        for (int j=0; j < nju ; j++)
-          for(int i=0; i<niu ; i++) mask(i,j,l) = mask(i,j,l) && domainMask(i,j) ;
-
-
-   }
-
+      std::vector<CDomain*> domainP = this->getDomains();
+      std::vector<CAxis*> axisP = this->getAxis();
+      int dim = domainP.size() * 2 + axisP.size();
+
+      std::vector<CArray<bool,2>* > domainMasks(domainP.size());
+      for (int i = 0; i < domainMasks.size(); ++i) domainMasks[i] = &(domainP[i]->mask);
+      std::vector<CArray<bool,1>* > axisMasks(axisP.size());
+      for (int i = 0; i < axisMasks.size(); ++i) axisMasks[i] = &(axisP[i]->mask);
+
+      switch (dim) {
+        case 1:
+          checkGridMask(mask1, domainMasks, axisMasks, axisDomainOrder);
+          break;
+        case 2:
+          checkGridMask(mask2, domainMasks, axisMasks, axisDomainOrder);
+          break;
+        case 3:
+          checkGridMask(mask3, domainMasks, axisMasks, axisDomainOrder);
+          break;
+//        case 4:
+//          checkGridMask(mask4, domainMasks, axisMasks, axisDomainOrder);
+//          break;
+//        case 5:
+//          checkGridMask(mask5, domainMasks, axisMasks, axisDomainOrder);
+//          break;
+//        case 6:
+//          checkGridMask(mask6, domainMasks, axisMasks, axisDomainOrder);
+//          break;
+//        case 7:
+//          checkGridMask(mask7, domainMasks, axisMasks, axisDomainOrder);
+//          break;
+        default:
+          break;
+      }
+   }
    //---------------------------------------------------------------
 
-//   void CGrid::solveDomainRef(void)
-//   {
-//      if (!domain_ref.isEmpty())
-//      {
-//         if (CDomain::has(domain_ref.getValue()))
-//         {
-//            this->domain = CDomain::get(domain_ref.getValue()) ;
-//            domain->checkAttributes() ;
-//         }
-//         else ERROR("CGrid::solveDomainRef(void)",
-//                     << "Wrong domain reference") ;
-//      }
-//      else ERROR("CGrid::solveDomainRef(void)",
-//                  << "Domain reference is not defined") ;
-//   }
-//
-//   //---------------------------------------------------------------
-//
-//   void CGrid::solveAxisRef(void)
-//   {
-//      if (!axis_ref.isEmpty())
-//      {
-//         this->withAxis = true ;
-//         if (CAxis::get(axis_ref.getValue()))
-//         {
-//            this->axis = CAxis::get(axis_ref.getValue()) ;
-//            axis->checkAttributes() ;
-//         }
-//         else ERROR("CGrid::solveAxisRef(void)",
-//                    << "Wrong axis reference") ;
-//      }
-//      else withAxis = false ;
-//   }
-
-
    void CGrid::solveDomainRef(bool sendAtt)
    {
-//      if (!domain_ref.isEmpty())
-//      {
-//         if (CDomain::has(domain_ref.getValue()))
-//         {
-//            this->domain = CDomain::get(domain_ref.getValue()) ;
-//            if (sendAtt) domain->sendCheckedAttributes();
-//            else domain->checkAttributesOnClient() ;
-//         }
-//         else ERROR("CGrid::solveDomainRef(void)",
-//                     << "Wrong domain reference") ;
-//      }
-//      else ERROR("CGrid::solveDomainRef(void)",
-//                  << "Domain reference is not defined") ;
       setDomainList();
-      this->domain = CDomain::get(domList_.at(0));
-      if (0 != this->domain)
-      {
-//        this->domain = this->getDomain();
-        if (sendAtt) domain->sendCheckedAttributes();
-        else domain->checkAttributesOnClient() ;
-      }
-      else ERROR("CGrid::solveDomainRef(void)",
-                  << "Domain reference is not defined") ;
+      std::vector<CDomain*> domListP = this->getDomains();
+      if (!domListP.empty())
+      {
+        computeGridGlobalDimension(getDomains(), getAxis(), axisDomainOrder);
+        for (int i = 0; i < domListP.size(); ++i)
+        {
+          if (sendAtt) domListP[i]->sendCheckedAttributes();
+          else domListP[i]->checkAttributesOnClient();
+        }
+      }
    }
 
    //---------------------------------------------------------------
 
-   void CGrid::solveAxisRef(bool checkAtt)
-   {
-//      if (!axis_ref.isEmpty())
-//      {
-//         this->withAxis = true ;
-//         if (CAxis::get(axis_ref.getValue()))
-//         {
-//            this->axis = CAxis::get(axis_ref.getValue()) ;
-//            axis->checkAttributes() ;
-//         }
-//         else ERROR("CGrid::solveAxisRef(void)",
-//                    << "Wrong axis reference") ;
-//      }
-//      else withAxis = false ;
-//      getAllAxis();
+   void CGrid::solveAxisRef(bool sendAtt)
+   {
       setAxisList();
-      if (!axisList_.empty())
-      {
-        int sizeList = axisList_.size();
-        for (int i = 0; i < sizeList; ++i)
+      std::vector<CAxis*> axisListP = this->getAxis();
+      if (!axisListP.empty())
+      {
+        int idx = 0;
+        computeGridGlobalDimension(getDomains(), getAxis(), axisDomainOrder);
+        for (int i = 0; i < axisListP.size(); ++i)
         {
-          CAxis::get(axisList_.at(i))->checkAttributes();
-          this->axis = CAxis::get(axisList_.at(i));
+          while (this->axisDomainOrder(idx)) idx += 2;
+          if (sendAtt)
+            axisListP[i]->sendCheckedAttributes(globalDim_,idx);
+          else
+            axisListP[i]->checkAttributesOnClient(globalDim_,idx);
+          ++idx;
         }
-        withAxis = true;
-
-      }
-//      if (!axis_ref.isEmpty())
-//      {
-//         this->withAxis = true ;
-//         if (CAxis::get(axis_ref.getValue()))
-//         {
-//            this->axis = CAxis::get(axis_ref.getValue()) ;
-//            axis->checkAttributes() ;
-//         }
-//         else ERROR("CGrid::solveAxisRef(void)",
-//                    << "Wrong axis reference") ;
-//      }
-      else withAxis = false ;
+
+      }
    }
 
@@ -415 +309 @@
 
      // Finally, compute index mapping between client(s) and server(s)
-     clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(),serverDistributionDescription_->getGlobalIndex());
+     clientServerMap_.computeServerIndexMapping(clientDistribution_->getGlobalIndex(),
+                                                clientDistribution_->getLocalDataIndexSendToServerOnClient(),
+                                                serverDistributionDescription_->getGlobalIndex());
      const std::map<int, std::vector<size_t> >& globalIndexOnServer = clientServerMap_.getGlobalIndexOnServer();
      std::vector<int> connectedServerRank;
@@ -427 +323 @@
      storeIndex_client = (clientDistribution_->getLocalDataIndexOnClient());
 
-/*
-      const int ni   = domain->ni.getValue() ,
-                nj   = domain->nj.getValue() ,
-                size = (this->hasAxis()) ? axis->size.getValue() : 1 ,
-                lbegin = (this->hasAxis()) ? axis->zoom_begin.getValue()-1 : 0 ,
-                lend = (this->hasAxis()) ? axis->zoom_end.getValue()-1 : 0 ;
-
-
-      const int data_dim     = domain->data_dim.getValue() ,
-                data_n_index = domain->data_n_index.getValue() ,
-                data_ibegin  = domain->data_ibegin.getValue() ,
-                data_jbegin  = (data_dim == 2)
-                             ? domain->data_jbegin.getValue() : -1;
-
-      CArray<int,1> data_i_index = domain->data_i_index ;
-      CArray<int,1> data_j_index = domain->data_j_index ;
-
-
-      int indexCount = 0;
-
-      for(int l = 0; l < size ; l++)
-      {
-         for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
-         {
-            int temp_i = data_i_index(n) + data_ibegin,
-                temp_j = (data_dim == 1) ? -1
-                       : data_j_index(n) + data_jbegin;
-            i = (data_dim == 1) ? (temp_i - 1) % ni
-                                : (temp_i - 1) ;
-            j = (data_dim == 1) ? (temp_i - 1) / ni
-                                : (temp_j - 1) ;
-
-            if ((l >=lbegin && l<= lend) &&
-                (i >= 0 && i < ni) &&
-                (j >= 0 && j < nj) && mask(i,j,l))
-               indexCount++ ;
-         }
-      }
-
-      storeIndex[0]  = new CArray<int,1>(indexCount) ;
-      out_i_index[0] = new CArray<int,1>(indexCount) ;
-      out_j_index[0] = new CArray<int,1>(indexCount) ;
-      out_l_index[0] = new CArray<int,1>(indexCount) ;
-
-      storeIndex_client.resize(indexCount) ;
-      out_i_client.resize(indexCount) ;
-      out_j_client.resize(indexCount) ;
-      out_l_client.resize(indexCount) ;
-
-
-      for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
-      {
-         for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
-         {
-            int temp_i = data_i_index(n) + data_ibegin,
-                temp_j = (data_dim == 1) ? -1
-                       : data_j_index(n) + data_jbegin;
-            i = (data_dim == 1) ? (temp_i - 1) % ni
-                                : (temp_i - 1) ;
-            j = (data_dim == 1) ? (temp_i - 1) / ni
-                                : (temp_j - 1) ;
-
-            if ((l >= lbegin && l <= lend) &&
-                (i >= 0 && i < ni) &&
-                (j >= 0 && j < nj) && mask(i,j,l))
-            {
-               (*storeIndex[0])(indexCount) = count ;
-               (*out_l_index[0])(indexCount) = l ;
-               (*out_i_index[0])(indexCount) = i ;
-               (*out_j_index[0])(indexCount) = j ;
-
-               storeIndex_client(indexCount) = count ;
-               out_i_client(indexCount)=i+domain->ibegin_client-1 ;
-               out_j_client(indexCount)=j+domain->jbegin_client-1 ;
-               out_l_client(indexCount)=l-lbegin ;
-               indexCount++ ;
-            }
-         }
-      }
-*/
-//      computeDomConServer();
-//      sendIndex() ;
-
-
    }
 
@@ -517 +329 @@
    CGrid* CGrid::createGrid(CDomain* domain)
    {
-      StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
-      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
-
       std::vector<CDomain*> vecDom(1,domain);
-      grid->setDomainList(vecDom);
-//      grid->domain_ref.setValue(domain->getId());
+      std::vector<CAxis*> vecAxis;
+
+      CGrid* grid = createGrid(vecDom, vecAxis);
+
       return (grid);
    }
@@ -528 +339 @@
    CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
    {
-      StdString new_id = StdString("__") + domain->getId() +
-                         StdString("_") + axis->getId() + StdString("__") ;
-      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
-
       std::vector<CDomain*> vecDom(1,domain);
       std::vector<CAxis*> vecAxis(1,axis);
-      grid->setDomainList(vecDom);
-      grid->setAxisList(vecAxis);
-//      grid->domain_ref.setValue(domain->getId());
-//      grid->axis_ref.setValue(axis->getId());
+      CGrid* grid = createGrid(vecDom, vecAxis);
+
       return (grid);
    }
@@ -564 +369 @@
       }
 
+      grid->computeGridGlobalDimension(domains, axis, grid->axisDomainOrder);
+
       return (grid);
    }
@@ -575 +382 @@
    {
      return (this->vAxisGroup_);
-   }
-
-   //----------------------------------------------------------------
-
-   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 3>& field)
-   {
-      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
-      CArray<int,1>& out_j=*out_j_fromClient[rank] ;
-      CArray<int,1>& out_l=*out_l_fromClient[rank] ;
-
-      for(StdSize n = 0; n < stored.numElements(); n++)
-         field(out_i(n), out_j(n), out_l(n)) = stored(n) ;
-   }
-
-   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 2>& field)
-   {
-      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
-      CArray<int,1>& out_j=*out_j_fromClient[rank] ;
-
-      for(StdSize n = 0; n < stored.numElements(); n++)
-         field(out_i(n), out_j(n)) = stored(n) ;   }
-
-   //---------------------------------------------------------------
-
-   void CGrid::outputField(int rank,const CArray<double, 1>& stored,  CArray<double, 1>& field)
-   {
-      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
-
-      for(StdSize n = 0; n < stored.numElements(); n++)
-         field(out_i(n)) = stored(n) ;
    }
 
@@ -629 +406 @@
    }
 
-   //---------------------------------------------------------------
-
-//  void CGrid::sendIndex(void)
-//  {
-//    CContext* context = CContext::getCurrent() ;
-//    CContextClient* client=context->client ;
-//
-//    CEventClient event(getType(),EVENT_ID_INDEX) ;
-//    int rank ;
-//    list<shared_ptr<CMessage> > list_msg ;
-//    list< CArray<int,1>* > list_out_i,list_out_j,list_out_l ;
-//
-//    for(int ns=0;ns<domain->connectedServer.size();ns++)
-//    {
-//       rank=domain->connectedServer[ns] ;
-//
-//       int i,j ;
-//       int nb=0 ;
-//       for(int k=0;k<storeIndex_client.numElements();k++)
-//       {
-//         i=out_i_client(k)- domain->ibegin +1;
-//         j=out_j_client(k)- domain->jbegin +1;
-//         if (domain->mapConnectedServer(i,j)==ns)  nb++ ;
-//       }
-//       CArray<int,1> storeIndex(nb) ;
-//       CArray<int,1> out_i(nb) ;
-//       CArray<int,1> out_j(nb) ;
-//       CArray<int,1> out_l(nb) ;
-//
-//
-//       nb=0 ;
-//       for(int k=0;k<storeIndex_client.numElements();k++)
-//       {
-//         i=out_i_client(k)- domain->ibegin +1 ;
-//         j=out_j_client(k)- domain->jbegin +1 ;
-//         if (domain->mapConnectedServer(i,j)==ns)
-//         {
-//            storeIndex(nb)=k ;
-//            out_i(nb)=domain->i_index(i,j) + domain->ibegin-1;
-//            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1;
-//            out_l(nb)=out_l_client(k) ;
-//            nb++ ;
-//         }
-//       }
-//
-//       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ;
-//       nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ;
-//       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
-//       list_out_i.push_back(new CArray<int,1>(out_i)) ;
-//       list_out_j.push_back(new CArray<int,1>(out_j)) ;
-//       list_out_l.push_back(new CArray<int,1>(out_l)) ;
-//
-//       *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ;
-//       event.push(rank,domain->nbSenders[ns],*list_msg.back()) ;
-//    }
-//    client->sendEvent(event) ;
-//
-//    for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ;
-//    for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ;
-//    for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ;
-//
-//  }
-
-  void CGrid::computeDomConServer()
-  {
-    if (!isDomConServerComputed_)
-    {
-      for(int ns=0;ns<domain->connectedServer.size(); ++ns)
-      {
-         int rank=domain->connectedServer[ns] ;
-
-         int i,j ;
-         int nb=0 ;
-         for(int k=0;k<storeIndex_client.numElements();++k)
-         {
-           i=out_i_client(k)- domain->ibegin +1;
-           j=out_j_client(k)- domain->jbegin +1;
-           if (domain->mapConnectedServer(i,j)==ns)  ++nb ;
-         }
-
-         domConnectedServerSide_.insert(std::make_pair(rank, nb));
-      }
-      isDomConServerComputed_ = true;
-    }
-  }
-
-
-  std::map<int, int> CGrid::getDomConServerSide()
-  {
-    return domConnectedServerSide_;
-  }
-
   void CGrid::sendIndex(void)
   {
@@ -739 +424 @@
     itLocal = localIndexSendToServer.begin();
 
-    for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns)
-    {
-      rank = itGlobal->first;
-      int nb = (itGlobal->second).size();
-
-      CArray<size_t, 1> outGlobalIndexOnServer(nb);
-      CArray<int, 1> outLocalIndexToServer(nb);
-      for (int k = 0; k < nb; ++k)
-      {
-        outGlobalIndexOnServer(k) = itGlobal->second.at(k);
-        outLocalIndexToServer(k)  = itLocal->second.at(k);
-      }
-
-      storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) ));
-      listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer));
-
-      list_msg.push_back(shared_ptr<CMessage>(new CMessage));
-      *list_msg.back()<<getId()<<*listOutIndex.back();
-      event.push(rank, nbSenders[rank], *list_msg.back());
-    }
-    client->sendEvent(event);
+    if (!doGridHaveDataDistributed())
+    {
+      if (0 == client->getClientRank())
+      {
+       for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns)
+        {
+          rank = itGlobal->first;
+          int nb = (itGlobal->second).size();
+
+          CArray<size_t, 1> outGlobalIndexOnServer(nb);
+          CArray<int, 1> outLocalIndexToServer(nb);
+          for (int k = 0; k < nb; ++k)
+          {
+            outGlobalIndexOnServer(k) = itGlobal->second.at(k);
+            outLocalIndexToServer(k)  = itLocal->second.at(k);
+          }
+
+          storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) ));
+          listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer));
+
+          list_msg.push_back(shared_ptr<CMessage>(new CMessage));
+          *list_msg.back()<<getId()<<*listOutIndex.back();
+          event.push(rank, 1, *list_msg.back());
+        }
+        client->sendEvent(event);
+      } else client->sendEvent(event);
+    }
+    else
+    {
+      for (int ns = 0; itGlobal != iteMap; ++itGlobal, ++itLocal, ++ns)
+      {
+        rank = itGlobal->first;
+        int nb = (itGlobal->second).size();
+
+        CArray<size_t, 1> outGlobalIndexOnServer(nb);
+        CArray<int, 1> outLocalIndexToServer(nb);
+        for (int k = 0; k < nb; ++k)
+        {
+          outGlobalIndexOnServer(k) = itGlobal->second.at(k);
+          outLocalIndexToServer(k)  = itLocal->second.at(k);
+        }
+
+        storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(outLocalIndexToServer) ));
+        listOutIndex.push_back(new CArray<size_t,1>(outGlobalIndexOnServer));
+
+        list_msg.push_back(shared_ptr<CMessage>(new CMessage));
+        *list_msg.back()<<getId()<<*listOutIndex.back();
+        event.push(rank, nbSenders[rank], *list_msg.back());
+      }
+      client->sendEvent(event);
+    }
+
     for(list<CArray<size_t,1>* >::iterator it=listOutIndex.begin();it!=listOutIndex.end();++it) delete *it ;
-
-/*
-    if (!isDomConServerComputed_) computeDomConServer();
-
-    for(int ns=0;ns<domain->connectedServer.size();ns++)
-    {
-       rank=domain->connectedServer[ns] ;
-
-       int nb = domConnectedServerSide_.find(rank)->second;
-       CArray<int,1> storeIndex(nb) ;
-       CArray<int,1> out_i(nb) ;
-       CArray<int,1> out_j(nb) ;
-       CArray<int,1> out_l(nb) ;
-
-       int i, j;
-       nb=0 ;
-       for(int k=0;k<storeIndex_client.numElements();k++)
-       {
-         i=out_i_client(k)- domain->ibegin +1 ;
-         j=out_j_client(k)- domain->jbegin +1 ;
-         if (domain->mapConnectedServer(i,j)==ns)
-         {
-            storeIndex(nb)=k ;
-            out_i(nb)=domain->i_index(i,j) + domain->ibegin-1;
-            out_j(nb)=domain->j_index(i,j) + domain->jbegin-1;
-            out_l(nb)=out_l_client(k) ;
-            nb++ ;
-         }
-       }
-
-       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ;
-       nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ;
-       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
-       list_out_i.push_back(new CArray<int,1>(out_i)) ;
-       list_out_j.push_back(new CArray<int,1>(out_j)) ;
-       list_out_l.push_back(new CArray<int,1>(out_l)) ;
-
-       *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ;
-       event.push(rank,domain->nbSenders[ns],*list_msg.back()) ;
-    }
-    client->sendEvent(event) ;
-
-    for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ;
-    for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ;
-    for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ;
-*/
   }
 
@@ -820 +490 @@
       get(gridId)->recvIndex(rank,*buffer) ;
     }
+  }
+
+  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains,
+                                         const std::vector<CAxis*>& axis,
+                                         const CArray<bool,1>& axisDomainOrder)
+  {
+    globalDim_.resize(domains.size()*2+axis.size());
+    int idx = 0, idxDomain = 0, idxAxis = 0;
+    for (int i = 0; i < axisDomainOrder.numElements(); ++i)
+    {
+      if (axisDomainOrder(i))
+      {
+        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue();
+        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue();
+        ++idxDomain;
+        idx += 2;
+      }
+      else
+      {
+        globalDim_[idx] = axis[idxAxis]->size.getValue();
+        ++idxAxis;
+        ++idx;
+      }
+    }
+  }
+
+  std::vector<int> CGrid::getGlobalDimension()
+  {
+    return globalDim_;
+  }
+
+  /*!
+    Verify whether one server need to write data
+    There are some cases on which one server has nodata to write. For example, when we
+  just only want to zoom on a domain.
+  */
+  bool CGrid::doGridHaveDataToWrite()
+  {
+    return (0 != serverDistribution_);
+  }
+
+  /*!
+    Return size of data which is written on each server
+    Whatever dimension of a grid, data which are written on server must be presented as
+  an one dimension array.
+  \return size of data written on server
+  */
+  size_t CGrid::getWrittenDataSize() const
+  {
+    return writtenDataSize_;
+  }
+
+
+  const CDistributionServer* CGrid::getDistributionServer() const
+  {
+    return serverDistribution_;
+  }
+
+  bool CGrid::doGridHaveDataDistributed()
+  {
+    return clientDistribution_->isDataDistributed();
   }
 
@@ -835 +566 @@
          indexMap[i] = idx;
          if (true == axisDomainOrder(i))
-        {
-          ++ssize;
-          idx += 2;
-        }
+         {
+            ++ssize;
+            idx += 2;
+         }
+         else
+          ++idx;
        }
 
@@ -844 +577 @@
        std::vector<CDomain*> domainList = getDomains();
        std::vector<CAxis*> axisList = getAxis();
-       std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize);
+       std::vector<int> nZoomBegin(ssize), nZoomSize(ssize), nGlob(ssize), nZoomBeginGlobal(ssize);
        for (int i = 0; i < numElement; ++i)
        {
@@ -851 +584 @@
             nZoomBegin[indexMap[i]]   = domainList[domainId]->zoom_ibegin_srv;
             nZoomSize[indexMap[i]]    = domainList[domainId]->zoom_ni_srv;
+            nZoomBeginGlobal[indexMap[i]] = domainList[domainId]->zoom_ibegin;
             nGlob[indexMap[i]]    = domainList[domainId]->ni_glo;
 
             nZoomBegin[indexMap[i]+1] = domainList[domainId]->zoom_jbegin_srv;
             nZoomSize[indexMap[i]+1]  = domainList[domainId]->zoom_nj_srv;
+            nZoomBeginGlobal[indexMap[i]+1] = domainList[domainId]->zoom_jbegin;
             nGlob[indexMap[i]+1]    = domainList[domainId]->nj_glo;
             ++domainId;
@@ -860 +595 @@
          else
          {
-            nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin;
-            nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size;
+            nZoomBegin[indexMap[i]] = axisList[axisId]->zoom_begin_srv;
+            nZoomSize[indexMap[i]]  = axisList[axisId]->zoom_size_srv;
+            nZoomBeginGlobal[indexMap[i]] = axisList[axisId]->zoom_begin;
             nGlob[indexMap[i]]      = axisList[axisId]->size;
             ++axisId;
          }
        }
-       serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize, nGlob);
+       writtenDataSize_ = 1;
+       for (int i = 0; i < nZoomSize.size(); ++i)
+        writtenDataSize_ *= nZoomSize[i];
+
+       serverDistribution_ = new CDistributionServer(server->intraCommRank, nZoomBegin, nZoomSize,
+                                                     nZoomBeginGlobal, nGlob);
      }
 
@@ -873 +614 @@
      serverDistribution_->computeLocalIndex(outIndex);
      outIndexFromClient.insert(std::pair<int, CArray<size_t,1>* >(rank, new CArray<size_t,1>(outIndex)));
-
-    /*
-    CArray<int,1> out_i ;
-    CArray<int,1> out_j ;
-    CArray<int,1> out_l ;
-
-    buffer>>out_i>>out_j>>out_l ;
-
-    out_i -= domain->zoom_ibegin_srv-1 ;
-    out_j -= domain->zoom_jbegin_srv-1 ;
-
-    out_i_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_i) )) ;
-    out_j_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_j) )) ;
-    out_l_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_l) )) ;
-    */
   }
 
@@ -1240 +966 @@
   {
     SuperClass::parse(node);
+
     // List order of axis and domain in a grid, if there is a domain, it will take value 1 (true), axis 0 (false)
-//    std::vector<int> axisOrder;
     std::vector<bool> order;
 

XIOS/trunk/src/node/grid.hpp

@@ -15 +15 @@
 #include "server_distribution_description.hpp"
 #include "client_server_mapping.hpp"
+#include "utils.hpp"
 
 namespace xios {
@@ -133 +134 @@
          void computeIndexServer(void);
          void computeIndex(void);
-//         void solveDomainRef(void);  //TODO temporarily comment
-//         void solveAxisRef(void);   // TODO: temporarily comment
 
          void solveDomainRef(bool checkAtt);
@@ -164 +163 @@
          std::vector<CAxis*> getAxis();
          std::vector<int> getAxisOrder();
+         std::vector<int> getGlobalDimension();
+
+         bool doGridHaveDataToWrite();
+         bool doGridHaveDataDistributed();
+         size_t getWrittenDataSize() const;
+
+         const CDistributionServer* getDistributionServer() const;
 
       public:
 
          /// Propriétés privées ///
-         bool withAxis ;
          bool isChecked;
          bool isDomainAxisChecked;
          bool isIndexSent;
 
-         CAxis*   axis ;
-         CDomain* domain ;
-
          std::deque< CArray<int, 1>* > storeIndex ;
-         std::deque< CArray<int, 1>* > out_i_index ;
-         std::deque< CArray<int, 1>* > out_j_index ;
-         std::deque< CArray<int, 1>* > out_l_index ;
-
         CArray<int, 1>  storeIndex_client ;
-        CArray<int, 1>  out_i_client ;
-        CArray<int, 1>  out_j_client ;
-        CArray<int, 1>  out_l_client ;
+
 
          map<int, CArray<int, 1>* >  storeIndex_toSrv ;
          map<int,int> nbSenders ;
-//         std::deque<ARRAY(int, 1)> out_i_toSrv ;
-//         std::deque<ARRAY(int, 1)> out_j_toSrv ;
-//         std::deque<ARRAY(int, 1)> out_l_toSrv ;
-
-         map<int, CArray<int, 1>* > out_i_fromClient ;
-         map<int, CArray<int, 1>* > out_j_fromClient ;
-         map<int, CArray<int, 1>* > out_l_fromClient ;
 
          map<int, CArray<size_t, 1>* > outIndexFromClient;
          void checkMask(void) ;
 
-         std::map<int, int> domConnectedServerSide_;
-         bool isDomConServerComputed_;
-
       private:
+       template<int N>
+       void checkGridMask(CArray<bool,N>& gridMask,
+                          const std::vector<CArray<bool,2>* >& domainMasks,
+                          const std::vector<CArray<bool,1>* >& axisMasks,
+                          const CArray<bool,1>& axisDomainOrder);
         void setVirtualDomainGroup(CDomainGroup* newVDomainGroup);
         void setVirtualDomainGroup();
         void setVirtualAxisGroup(CAxisGroup* newVAxisGroup);
         void setVirtualAxisGroup();
-//        void setAxisList();
+
         void setAxisList(const std::vector<CAxis*> axis = std::vector<CAxis*>());
-//        void setDomainList();
         void setDomainList(const std::vector<CDomain*> domains = std::vector<CDomain*>());
+
+        void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
+                                        const std::vector<CAxis*>& axis,
+                                        const CArray<bool,1>& axisDomainOrder);
 
         CDomain* addDomain(const std::string& id);
@@ -217 +211 @@
         CAxisGroup* getVirtualAxisGroup() const;
         CDomainGroup* getVirtualDomainGroup() const;
+        std::vector<int> globalDim_;
       private:
         CDomainGroup* vDomainGroup_;
@@ -222 +217 @@
         std::vector<std::string> axisList_, domList_;
         bool isAxisListSet, isDomListSet;
+
         CDistributionClient* clientDistribution_;
         CDistributionServer* serverDistribution_;
         CServerDistributionDescription* serverDistributionDescription_;
         CClientServerMapping clientServerMap_;
+        size_t writtenDataSize_;
    }; // class CGrid
 
@@ -231 +228 @@
 
    template <int n>
-      void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
+   void CGrid::inputField(const CArray<double,n>& field, CArray<double,1>& stored) const
    {
       if (this->getDataSize() != field.numElements())
@@ -241 +238 @@
    }
 
+   template<int N>
+   void CGrid::checkGridMask(CArray<bool,N>& gridMask,
+                             const std::vector<CArray<bool,2>* >& domainMasks,
+                             const std::vector<CArray<bool,1>* >& axisMasks,
+                             const CArray<bool,1>& axisDomainOrder)
+   {
+     int idx = 0;
+     int numElement = axisDomainOrder.numElements();
+     int dim = domainMasks.size()*2 + axisMasks.size();
+
+     std::vector<int> idxLoop(dim,0), indexMap(numElement), eachDimSize(dim);
+     std::vector<int> currentIndex(dim);
+     int idxDomain = 0, idxAxis = 0;
+    for (int i = 0; i < numElement; ++i)
+    {
+      indexMap[i] = idx;
+      if (true == axisDomainOrder(i)) {
+          eachDimSize[indexMap[i]]   = domainMasks[idxDomain]->extent(0);
+          eachDimSize[indexMap[i]+1] = domainMasks[idxDomain]->extent(1);
+          idx += 2; ++idxDomain;
+      }
+      else {
+        eachDimSize[indexMap[i]] = axisMasks[idxAxis]->numElements();
+        ++idx; ++idxAxis;
+      }
+    }
+
+    if (!gridMask.isEmpty())
+    {
+      for (int i = 0; i < dim; ++i)
+      {
+        if (gridMask.extent(i) != eachDimSize[i])
+           ERROR("CGrid::checkMask(void)",
+                <<"The mask has one dimension whose size is different from the one of the local grid"<<endl
+                <<"Local size is "<< i << " " << eachDimSize[i]<<endl
+                <<"Mask dimension size is "<<gridMask.extent(i));
+      }
+    }
+    else {
+        CArrayBoolTraits<CArray<bool,N> >::resizeArray(gridMask,eachDimSize);
+        gridMask = true;
+    }
+
+    int ssize = gridMask.numElements();
+    idx = 0;
+    while (idx < ssize)
+    {
+      for (int i = 0; i < dim-1; ++i)
+      {
+        if (idxLoop[i] == eachDimSize[i])
+        {
+          idxLoop[i] = 0;
+          ++idxLoop[i+1];
+        }
+      }
+
+      // Find out outer index
+      idxDomain = idxAxis = 0;
+      bool maskValue = true;
+      for (int i = 0; i < numElement; ++i)
+      {
+        if (axisDomainOrder(i))
+        {
+          maskValue = maskValue && (*domainMasks[idxDomain])(idxLoop[indexMap[i]],
+                                                          idxLoop[indexMap[i]+1]);
+          ++idxDomain;
+        }
+        else
+        {
+          maskValue = maskValue && (*axisMasks[idxAxis])(idxLoop[indexMap[i]]);
+          ++idxAxis;
+        }
+      }
+
+      int maskIndex = idxLoop[0];
+      int mulDim = 1;
+      for (int k = 1; k < dim; ++k)
+      {
+        mulDim *= eachDimSize[k-1];
+        maskIndex += idxLoop[k]*mulDim;
+      }
+      *(gridMask.dataFirst()+maskIndex) = maskValue;
+
+      ++idxLoop[0];
+      ++idx;
+    }
+
+   }
+
    ///--------------------------------------------------------------
 

XIOS/trunk/src/output/nc4_data_output.cpp

@@ -483 +483 @@
          if (axis->IsWritten(this->filename)) return;
          axis->checkAttributes();
-         StdSize zoom_size=axis->zoom_size.getValue() ;
-         StdSize zoom_begin=axis->zoom_begin.getValue()-1 ;
+         StdSize zoom_size_srv=axis->zoom_size_srv;
+         StdSize zoom_begin_srv=axis->zoom_begin_srv;
 
 
@@ -492 +492 @@
          try
          {
-           SuperClassWriter::addDimension(axisid, zoom_size);
+           SuperClassWriter::addDimension(axisid, zoom_size_srv);
            dims.push_back(axisid);
 
@@ -527 +527 @@
                  SuperClassWriter::definition_end();
 
-                 CArray<double,1> axis_value(zoom_size) ;
-                 for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ;
+                 CArray<double,1> axis_value(zoom_size_srv) ;
+                 for(StdSize i = 0 ; i < zoom_size_srv ; i++) axis_value(i)=axis->value(i+zoom_begin_srv) ;
                  SuperClassWriter::writeData(axis_value, axisid, isCollective, 0);
 
@@ -580 +580 @@
          std::vector<StdString> dims, coodinates;
          CGrid* grid = field->grid;
-         CDomain* domain = grid->domain;
-
-         if (domain->isEmpty())
-           if (SuperClass::type==MULTI_FILE) return ;
-
-         StdString timeid    = StdString("time_counter");
-         StdString domid     = (!domain->name.isEmpty())
-                             ? domain->name.getValue() : domain->getId();
-         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
-
-//         bool isCurvilinear = domain->isCurvilinear ;
-//         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ;
-
-         StdString dimXid,dimYid ;
-
-         switch (domain->type)
-         {
-           case CDomain::type_attr::curvilinear :
-             dimXid     = StdString("x").append(appendDomid);
-             dimYid     = StdString("y").append(appendDomid);
-             break ;
-           case CDomain::type_attr::regular :
-             dimXid     = StdString("lon").append(appendDomid);
-             dimYid     = StdString("lat").append(appendDomid);
-             break ;
-           case CDomain::type_attr::unstructured :
-             dimXid     = StdString("cell").append(appendDomid);
-             break ;
-        }
+         if (!grid->doGridHaveDataToWrite())
+          if (SuperClass::type==MULTI_FILE) return ;
+
+         CArray<bool,1> axisDomainOrder = grid->axisDomainOrder;
+         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
+         std::vector<StdString> domainList = grid->getDomainList();
+         std::vector<StdString> axisList   = grid->getAxisList();
+
+         StdString timeid  = StdString("time_counter");
+         StdString dimXid,dimYid;
+         std::deque<StdString> dimIdList, dimCoordList;
+
+         for (int i = 0; i < numElement; ++i)
+         {
+           if (axisDomainOrder(i))
+           {
+             CDomain* domain = CDomain::get(domainList[idxDomain]);
+             StdString domid = (!domain->name.isEmpty())
+                                 ? domain->name.getValue() : domain->getId();
+             StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
+             switch (domain->type)
+             {
+               case CDomain::type_attr::curvilinear :
+                 dimXid     = StdString("x").append(appendDomid);
+                 dimIdList.push_back(dimXid);
+                 dimYid     = StdString("y").append(appendDomid);
+                 dimIdList.push_back(dimYid);
+                 dimCoordList.push_back(StdString("nav_lon").append(appendDomid));
+                 dimCoordList.push_back(StdString("nav_lat").append(appendDomid));
+                 break ;
+               case CDomain::type_attr::regular :
+                 dimXid     = StdString("lon").append(appendDomid);
+                 dimIdList.push_back(dimXid);
+                 dimYid     = StdString("lat").append(appendDomid);
+                 dimIdList.push_back(dimYid);
+                 break ;
+               case CDomain::type_attr::unstructured :
+                 dimXid     = StdString("cell").append(appendDomid);
+                 dimIdList.push_back(dimXid);
+                 dimCoordList.push_back(StdString("lon").append(appendDomid));
+                 dimCoordList.push_back(StdString("lat").append(appendDomid));
+                 break ;
+            }
+            ++idxDomain;
+           }
+           else
+           {
+             CAxis* axis = CAxis::get(axisList[idxAxis]);
+             StdString axisid = (!axis->name.isEmpty())
+                                ? axis->name.getValue() : axis->getId();
+             dimIdList.push_back(axisid);
+             dimCoordList.push_back(axisid);
+            ++idxAxis;
+           }
+         }
 
 /*
@@ -648 +674 @@
          }
 
-         std::vector<StdString> axisList = grid->getAxisList();
-         if (!axisList.empty())
-         {
-           std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end();
-           for (; itAxis != iteAxis; ++itAxis)
-           {
-             CAxis* axis = CAxis::get(*itAxis);
-             StdString axisid = (!axis->name.isEmpty())
-                                ? axis->name.getValue() : axis->getId();
-
-             dims.push_back(axisid);
-             coodinates.push_back(axisid);
-           }
-         }
-
-         switch (domain->type)
-         {
-           case CDomain::type_attr::curvilinear :
-             coodinates.push_back(StdString("nav_lon").append(appendDomid));
-             coodinates.push_back(StdString("nav_lat").append(appendDomid));
-             break;
-           case CDomain::type_attr::regular :
-           case CDomain::type_attr::unstructured :
-            coodinates.push_back(StdString("lon").append(appendDomid));
-            coodinates.push_back(StdString("lat").append(appendDomid));
-             break;
-         }
-
-         if ( domain->type == CDomain::type_attr::curvilinear || domain->type == CDomain::type_attr::regular)dims.push_back(dimYid);
-         dims.push_back(dimXid);
+         while (!dimIdList.empty())
+         {
+           dims.push_back(dimIdList.back());
+           dimIdList.pop_back();
+         }
+
+         while (!dimCoordList.empty())
+         {
+           coodinates.push_back(dimCoordList.back());
+           dimCoordList.pop_back();
+         }
 
          try
@@ -772 +779 @@
          }
       }
+
+
+//      void CNc4DataOutput::writeField_(CField* field)
+//      {
+//         CContext* context = CContext::getCurrent() ;
+//         CContextServer* server=context->server ;
+//
+//         std::vector<StdString> dims, coodinates;
+//         CGrid* grid = field->grid;
+//         CDomain* domain = grid->domain;
+//
+//         if (domain->isEmpty())
+//           if (SuperClass::type==MULTI_FILE) return ;
+//
+//         StdString timeid    = StdString("time_counter");
+//         StdString domid     = (!domain->name.isEmpty())
+//                             ? domain->name.getValue() : domain->getId();
+//         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
+//
+////         bool isCurvilinear = domain->isCurvilinear ;
+////         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ;
+//
+//         StdString dimXid,dimYid ;
+//
+//         switch (domain->type)
+//         {
+//           case CDomain::type_attr::curvilinear :
+//             dimXid     = StdString("x").append(appendDomid);
+//             dimYid     = StdString("y").append(appendDomid);
+//             break ;
+//           case CDomain::type_attr::regular :
+//             dimXid     = StdString("lon").append(appendDomid);
+//             dimYid     = StdString("lat").append(appendDomid);
+//             break ;
+//           case CDomain::type_attr::unstructured :
+//             dimXid     = StdString("cell").append(appendDomid);
+//             break ;
+//        }
+//
+///*
+//         StdString lonid_loc = (server->intraCommSize > 1)
+//                             ? StdString("lon").append(appendDomid).append("_local")
+//                             : lonid;
+//         StdString latid_loc = (server->intraCommSize > 1)
+//                             ? StdString("lat").append(appendDomid).append("_local")
+//                             : latid;
+//*/
+//         StdString fieldid   = (!field->name.isEmpty())
+//                             ? field->name.getValue() : field->getBaseFieldReference()->getId();
+//
+////         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue();
+////         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize);
+////          bool isCurvilinear = domain->isCurvilinear ;
+//
+//         nc_type type ;
+//         if (field->prec.isEmpty()) type =  NC_FLOAT ;
+//         else
+//         {
+//           if (field->prec==2) type = NC_SHORT ;
+//           else if (field->prec==4)  type =  NC_FLOAT ;
+//           else if (field->prec==8)   type =  NC_DOUBLE ;
+//         }
+//
+//         bool wtime   = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once);
+//
+//         if (wtime)
+//         {
+//
+//            //StdOStringStream oss;
+//           // oss << "time_" << field->operation.getValue()
+//           //     << "_" << field->getRelFile()->output_freq.getValue();
+//          //oss
+//            if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant"));
+//            else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered"));
+//            dims.push_back(timeid);
+//         }
+//
+//         std::vector<StdString> axisList = grid->getAxisList();
+//         if (!axisList.empty())
+//         {
+//           std::vector<StdString>::const_iterator itAxis = axisList.begin(), iteAxis = axisList.end();
+//           for (; itAxis != iteAxis; ++itAxis)
+//           {
+//             CAxis* axis = CAxis::get(*itAxis);
+//             StdString axisid = (!axis->name.isEmpty())
+//                                ? axis->name.getValue() : axis->getId();
+//
+//             dims.push_back(axisid);
+//             coodinates.push_back(axisid);
+//           }
+//         }
+//
+//         switch (domain->type)
+//         {
+//           case CDomain::type_attr::curvilinear :
+//             coodinates.push_back(StdString("nav_lon").append(appendDomid));
+//             coodinates.push_back(StdString("nav_lat").append(appendDomid));
+//             break;
+//           case CDomain::type_attr::regular :
+//           case CDomain::type_attr::unstructured :
+//            coodinates.push_back(StdString("lon").append(appendDomid));
+//            coodinates.push_back(StdString("lat").append(appendDomid));
+//             break;
+//         }
+//
+//         if ( domain->type == CDomain::type_attr::curvilinear || domain->type == CDomain::type_attr::regular)dims.push_back(dimYid);
+//         dims.push_back(dimXid);
+//
+//         try
+//         {
+//           SuperClassWriter::addVariable(fieldid, type, dims);
+//
+//           if (!field->standard_name.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("standard_name",  field->standard_name.getValue(), &fieldid);
+//
+//           if (!field->long_name.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("long_name", field->long_name.getValue(), &fieldid);
+//
+//           if (!field->unit.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("units", field->unit.getValue(), &fieldid);
+//
+//            if (!field->valid_min.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("valid_min", field->valid_min.getValue(), &fieldid);
+//
+//           if (!field->valid_max.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("valid_max", field->valid_max.getValue(), &fieldid);
+//
+//            if (!field->scale_factor.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("scale_factor", field->scale_factor.getValue(), &fieldid);
+//
+//             if (!field->add_offset.isEmpty())
+//              SuperClassWriter::addAttribute
+//                 ("add_offset", field->add_offset.getValue(), &fieldid);
+//
+//           SuperClassWriter::addAttribute
+//                 ("online_operation", field->operation.getValue(), &fieldid);
+//
+//          // write child variables as attributes
+//
+//
+//           vector<CVariable*> listVars = field->getAllVariables() ;
+//           for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ;
+//
+//
+//           if (wtime)
+//           {
+//              CDuration duration = field->freq_op.getValue();
+//              duration.solveTimeStep(*(context->calendar));
+//              SuperClassWriter::addAttribute("interval_operation", duration.toString(), &fieldid);
+//
+//              duration = field->getRelFile()->output_freq.getValue();
+//              duration.solveTimeStep(*(context->calendar));
+//              SuperClassWriter::addAttribute("interval_write", duration.toString(), &fieldid);
+//           }
+//
+//           if (!field->default_value.isEmpty())
+//           {
+//              double default_value = field->default_value.getValue();
+//              float fdefault_value = (float)default_value;
+//              if (type == NC_DOUBLE)
+//                 SuperClassWriter::setDefaultValue(fieldid, &default_value);
+//              else
+//                 SuperClassWriter::setDefaultValue(fieldid, &fdefault_value);
+//           }
+//           else
+//              SuperClassWriter::setDefaultValue(fieldid, (double*)NULL);
+//
+//           {  // Ecriture des coordonnées
+//
+//              StdString coordstr; //boost::algorithm::join(coodinates, " ")
+//              std::vector<StdString>::iterator
+//                 itc = coodinates.begin(), endc = coodinates.end();
+//
+//              for (; itc!= endc; itc++)
+//              {
+//                 StdString & coord = *itc;
+//                 if (itc+1 != endc)
+//                       coordstr.append(coord).append(" ");
+//                 else  coordstr.append(coord);
+//              }
+//
+//              SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid);
+//
+//           }
+//         }
+//         catch (CNetCdfException& e)
+//         {
+//           StdString msg("On writing field : ");
+//           msg.append(fieldid); msg.append("\n");
+//           msg.append("In the context : ");
+//           msg.append(context->getId()); msg.append("\n");
+//           msg.append(e.what());
+//           ERROR("CNc4DataOutput::writeField_(CField* field)", << msg);
+//         }
+//      }
 
       //--------------------------------------------------------------
@@ -932 +1140 @@
 
          CGrid* grid = field->grid ;
-         CDomain* domain = grid->domain ;
-
-         if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return;
-
+
+         if (!grid->doGridHaveDataToWrite())
+          if (SuperClass::type==MULTI_FILE || !isCollective) return ;
 
          StdString fieldid   = (!field->name.isEmpty())
@@ -992 +1199 @@
          try
          {
-           if (grid->hasAxis()) // 3D
+           CArray<double,1> fieldData(grid->getWrittenDataSize());
+           if (!field->default_value.isEmpty()) fieldData = field->default_value;
+           field->outputField(fieldData);
+           if (!field->prec.isEmpty() && field->prec==2) fieldData=round(fieldData) ;
+
+           switch (SuperClass::type)
            {
-              CAxis* axis = grid->axis ;
-              CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ;
-              if (!field->default_value.isEmpty()) field_data3D = field->default_value ;
-
-              field->outputField(field_data3D);
-
-              if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ;
-
-              switch (SuperClass::type)
-             {
-                case (MULTI_FILE) :
+              case (MULTI_FILE) :
+              {
+                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1);
+                 if (wtime)
+                 {
+                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
+                   SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
+                   SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
+                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
+                 }
+                 break ;
+              }
+              case (ONE_FILE) :
+              {
+                std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
+                std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
+                std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
+
+                int ssize = nZoomBeginGlobal.size();
+
+                std::vector<StdSize> start(ssize) ;
+                std::vector<StdSize> count(ssize) ;
+
+                for (int i = 0; i < ssize; ++i)
                 {
-                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1);
-                   if (wtime)
-                   {
-                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
-                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
-                     SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
-                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
-                   }
-                   break ;
+                  start[i] = nZoomBeginServer[ssize-i-1] - nZoomBeginGlobal[ssize-i-1];
+                  count[i] = nZoomSizeServer[ssize-i-1];
                 }
-                case (ONE_FILE) :
-                {
-                   std::vector<StdSize> start(3) ;
-                   std::vector<StdSize> count(3) ;
-                   if (domain->isEmpty())
-                   {
-                     start[0]=0 ; start[1]=0 ; start[2]=0 ;
-                     count[0]=0 ; count[1]=0 ; start[2]=0 ;
-                   }
-                   else
-                   {
-  //                 start[2]=domain->zoom_ibegin_loc.getValue()-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()-domain->zoom_jbegin.getValue() ; start[0]=0 ;
-                     start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ;
-                     count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue();
-                   }
-                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count );
-                   if (wtime)
-                   {
-                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot );
-                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot );
-                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot );
-                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
-                   }
-                   break;
-                }
+
+                 SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1,&start,&count );
+                 if (wtime)
+                 {
+                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot );
+                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot );
+                   SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot );
+                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
+                 }
+                 break;
               }
-
-           }
-           else // 2D
-           {
-              CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ;
-              if (!field->default_value.isEmpty()) field_data2D = field->default_value ;
-              field->outputField(field_data2D);
-              if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ;
-              switch (SuperClass::type)
-              {
-                case (MULTI_FILE) :
-                {
-                  SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1);
-                  if (wtime)
-                  {
-                    SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
-                    SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
-                    SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
-                    SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
-                  }
-                  break;
-                }
-                case (ONE_FILE) :
-                {
-                   std::vector<StdSize> start(2) ;
-                   std::vector<StdSize> count(2) ;
-                   if (domain->isEmpty())
-                   {
-                     start[0]=0 ; start[1]=0 ;
-                     count[0]=0 ; count[1]=0 ;
-                   }
-                   else
-                   {
-                     start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
-                     count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
-                   }
-
-                   SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count);
-                   if (wtime)
-                   {
-                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot);
-                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot);
-                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot);
-                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
-                   }
-                   break;
-
-                }
-              }
-           }
+            }
          }
          catch (CNetCdfException& e)
@@ -1103 +1257 @@
          }
       }
+
+//      //---------------------------------------------------------------
+//
+//      void CNc4DataOutput::writeFieldData_ (CField*  field)
+//      {
+//         CContext* context = CContext::getCurrent() ;
+////          if (field->getRelFile()->isSyncTime()) SuperClassWriter::sync() ;
+//         CContextServer* server=context->server ;
+//
+//         CGrid* grid = field->grid ;
+//         CDomain* domain = grid->domain ;
+//
+//         if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return;
+//
+//
+//         StdString fieldid   = (!field->name.isEmpty())
+//                             ? field->name.getValue()
+//                             : field->getBaseFieldReference()->getId();
+//
+//         StdOStringStream oss;
+//         string timeAxisId ;
+//         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisId="time_instant" ;
+//         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisId="time_centered" ;
+//
+//         StdString timeBoundId("time_counter_bounds");
+//
+//         StdString timeAxisBoundId;
+//         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisBoundId="time_instant_bounds" ;
+//         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisBoundId="time_centered_bounds" ;
+//
+//         CArray<double,1> time_data(1) ;
+//         CArray<double,1> time_counter(1) ;
+//         CArray<double,1> time_counter_bound(2);
+//         CArray<double,1> time_data_bound(2);
+//
+//        bool wtime   = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once));
+//
+//        if (wtime)
+//        {
+//          time_counter(0)= (Time(*field->last_Write_srv) + Time(*field->lastlast_Write_srv)) / 2;
+//          if (field->foperation->timeType() == func::CFunctor::instant)
+//            time_data(0) = Time(*field->last_Write_srv);
+//          else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0);
+//
+//          time_counter_bound(0) = Time(*field->lastlast_Write_srv);
+//          time_counter_bound(1) = Time(*field->last_Write_srv);
+//          if (field->foperation->timeType() == func::CFunctor::instant)
+//            time_data_bound(0) = time_data_bound(1) = Time(*field->last_Write_srv);
+//          else if (field->foperation->timeType() == func::CFunctor::centered)
+//          {
+//            time_data_bound(0) = time_counter_bound(0);
+//            time_data_bound(1) = time_counter_bound(1);
+//          }
+//         }
+//
+//         bool isRoot ;
+//         if (server->intraCommRank==0) isRoot=true ;
+//         else isRoot=false ;
+//
+//         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
+//         {
+//           double scaleFactor=1. ;
+//           double addOffset=0. ;
+//           if (!field->scale_factor.isEmpty()) scaleFactor=field->scale_factor ;
+//           if (!field->add_offset.isEmpty()) addOffset=field->add_offset ;
+//           field->scaleFactorAddOffset(scaleFactor,addOffset) ;
+//         }
+//
+//         try
+//         {
+//           if (grid->hasAxis()) // 3D
+//           {
+//              CAxis* axis = grid->axis ;
+//              CArray<double,3> field_data3D(domain->zoom_ni_srv,domain->zoom_nj_srv,axis->zoom_size) ;
+//              if (!field->default_value.isEmpty()) field_data3D = field->default_value ;
+//
+//              field->outputField(field_data3D);
+//
+//              if (!field->prec.isEmpty() && field->prec==2) field_data3D=round(field_data3D) ;
+//
+//              switch (SuperClass::type)
+//             {
+//                case (MULTI_FILE) :
+//                {
+//                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1);
+//                   if (wtime)
+//                   {
+//                     SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
+//                     SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
+//                     SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
+//                     SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
+//                   }
+//                   break ;
+//                }
+//                case (ONE_FILE) :
+//                {
+//                   std::vector<StdSize> start(3) ;
+//                   std::vector<StdSize> count(3) ;
+//                   if (domain->isEmpty())
+//                   {
+//                     start[0]=0 ; start[1]=0 ; start[2]=0 ;
+//                     count[0]=0 ; count[1]=0 ; start[2]=0 ;
+//                   }
+//                   else
+//                   {
+//  //                 start[2]=domain->zoom_ibegin_loc.getValue()-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()-domain->zoom_jbegin.getValue() ; start[0]=0 ;
+//                     start[2]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; start[0]=0 ;
+//                     count[2]=domain->zoom_ni_srv ; count[1]=domain->zoom_nj_srv ; count[0] = axis->zoom_size.getValue();
+//                   }
+//                   SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count );
+//                   if (wtime)
+//                   {
+//                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot );
+//                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot );
+//                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot );
+//                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
+//                   }
+//                   break;
+//                }
+//              }
+//
+//           }
+//           else // 2D
+//           {
+//              CArray<double,2> field_data2D(domain->zoom_ni_srv,domain->zoom_nj_srv) ;
+//              if (!field->default_value.isEmpty()) field_data2D = field->default_value ;
+//              field->outputField(field_data2D);
+//              if (!field->prec.isEmpty() && field->prec==2) field_data2D=round(field_data2D) ;
+//              switch (SuperClass::type)
+//              {
+//                case (MULTI_FILE) :
+//                {
+//                  SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1);
+//                  if (wtime)
+//                  {
+//                    SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1);
+//                    SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1);
+//                    SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1);
+//                    SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1);
+//                  }
+//                  break;
+//                }
+//                case (ONE_FILE) :
+//                {
+//                   std::vector<StdSize> start(2) ;
+//                   std::vector<StdSize> count(2) ;
+//                   if (domain->isEmpty())
+//                   {
+//                     start[0]=0 ; start[1]=0 ;
+//                     count[0]=0 ; count[1]=0 ;
+//                   }
+//                   else
+//                   {
+//                     start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;
+//                     count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;
+//                   }
+//
+//                   SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count);
+//                   if (wtime)
+//                   {
+//                     SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot);
+//                     SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot);
+//                     SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot);
+//                     SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot);
+//                   }
+//                   break;
+//
+//                }
+//              }
+//           }
+//         }
+//         catch (CNetCdfException& e)
+//         {
+//           StdString msg("On writing field data: ");
+//           msg.append(fieldid); msg.append("\n");
+//           msg.append("In the context : ");
+//           msg.append(context->getId()); msg.append("\n");
+//           msg.append(e.what());
+//           ERROR("CNc4DataOutput::writeFieldData_ (CField*  field)", << msg);
+//         }
+//      }
 
       //---------------------------------------------------------------

XIOS/trunk/src/test/test_new_features.f90

@@ -25 +25 @@
 
   DOUBLE PRECISION,DIMENSION(ni_glo,nj_glo) :: lon_glo,lat_glo
-  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm)
-  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), lonvalue(:) ;
-  INTEGER :: ni,ibegin,iend,nj,jbegin,jend
+  DOUBLE PRECISION :: field_A_glo(ni_glo,nj_glo,llm), lval_ni(ni_glo), lval_nj(nj_glo)
+  DOUBLE PRECISION,ALLOCATABLE :: lon(:,:),lat(:,:),field_A(:,:,:), field_All_Axis(:,:,:), lonvalue(:) , field_Axis(:)
+  INTEGER :: ni,ibegin,iend,nj,jbegin,jend, nAxis, axisBegin, axisEnd
   INTEGER :: i,j,l,ts,n
 
@@ -47 +47 @@
       lon_glo(i,j)=(i-1)+(j-1)*ni_glo
       lat_glo(i,j)=1000+(i-1)+(j-1)*ni_glo
+      lval_ni(i) = i-1
       DO l=1,llm
         field_A_glo(i,j,l)=(i-1)+(j-1)*ni_glo+10000*l
       ENDDO
     ENDDO
+    lval_nj(j) = j-1
   ENDDO
   ni=ni_glo ; ibegin=0
@@ -61 +63 @@
     jbegin=jbegin+nj
   ENDDO
-
   iend=ibegin+ni-1 ; jend=jbegin+nj-1
 
-  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj))
+  axisBegin = 0
+  nAxis = llm
+!  DO n=0, size -1
+!    nAxis = llm/size
+!    IF (n<MOD(llm,size)) nAxis=nAxis+1
+!    IF (n==rank) exit
+!    axisBegin=axisBegin+nAxis
+!  ENDDO
+  axisEnd=axisBegin+nAxis-1
+
+  ALLOCATE(lon(ni,nj),lat(ni,nj),field_A(0:ni+1,-1:nj+2,llm),lonvalue(ni*nj), field_Axis(nAxis), field_All_Axis(1:ni,1:nj,llm))
   lon(:,:)=lon_glo(ibegin+1:iend+1,jbegin+1:jend+1)
   lat(:,:)=lat_glo(ibegin+1:iend+1,jbegin+1:jend+1)
-  field_A(1:ni,1:nj,:)=field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
+  field_A(1:ni,1:nj,:) = field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
+  field_Axis(1:nAxis)  = field_A_glo(1,1,axisBegin+1:axisEnd+1)
+  field_All_Axis(1:ni,1:nj,:) = field_A_glo(ibegin+1:iend+1,jbegin+1:jend+1,:)
 
   CALL xios_context_initialize("test",comm)
@@ -73 +86 @@
   CALL xios_set_current_context(ctx_hdl)
 
-  CALL xios_get_calendar_type(calendar_type)
-  PRINT *, "calendar_type = ", calendar_type
+!  CALL xios_get_calendar_type(calendar_type)
+!  PRINT *, "calendar_type = ", calendar_type
 
-  CALL xios_set_axis_attr("axis_A",size=llm ,value=lval) ;
+  CALL xios_set_axis_attr("axis_A", size=ni_glo, ibegin=ibegin, ni=ni, value=lval_ni)
+  CALL xios_set_axis_attr("axis_B", size=nj_glo, ibegin=jbegin, ni=nj, value=lval_nj)
+  CALL xios_set_axis_attr("axis_C", size=llm, value=lval)
+  CALL xios_set_axis_attr("axis_D", size=llm, value=lval)
   CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj)
   CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4)
@@ -89 +105 @@
   CALL xios_add_child(file_hdl,field_hdl)
   CALL xios_set_attr(field_hdl,field_ref="field_A",name="field_C")
+
+  CALL xios_get_handle("output_Axis",file_hdl)
+  CALL xios_add_child(file_hdl,field_hdl)
+  CALL xios_set_attr(field_hdl,field_ref="field_All_Axis",name="field_C")
 
   dtime%second = 3600
@@ -126 +146 @@
     CALL xios_update_calendar(ts)
     CALL xios_send_field("field_A",field_A)
+    CALL xios_send_field("field_Axis",field_Axis)
+    CALL xios_send_field("field_All_Axis",field_All_Axis)
     CALL wait_us(5000) ;
   ENDDO