Changeset 676

Timestamp:

08/25/15 16:52:45 (9 years ago)

Author:

rlacroix

Message:

Add support for indexed output.

If the new field attribute "indexed_output" is set to true and a mask is defined (either at grid, domain or axis level), the indexed data will be outputed instead of the full data with missing values.

See ​http://cfconventions.org/Data/cf-conventions/cf-conventions-1.5/build/cf-conventions.html#compression-by-gathering for more information.

Location:

XIOS/trunk/src

Files:

• config/field_attribute.conf (modified) (1 diff)
• data_output.cpp (modified) (3 diffs)
• data_output.hpp (modified) (2 diffs)
• distribution_client.hpp (modified) (2 diffs)
• distribution_server.cpp (modified) (1 diff)
• distribution_server.hpp (modified) (1 diff)
• interface/c_attr/icfield_attr.cpp (modified) (1 diff)
• interface/c_attr/icfieldgroup_attr.cpp (modified) (1 diff)
• interface/fortran_attr/field_interface_attr.F90 (modified) (1 diff)
• interface/fortran_attr/fieldgroup_interface_attr.F90 (modified) (1 diff)
• interface/fortran_attr/ifield_attr.F90 (modified) (27 diffs)
• interface/fortran_attr/ifieldgroup_attr.F90 (modified) (27 diffs)
• node/axis.cpp (modified) (22 diffs)
• node/axis.hpp (modified) (4 diffs)
• node/context.cpp (modified) (2 diffs)
• node/context.hpp (modified) (1 diff)
• node/domain.cpp (modified) (21 diffs)
• node/domain.hpp (modified) (6 diffs)
• node/field.cpp (modified) (6 diffs)
• node/field.hpp (modified) (3 diffs)
• node/grid.cpp (modified) (13 diffs)
• node/grid.hpp (modified) (11 diffs)
• output/nc4_data_output.cpp (modified) (7 diffs)
• output/nc4_data_output.hpp (modified) (1 diff)
• output/onetcdf4_decl.cpp (modified) (1 diff)

XIOS/trunk/src/config/field_attribute.conf

@@ -14 +14 @@
 DECLARE_ATTRIBUTE(bool,      enabled)
 DECLARE_ATTRIBUTE(bool,      read_access)
+DECLARE_ATTRIBUTE(bool,      indexed_output)
 
 DECLARE_ATTRIBUTE(StdString, domain_ref)

XIOS/trunk/src/data_output.cpp

@@ -14 +14 @@
       //----------------------------------------------------------------
 
-      void CDataOutput::writeGrid(CGrid* grid)
+      void CDataOutput::writeGrid(CGrid* grid, bool allowCompressedOutput /*= false*/)
       {
-//         if (grid->domain_ref.isEmpty())
-//            ERROR("CDataOutput::writeGrid(grid)",
-//                   << " domain is not defined !");
-//
-//         if (grid->axis_ref.isEmpty())
-//         {
-//            this->writeGrid(CDomain::get(grid->domain_ref.getValue()));
-//         }
-//         else
-//         {
-//            this->writeGrid(CDomain::get(grid->domain_ref.getValue()),
-//                            CAxis::get(grid->axis_ref.getValue()));
-//         }
-//        this->writeGrid(grid->domain, grid->axis);
         this->writeGrid(grid->getDomains(), grid->getAxis());
+
+        if (allowCompressedOutput)
+          writeGridCompressed_(grid);
       }
 
@@ -57 +46 @@
       //----------------------------------------------------------------
 
-      void CDataOutput::writeGrid(CDomain* domain,CAxis* axis)
+      void CDataOutput::writeGrid(CDomain* domain, CAxis* axis)
       {
          this->writeDomain_(domain);
@@ -98 +87 @@
       void CDataOutput::writeFieldGrid(CField* field)
       {
-         this->writeGrid(field->getRelGrid());
+         this->writeGrid(field->getRelGrid(),
+                         !field->indexed_output.isEmpty() && field->indexed_output);
       }
 

XIOS/trunk/src/data_output.hpp

@@ -20 +20 @@
 
             /// Ecriture ///
-            void writeFile     (CFile*  file);
-            void writeAttribute(CVariable*  var);
-            void syncFile     (void);
+            void writeFile     (CFile*     file);
+            void writeAttribute(CVariable* var);
+            void syncFile      (void);
             void closeFile     (void);
             void writeField    (CField* field);
@@ -40 +40 @@
 
             /// Ecriture ///
-            void writeGrid(CGrid* grid);
-            void writeGrid(CDomain* domain,
-                           CAxis*   axis);
+            void writeGrid(CGrid* grid, bool allowCompressedOutput = false);
+            void writeGrid(CDomain* domain, CAxis* axis);
             void writeGrid(CDomain* domain);
             void writeGrid(std::vector<CDomain*> domain, std::vector<CAxis*> axis);
 
-            virtual void writeFile_       (CFile*     file)   = 0;
-            virtual void writeAttribute_(CVariable*  var) = 0 ;
-            virtual void closeFile_       (void)                                            = 0;
-            virtual void syncFile_       (void)                                            = 0;
-            virtual void writeField_      (CField*    field)  = 0;
-            virtual void writeFieldData_  (CField*    field)  = 0;
-            virtual void writeDomain_     (CDomain*   domain) = 0;
-            virtual void writeTimeDimension_ (void) = 0;
-            virtual void writeAxis_       (CAxis*     axis)   = 0;
-            virtual void writeTimeAxis_   (CField*    field,
-                                           const shared_ptr<CCalendar> cal)    = 0;
+            virtual void writeFile_     (CFile*      file)   = 0;
+            virtual void writeAttribute_(CVariable*  var)    = 0;
+            virtual void closeFile_     (void)               = 0;
+            virtual void syncFile_      (void)               = 0;
+            virtual void writeField_    (CField*     field)  = 0;
+            virtual void writeFieldData_(CField*     field)  = 0;
+            virtual void writeDomain_   (CDomain*    domain) = 0;
+            virtual void writeAxis_     (CAxis*      axis)   = 0;
+            virtual void writeGridCompressed_(CGrid* grid)   = 0;
+            virtual void writeTimeDimension_(void)           = 0;
+            virtual void writeTimeAxis_ (CField*     field,
+                                         const shared_ptr<CCalendar> cal) = 0;
 
             /// Propriétés protégées ///

XIOS/trunk/src/distribution_client.hpp

@@ -46 +46 @@
     bool isDataDistributed() { return isDataDistributed_; }
 
+    static int getDomainIndex(const int& dataIIndex, const int& dataJIndex,
+                                     const int& dataIBegin, const int& dataJBegin,
+                                     const int& dataDim, const int& ni, int& j);
+    static int getAxisIndex(const int& dataIndex, const int& dataBegin, const int& ni);
+
   protected:
     void createGlobalIndex();
@@ -61 +66 @@
     //! Create local index of an axis
     void createLocalAxisDataIndex();
-
-    inline int getDomainIndex(const int& dataIIndex, const int& dataJIndex,
-                              const int& dataIBegin, const int& dataJBegin,
-                              const int& dataDim, const int& ni, int& j);
-    inline int getAxisIndex(const int& dataIndex, const int& dataBegin, const int& ni);
 
     template<int N>

XIOS/trunk/src/distribution_server.cpp

@@ -146 +146 @@
 }
 
+/*!
+  Transforms local indexes owned by the server into global indexes
+  \param [in/out] indexes on input, local indexes of the server,
+                          on output, the corresponding global indexes
+*/
+void CDistributionServer::computeGlobalIndex(CArray<int,1>& indexes) const
+{
+  for (int i = 0; i < indexes.numElements(); ++i)
+  {
+    indexes(i) = globalIndex_(indexes(i));
+  }
+}
 
-std::vector<int> CDistributionServer::getZoomBeginGlobal() const
+
+const std::vector<int>& CDistributionServer::getZoomBeginGlobal() const
 {
   return nZoomBeginGlobal_;
 }
 
-std::vector<int> CDistributionServer::getZoomBeginServer() const
+const std::vector<int>& CDistributionServer::getZoomBeginServer() const
 {
   return nZoomBegin_;
 }
 
-std::vector<int> CDistributionServer::getZoomSizeServer() const
+const std::vector<int>& CDistributionServer::getZoomSizeServer() const
 {
   return nZoomSize_;

XIOS/trunk/src/distribution_server.hpp

@@ -34 +34 @@
     virtual ~CDistributionServer();
 
-    std::vector<int> getZoomBeginGlobal() const;
-    std::vector<int> getZoomBeginServer() const;
-    std::vector<int> getZoomSizeServer() const;
+    const std::vector<int>& getZoomBeginGlobal() const;
+    const std::vector<int>& getZoomBeginServer() const;
+    const std::vector<int>& getZoomSizeServer() const;
 
     virtual CArray<size_t,1> computeLocalIndex(const CArray<size_t,1>& globalIndex);
     virtual void computeLocalIndex(CArray<size_t,1>& globalIndex);
+    virtual void computeGlobalIndex(CArray<int,1>& indexes) const;
 
   protected:

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

@@ -313 +313 @@
 
 
+  void cxios_set_field_indexed_output(field_Ptr field_hdl, bool indexed_output)
+  {
+    CTimer::get("XIOS").resume();
+    field_hdl->indexed_output.setValue(indexed_output);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_field_indexed_output(field_Ptr field_hdl, bool* indexed_output)
+  {
+    CTimer::get("XIOS").resume();
+    *indexed_output = field_hdl->indexed_output.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_field_indexed_output(field_Ptr field_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = field_hdl->indexed_output.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_field_level(field_Ptr field_hdl, int level)
   {

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

@@ -339 +339 @@
 
 
+  void cxios_set_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl, bool indexed_output)
+  {
+    CTimer::get("XIOS").resume();
+    fieldgroup_hdl->indexed_output.setValue(indexed_output);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl, bool* indexed_output)
+  {
+    CTimer::get("XIOS").resume();
+    *indexed_output = fieldgroup_hdl->indexed_output.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_fieldgroup_indexed_output(fieldgroup_Ptr fieldgroup_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = fieldgroup_hdl->indexed_output.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
   void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
   {

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

@@ -231 +231 @@
 
 
+    SUBROUTINE cxios_set_field_indexed_output(field_hdl, indexed_output) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: indexed_output
+    END SUBROUTINE cxios_set_field_indexed_output
+
+    SUBROUTINE cxios_get_field_indexed_output(field_hdl, indexed_output) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+      LOGICAL (KIND=C_BOOL)             :: indexed_output
+    END SUBROUTINE cxios_get_field_indexed_output
+
+    FUNCTION cxios_is_defined_field_indexed_output(field_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_field_indexed_output
+      INTEGER (kind = C_INTPTR_T), VALUE :: field_hdl
+    END FUNCTION cxios_is_defined_field_indexed_output
+
+
     SUBROUTINE cxios_set_field_level(field_hdl, level) BIND(C)
       USE ISO_C_BINDING

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

@@ -252 +252 @@
 
 
+    SUBROUTINE cxios_set_fieldgroup_indexed_output(fieldgroup_hdl, indexed_output) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: indexed_output
+    END SUBROUTINE cxios_set_fieldgroup_indexed_output
+
+    SUBROUTINE cxios_get_fieldgroup_indexed_output(fieldgroup_hdl, indexed_output) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+      LOGICAL (KIND=C_BOOL)             :: indexed_output
+    END SUBROUTINE cxios_get_fieldgroup_indexed_output
+
+    FUNCTION cxios_is_defined_fieldgroup_indexed_output(fieldgroup_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_fieldgroup_indexed_output
+      INTEGER (kind = C_INTPTR_T), VALUE :: fieldgroup_hdl
+    END FUNCTION cxios_is_defined_fieldgroup_indexed_output
+
+
     SUBROUTINE cxios_set_fieldgroup_level(fieldgroup_hdl, level) BIND(C)
       USE ISO_C_BINDING

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

@@ -13 +13 @@
   SUBROUTINE xios(set_field_attr)  &
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -32 +32 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: freq_op
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
@@ -48 +50 @@
       CALL xios(set_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(set_field_attr)
@@ -55 +57 @@
   SUBROUTINE xios(set_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -73 +75 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: freq_op
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
@@ -88 +92 @@
       CALL xios(set_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(set_field_attr_hdl)
@@ -95 +99 @@
   SUBROUTINE xios(set_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, level_, long_name_, name_  &
-    , operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, indexed_output_, level_  &
+    , long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_  &
+    , valid_min_ )
 
     IMPLICIT NONE
@@ -114 +118 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(IN) :: freq_op_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output_
+      LOGICAL (KIND=C_BOOL) :: indexed_output__tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
@@ -173 +179 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        indexed_output__tmp = indexed_output_
+        CALL cxios_set_field_indexed_output(field_hdl%daddr, indexed_output__tmp)
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         CALL cxios_set_field_level(field_hdl%daddr, level_)
@@ -222 +233 @@
   SUBROUTINE xios(get_field_attr)  &
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -241 +252 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: freq_op
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
@@ -257 +270 @@
       CALL xios(get_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(get_field_attr)
@@ -264 +277 @@
   SUBROUTINE xios(get_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -282 +295 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: freq_op
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
@@ -297 +312 @@
       CALL xios(get_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(get_field_attr_hdl)
@@ -304 +319 @@
   SUBROUTINE xios(get_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, level_, long_name_, name_  &
-    , operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, indexed_output_, level_  &
+    , long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_  &
+    , valid_min_ )
 
     IMPLICIT NONE
@@ -323 +338 @@
       TYPE(txios(duration))  , OPTIONAL, INTENT(OUT) :: freq_op_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output_
+      LOGICAL (KIND=C_BOOL) :: indexed_output__tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
@@ -382 +399 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        CALL cxios_get_field_indexed_output(field_hdl%daddr, indexed_output__tmp)
+        indexed_output_ = indexed_output__tmp
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         CALL cxios_get_field_level(field_hdl%daddr, level_)
@@ -431 +453 @@
   SUBROUTINE xios(is_defined_field_attr)  &
     ( field_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -459 +481 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
       LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL(KIND=C_BOOL) :: indexed_output_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level
       LOGICAL(KIND=C_BOOL) :: level_tmp
@@ -485 +509 @@
       CALL xios(is_defined_field_attr_hdl_)   &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(is_defined_field_attr)
@@ -492 +516 @@
   SUBROUTINE xios(is_defined_field_attr_hdl)  &
     ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-    , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-    , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+    , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+    , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
     IMPLICIT NONE
@@ -519 +543 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref
       LOGICAL(KIND=C_BOOL) :: grid_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL(KIND=C_BOOL) :: indexed_output_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level
       LOGICAL(KIND=C_BOOL) :: level_tmp
@@ -544 +570 @@
       CALL xios(is_defined_field_attr_hdl_)  &
       ( field_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value, domain_ref  &
-      , enabled, field_ref, freq_offset, freq_op, grid_ref, level, long_name, name, operation, prec  &
-      , read_access, scale_factor, standard_name, unit, valid_max, valid_min )
+      , enabled, field_ref, freq_offset, freq_op, grid_ref, indexed_output, level, long_name, name  &
+      , operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min )
 
   END SUBROUTINE xios(is_defined_field_attr_hdl)
@@ -551 +577 @@
   SUBROUTINE xios(is_defined_field_attr_hdl_)   &
     ( field_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, level_, long_name_, name_  &
-    , operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, indexed_output_, level_  &
+    , long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_  &
+    , valid_min_ )
 
     IMPLICIT NONE
@@ -579 +605 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: grid_ref_
       LOGICAL(KIND=C_BOOL) :: grid_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output_
+      LOGICAL(KIND=C_BOOL) :: indexed_output__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level_
       LOGICAL(KIND=C_BOOL) :: level__tmp
@@ -657 +685 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        indexed_output__tmp = cxios_is_defined_field_indexed_output(field_hdl%daddr)
+        indexed_output_ = indexed_output__tmp
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         level__tmp = cxios_is_defined_field_level(field_hdl%daddr)

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

@@ -13 +13 @@
   SUBROUTINE xios(set_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -34 +34 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
@@ -50 +52 @@
       CALL xios(set_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(set_fieldgroup_attr)
@@ -58 +60 @@
   SUBROUTINE xios(set_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -78 +80 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name
@@ -93 +97 @@
       CALL xios(set_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(set_fieldgroup_attr_hdl)
@@ -101 +105 @@
   SUBROUTINE xios(set_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, level_, long_name_  &
-    , name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, indexed_output_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , unit_, valid_max_, valid_min_ )
 
     IMPLICIT NONE
@@ -121 +125 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: grid_ref_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: group_ref_
+      LOGICAL  , OPTIONAL, INTENT(IN) :: indexed_output_
+      LOGICAL (KIND=C_BOOL) :: indexed_output__tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: level_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: long_name_
@@ -184 +190 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        indexed_output__tmp = indexed_output_
+        CALL cxios_set_fieldgroup_indexed_output(fieldgroup_hdl%daddr, indexed_output__tmp)
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         CALL cxios_set_fieldgroup_level(fieldgroup_hdl%daddr, level_)
@@ -233 +244 @@
   SUBROUTINE xios(get_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -254 +265 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
@@ -270 +283 @@
       CALL xios(get_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(get_fieldgroup_attr)
@@ -278 +291 @@
   SUBROUTINE xios(get_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -298 +311 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL (KIND=C_BOOL) :: indexed_output_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name
@@ -313 +328 @@
       CALL xios(get_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(get_fieldgroup_attr_hdl)
@@ -321 +336 @@
   SUBROUTINE xios(get_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, level_, long_name_  &
-    , name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, indexed_output_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , unit_, valid_max_, valid_min_ )
 
     IMPLICIT NONE
@@ -341 +356 @@
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: grid_ref_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: group_ref_
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: indexed_output_
+      LOGICAL (KIND=C_BOOL) :: indexed_output__tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: level_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: long_name_
@@ -404 +421 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        CALL cxios_get_fieldgroup_indexed_output(fieldgroup_hdl%daddr, indexed_output__tmp)
+        indexed_output_ = indexed_output__tmp
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         CALL cxios_get_fieldgroup_level(fieldgroup_hdl%daddr, level_)
@@ -453 +475 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr)  &
     ( fieldgroup_id, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -484 +506 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL(KIND=C_BOOL) :: indexed_output_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level
       LOGICAL(KIND=C_BOOL) :: level_tmp
@@ -510 +534 @@
       CALL xios(is_defined_fieldgroup_attr_hdl_)   &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr)
@@ -518 +542 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)  &
     ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-    , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-     )
+    , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+    , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+    , valid_min )
 
     IMPLICIT NONE
@@ -548 +572 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref
       LOGICAL(KIND=C_BOOL) :: group_ref_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output
+      LOGICAL(KIND=C_BOOL) :: indexed_output_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level
       LOGICAL(KIND=C_BOOL) :: level_tmp
@@ -573 +599 @@
       CALL xios(is_defined_fieldgroup_attr_hdl_)  &
       ( fieldgroup_hdl, add_offset, axis_ref, compression_level, default_value, detect_missing_value  &
-      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, level, long_name  &
-      , name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max, valid_min  &
-       )
+      , domain_ref, enabled, field_ref, freq_offset, freq_op, grid_ref, group_ref, indexed_output  &
+      , level, long_name, name, operation, prec, read_access, scale_factor, standard_name, unit, valid_max  &
+      , valid_min )
 
   END SUBROUTINE xios(is_defined_fieldgroup_attr_hdl)
@@ -581 +607 @@
   SUBROUTINE xios(is_defined_fieldgroup_attr_hdl_)   &
     ( fieldgroup_hdl, add_offset_, axis_ref_, compression_level_, default_value_, detect_missing_value_  &
-    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, level_, long_name_  &
-    , name_, operation_, prec_, read_access_, scale_factor_, standard_name_, unit_, valid_max_, valid_min_  &
-     )
+    , domain_ref_, enabled_, field_ref_, freq_offset_, freq_op_, grid_ref_, group_ref_, indexed_output_  &
+    , level_, long_name_, name_, operation_, prec_, read_access_, scale_factor_, standard_name_  &
+    , unit_, valid_max_, valid_min_ )
 
     IMPLICIT NONE
@@ -611 +637 @@
       LOGICAL, OPTIONAL, INTENT(OUT) :: group_ref_
       LOGICAL(KIND=C_BOOL) :: group_ref__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: indexed_output_
+      LOGICAL(KIND=C_BOOL) :: indexed_output__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: level_
       LOGICAL(KIND=C_BOOL) :: level__tmp
@@ -694 +722 @@
       ENDIF
 
+      IF (PRESENT(indexed_output_)) THEN
+        indexed_output__tmp = cxios_is_defined_fieldgroup_indexed_output(fieldgroup_hdl%daddr)
+        indexed_output_ = indexed_output__tmp
+      ENDIF
+
       IF (PRESENT(level_)) THEN
         level__tmp = cxios_is_defined_fieldgroup_level(fieldgroup_hdl%daddr)

XIOS/trunk/src/node/axis.cpp

@@ -8 +8 @@
 #include "context.hpp"
 #include "context_client.hpp"
+#include "context_server.hpp"
 #include "xios_spl.hpp"
 #include "inverse_axis.hpp"
@@ -14 +15 @@
 #include "server_distribution_description.hpp"
 #include "client_server_mapping_distributed.hpp"
+#include "distribution_client.hpp"
 
 namespace xios {
@@ -22 +24 @@
       : CObjectTemplate<CAxis>()
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
-      , isDistributed_(false), hasBounds_(false)
+      , isDistributed_(false), hasBounds_(false), isCompressible_(false)
+      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
       , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
    {
@@ -30 +33 @@
       : CObjectTemplate<CAxis>(id)
       , CAxisAttributes(), isChecked(false), relFiles(), baseRefObject(), areClientAttributesChecked_(false)
-      , isDistributed_(false), hasBounds_(false)
+      , isDistributed_(false), hasBounds_(false), isCompressible_(false)
+      , numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
       , transformationMap_(), global_zoom_begin(0), global_zoom_size(0)
    {
@@ -50 +54 @@
    }
 
+   bool CAxis::isWrittenCompressed(const StdString& filename) const
+   {
+      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
+   }
+
    bool CAxis::isDistributed(void) const
    {
@@ -55 +64 @@
    }
 
+   /*!
+    * Test whether the data defined on the axis can be outputted in a compressed way.
+    * 
+    * \return true if and only if a mask was defined for this axis
+    */
+   bool CAxis::isCompressible(void) const
+   {
+      return isCompressible_;
+   }
+
    void CAxis::addRelFile(const StdString & filename)
    {
       this->relFiles.insert(filename);
+   }
+
+   void CAxis::addRelFileCompressed(const StdString& filename)
+   {
+      this->relFilesCompressed.insert(filename);
+   }
+
+   //----------------------------------------------------------------
+
+   const std::vector<int>& CAxis::getIndexesToWrite(void) const
+   {
+     return indexesToWrite;
+   }
+
+   /*!
+     Returns the number of indexes written by each server.
+     \return the number of indexes written by each server
+   */
+   int CAxis::getNumberWrittenIndexes() const
+   {
+     return numberWrittenIndexes_;
+   }
+
+   /*!
+     Returns the total number of indexes written by the servers.
+     \return the total number of indexes written by the servers
+   */
+   int CAxis::getTotalNumberWrittenIndexes() const
+   {
+     return totalNumberWrittenIndexes_;
+   }
+
+   /*!
+     Returns the offset of indexes written by each server.
+     \return the offset of indexes written by each server
+   */
+   int CAxis::getOffsetWrittenIndexes() const
+   {
+     return offsetWrittenIndexes_;
    }
 
@@ -171 +229 @@
   }
 
+  void CAxis::checkEligibilityForCompressedOutput()
+  {
+    // We don't check if the mask is valid here, just if a mask has been defined at this point.
+    isCompressible_ = !mask.isEmpty();
+  }
 
   bool CAxis::dispatchEvent(CEventServer& event)
@@ -277 +340 @@
     }
 
+    std::set<int> writtenInd;
+    if (isCompressible_)
+    {
+      for (int idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, ni);
+
+        if (ind >= 0 && ind < ni && mask(ind))
+        {
+          ind += ibegin;
+          if (ind >= global_zoom_begin && ind <= zoom_end)
+            writtenInd.insert(ind);
+        }
+      }
+    }
+
     std::vector<int> nGlobDomain(1);
     nGlobDomain[0] = n_glo.getValue();
@@ -303 +382 @@
                                         iteVec = (globalAxisZoom).end();
     indSrv_.clear();
+    indWrittenSrv_.clear();
     for (; it != ite; ++it)
     {
@@ -315 +395 @@
           indSrv_[rank].push_back(globalIndexTmp[i]);
         }
+
+        if (writtenInd.count(globalIndexTmp[i]))
+        {
+          indWrittenSrv_[rank].push_back(globalIndexTmp[i]);
+        }
       }
     }
@@ -337 +422 @@
     CContext* context = CContext::getCurrent();
     CContextClient* client = context->client;
-    CEventClient event(getType(),EVENT_ID_NON_DISTRIBUTED_VALUE);
-
-    int zoom_end = global_zoom_begin+global_zoom_size-1;
-    int nb =0;
+    CEventClient event(getType(), EVENT_ID_NON_DISTRIBUTED_VALUE);
+
+    int zoom_end = global_zoom_begin + global_zoom_size - 1;
+    int nb = 0;
     for (size_t idx = 0; idx < n; ++idx)
     {
       size_t globalIndex = begin + idx;
       if (globalIndex >= global_zoom_begin && globalIndex <= zoom_end) ++nb;
+    }
+
+    int nbWritten = 0;
+    if (isCompressible_)
+    {
+      for (int idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, n);
+
+        if (ind >= 0 && ind < n && mask(ind))
+        {
+          ind += begin;
+          if (ind >= global_zoom_begin && ind <= zoom_end)
+            ++nbWritten;
+        }
+      }
     }
 
@@ -359 +460 @@
     }
 
+    CArray<int, 1> writtenInd(nbWritten);
+    nbWritten = 0;
+    if (isCompressible_)
+    {
+      for (int idx = 0; idx < data_index.numElements(); ++idx)
+      {
+        int ind = CDistributionClient::getAxisIndex(data_index(idx), data_begin, n);
+
+        if (ind >= 0 && ind < n && mask(ind))
+        {
+          ind += begin;
+          if (ind >= global_zoom_begin && ind <= zoom_end)
+          {
+            writtenInd(nbWritten) = ind;
+            ++nbWritten;
+          }
+        }
+      }
+    }
+
     if (client->isServerLeader())
     {
@@ -366 +487 @@
       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank)
       {
-        // Use const int to ensure CMessage holds a copy of the value instead of just a reference
         msgs.push_back(CMessage());
         CMessage& msg = msgs.back();
         msg << this->getId();
         msg << val;
-        event.push(*itRank,1,msg);
+        if (isCompressible_)
+          msg << writtenInd;
+        event.push(*itRank, 1, msg);
       }
       client->sendEvent(event);
@@ -390 +512 @@
     list<CMessage> list_msgsIndex, list_msgsVal;
     list<CArray<int,1> > list_indi;
+    list<CArray<int,1> > list_writtenInd;
     list<CArray<double,1> > list_val;
     list<CArray<double,2> > list_bounds;
@@ -433 +556 @@
       list_msgsIndex.back() << this->getId() << list_indi.back();
 
+      if (isCompressible_)
+      {
+        std::vector<int>& writtenIndSrc = indWrittenSrv_[rank];
+        list_writtenInd.push_back(CArray<int,1>(writtenIndSrc.size()));
+        CArray<int,1>& writtenInd = list_writtenInd.back();
+
+        for (n = 0; n < writtenInd.numElements(); ++n)
+          writtenInd(n) = writtenIndSrc[n];
+
+        list_msgsIndex.back() << writtenInd;
+      }
+
       list_msgsVal.push_back(CMessage());
       list_msgsVal.back() << this->getId() << list_val.back();
@@ -451 +586 @@
   void CAxis::recvIndex(CEventServer& event)
   {
+    CAxis* axis;
+
     list<CEventServer::SSubEvent>::iterator it;
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
     {
       CBufferIn* buffer = it->buffer;
-      string domainId;
-      *buffer >> domainId;
-      get(domainId)->recvIndex(it->rank, *buffer);
+      string axisId;
+      *buffer >> axisId;
+      axis = get(axisId);
+      axis->recvIndex(it->rank, *buffer);
+    }
+
+    if (axis->isCompressible_)
+    {
+      std::sort(axis->indexesToWrite.begin(), axis->indexesToWrite.end());
+
+      CContextServer* server = CContext::getCurrent()->server;
+      axis->numberWrittenIndexes_ = axis->indexesToWrite.size();
+      MPI_Allreduce(&axis->numberWrittenIndexes_, &axis->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      MPI_Scan(&axis->numberWrittenIndexes_, &axis->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      axis->offsetWrittenIndexes_ -= axis->numberWrittenIndexes_;
     }
   }
@@ -464 +613 @@
   {
     buffer >> indiSrv_[rank];
+
+    if (isCompressible_)
+    {
+      CArray<int, 1> writtenIndexes;
+      buffer >> writtenIndexes;
+      indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
+      for (int i = 0; i < writtenIndexes.numElements(); ++i)
+        indexesToWrite.push_back(writtenIndexes(i));
+    }
   }
 
@@ -472 +630 @@
     {
       CBufferIn* buffer = it->buffer;
-      string domainId;
-      *buffer >> domainId;
-      get(domainId)->recvDistributedValue(it->rank, *buffer);
+      string axisId;
+      *buffer >> axisId;
+      get(axisId)->recvDistributedValue(it->rank, *buffer);
     }
   }
@@ -503 +661 @@
    void CAxis::recvNonDistributedValue(CEventServer& event)
   {
+    CAxis* axis;
+
     list<CEventServer::SSubEvent>::iterator it;
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
     {
       CBufferIn* buffer = it->buffer;
-      string domainId;
-      *buffer >> domainId;
-      get(domainId)->recvNonDistributedValue(it->rank, *buffer);
+      string axisId;
+      *buffer >> axisId;
+      axis = get(axisId);
+      axis->recvNonDistributedValue(it->rank, *buffer);
+    }
+
+    if (axis->isCompressible_)
+    {
+      std::sort(axis->indexesToWrite.begin(), axis->indexesToWrite.end());
+
+      axis->numberWrittenIndexes_ = axis->totalNumberWrittenIndexes_ = axis->indexesToWrite.size();
+      axis->offsetWrittenIndexes_ = 0;
     }
   }
@@ -526 +695 @@
         bound_srv(1,ind) = bounds(1,ind);
       }
+    }
+
+    if (isCompressible_)
+    {
+      CArray<int, 1> writtenIndexes;
+      buffer >> writtenIndexes;
+      indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
+      for (int i = 0; i < writtenIndexes.numElements(); ++i)
+        indexesToWrite.push_back(writtenIndexes(i));
     }
   }
@@ -561 +739 @@
         msg << ni << begin << end;
         msg << global_zoom_begin << global_zoom_size;
+        msg << isCompressible_;
 
         event.push(*itRank,1,msg);
@@ -581 +760 @@
     int ni_srv, begin_srv, end_srv, global_zoom_begin_tmp, global_zoom_size_tmp;
 
-    buffer>>ni_srv>>begin_srv>>end_srv>>global_zoom_begin_tmp>>global_zoom_size_tmp;
+    buffer >> ni_srv >> begin_srv >> end_srv;
+    buffer >> global_zoom_begin_tmp >> global_zoom_size_tmp;
+    buffer >> isCompressible_;
     global_zoom_begin = global_zoom_begin_tmp;
     global_zoom_size  = global_zoom_size_tmp;

XIOS/trunk/src/node/axis.hpp

@@ -67 +67 @@
          const std::set<StdString> & getRelFiles(void) const;
 
+         const std::vector<int>& getIndexesToWrite(void) const;
+         int getNumberWrittenIndexes() const;
+         int getTotalNumberWrittenIndexes() const;
+         int getOffsetWrittenIndexes() const;
+
          /// Test ///
          bool IsWritten(const StdString & filename) const;
+         bool isWrittenCompressed(const StdString& filename) const;
          bool isDistributed(void) const;
+         bool isCompressible(void) const;
 
          /// Mutateur ///
          void addRelFile(const StdString & filename);
+         void addRelFileCompressed(const StdString& filename);
 
          /// Vérifications ///
@@ -97 +105 @@
                                     CServerDistributionDescription::ServerDistributionType disType = CServerDistributionDescription::BAND_DISTRIBUTION);
 
+         void checkEligibilityForCompressedOutput();
+
          bool hasTransformation();
          void solveInheritanceTransformation();
@@ -107 +117 @@
         CArray<double,1> value_srv;
         CArray<double,2> bound_srv;
-      private :
+
+      private:
          void checkData();
          void checkMask();
@@ -128 +139 @@
 
          void setTransformations(const TransMapTypes&);
+
       private:
          bool isChecked;
          bool areClientAttributesChecked_;
-         std::set<StdString> relFiles;
+         std::set<StdString> relFiles, relFilesCompressed;
          TransMapTypes transformationMap_;
          bool isDistributed_;
+         //! True if and only if the data defined on the axis can be outputted in a compressed way
+         bool isCompressible_;
          std::map<int,int> nbConnectedClients_; // Mapping of number of communicating client to a server
          std::map<int, vector<size_t> > indSrv_; // Global index of each client sent to server
+         std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server
+         std::vector<int> indexesToWrite;
+         int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
          std::vector<int> connectedServerRank_;
          std::map<int, CArray<int,1> > indiSrv_;

XIOS/trunk/src/node/context.cpp

@@ -745 +745 @@
       // Find all inheritance in xml structure
       this->solveAllInheritance();
+
+      // Check if some axis, domains or grids are eligible to for compressed indexed output.
+      // Warning: This must be done after solving the inheritance and before the rest of post-processing
+      checkAxisDomainsGridsEligibilityForCompressedOutput();
 
       //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir.
@@ -851 +855 @@
    }
 
+   //! Client side: Check if the defined axis, domains and grids are eligible for compressed indexed output
+   void CContext::checkAxisDomainsGridsEligibilityForCompressedOutput()
+   {
+     if (!hasClient) return;
+
+     const vector<CAxis*> allAxis = CAxis::getAll();
+     for (vector<CAxis*>::const_iterator it = allAxis.begin(); it != allAxis.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+
+     const vector<CDomain*> allDomains = CDomain::getAll();
+     for (vector<CDomain*>::const_iterator it = allDomains.begin(); it != allDomains.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+
+     const vector<CGrid*> allGrids = CGrid::getAll();
+     for (vector<CGrid*>::const_iterator it = allGrids.begin(); it != allGrids.end(); it++)
+       (*it)->checkEligibilityForCompressedOutput();
+   }
+
    //! Client side: Send information of reference grid of active fields
    void CContext::sendRefGrid()

XIOS/trunk/src/node/context.hpp

@@ -109 +109 @@
          void updateCalendar(int step);
          void createFileHeader(void );
+         void checkAxisDomainsGridsEligibilityForCompressedOutput();
          void solveAllRefOfEnabledFields(bool sendToServer);
          void buildFilterGraphOfEnabledFields();

XIOS/trunk/src/node/domain.cpp

@@ -13 +13 @@
 #include "context.hpp"
 #include "context_client.hpp"
+#include "context_server.hpp"
 #include "array_new.hpp"
+#include "distribution_client.hpp"
 #include "server_distribution_description.hpp"
 #include "client_server_mapping_distributed.hpp"
@@ -19 +21 @@
 #include "interpolate_from_file_domain.hpp"
 
+#include <algorithm>
+
 namespace xios {
 
@@ -26 +30 @@
       : CObjectTemplate<CDomain>(), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
       , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
@@ -35 +39 @@
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
       , global_zoom_ni(0), global_zoom_ibegin(0), global_zoom_nj(0), global_zoom_jbegin(0)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
@@ -64 +68 @@
 
    //----------------------------------------------------------------
+
+   const std::vector<int>& CDomain::getIndexesToWrite(void) const
+   {
+     return indexesToWrite;
+   }
+
+   /*!
+     Returns the number of indexes written by each server.
+     \return the number of indexes written by each server
+   */
+   int CDomain::getNumberWrittenIndexes() const
+   {
+     return numberWrittenIndexes_;
+   }
+
+   /*!
+     Returns the total number of indexes written by the servers.
+     \return the total number of indexes written by the servers
+   */
+   int CDomain::getTotalNumberWrittenIndexes() const
+   {
+     return totalNumberWrittenIndexes_;
+   }
+
+   /*!
+     Returns the offset of indexes written by each server.
+     \return the offset of indexes written by each server
+   */
+   int CDomain::getOffsetWrittenIndexes() const
+   {
+     return offsetWrittenIndexes_;
+   }
+
+   //----------------------------------------------------------------
+
    bool CDomain::isEmpty(void) const
    {
@@ -71 +110 @@
 
    //----------------------------------------------------------------
+
    bool CDomain::IsWritten(const StdString & filename) const
    {
@@ -76 +116 @@
    }
 
+   bool CDomain::isWrittenCompressed(const StdString& filename) const
+   {
+      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
+   }
+
    //----------------------------------------------------------------
+
    bool CDomain::isDistributed(void) const
    {
@@ -83 +129 @@
 
    //----------------------------------------------------------------
+
+   /*!
+    * Test whether the data defined on the domain can be outputted in a compressed way.
+    * 
+    * \return true if and only if a mask was defined for this domain
+    */
+   bool CDomain::isCompressible(void) const
+   {
+      return isCompressible_;
+   }
+
+   //----------------------------------------------------------------
+
    void CDomain::addRelFile(const StdString & filename)
    {
       this->relFiles.insert(filename);
+   }
+
+   void CDomain::addRelFileCompressed(const StdString& filename)
+   {
+      this->relFilesCompressed.insert(filename);
    }
 
@@ -246 +310 @@
    }
 
-
    //----------------------------------------------------------------
+
    void CDomain::checkDomainData(void)
    {
@@ -357 +421 @@
 
    //----------------------------------------------------------------
+
+   void CDomain::checkEligibilityForCompressedOutput(void)
+   {
+     // We don't check if the mask or the indexes are valid here, just if they have been defined at this point.
+     isCompressible_ = !mask_1d.isEmpty() || !mask_2d.isEmpty() || !data_i_index.isEmpty();
+   }
+
+   //----------------------------------------------------------------
+
    void CDomain::completeLonLatClient(void)
    {
@@ -746 +819 @@
         msg << ni_srv << ibegin_srv << iend_srv << nj_srv << jbegin_srv << jend_srv;
         msg << global_zoom_ni << global_zoom_ibegin << global_zoom_nj << global_zoom_jbegin;
+        msg << isCompressible_;
 
         event.push(*itRank,1,msg);
@@ -783 +857 @@
       {
         ++globalIndexCountZoom;
+      }
+    }
+
+    int globalIndexWrittenCount = 0;
+    if (isCompressible_)
+    {
+      for (i = 0; i < data_i_index.numElements(); ++i)
+      {
+        i_ind = CDistributionClient::getDomainIndex(data_i_index(i), data_j_index(i),
+                                                    data_ibegin, data_jbegin, data_dim, ni,
+                                                    j_ind);
+        if (i_ind >= 0 && i_ind < ni && j_ind >= 0 && j_ind < nj && mask_1d(i_ind + j_ind * ni))
+        {
+          i_ind += ibegin;
+          j_ind += jbegin;
+          if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
+            ++globalIndexWrittenCount;
+        }
       }
     }
@@ -809 +901 @@
     }
 
-     size_t globalSizeIndex = 1, indexBegin, indexEnd;
-     int range, clientSize = client->clientSize;
-     for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
-     indexBegin = 0;
-     for (int i = 0; i < clientSize; ++i)
-     {
-       range = globalSizeIndex / clientSize;
-       if (i < (globalSizeIndex%clientSize)) ++range;
-       if (i == client->clientRank) break;
-       indexBegin += range;
-     }
-     indexEnd = indexBegin + range - 1;
+    CArray<int,1> globalIndexWrittenDomain(globalIndexWrittenCount);
+    if (isCompressible_)
+    {
+      globalIndexWrittenCount = 0;
+      for (i = 0; i < data_i_index.numElements(); ++i)
+      {
+        i_ind = CDistributionClient::getDomainIndex(data_i_index(i), data_j_index(i),
+                                                    data_ibegin, data_jbegin, data_dim, ni,
+                                                    j_ind);
+        if (i_ind >= 0 && i_ind < ni && j_ind >= 0 && j_ind < nj && mask_1d(i_ind + j_ind * ni))
+        {
+          i_ind += ibegin;
+          j_ind += jbegin;
+          if (i_ind >= global_zoom_ibegin && i_ind <= global_zoom_iend && j_ind >= global_zoom_jbegin && j_ind <= global_zoom_jend)
+          {
+            globalIndexWrittenDomain(globalIndexWrittenCount) = i_ind + j_ind * ni_glo;
+            ++globalIndexWrittenCount;
+          }
+        }
+      }
+    }
+
+    size_t globalSizeIndex = 1, indexBegin, indexEnd;
+    int range, clientSize = client->clientSize;
+    for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
+    indexBegin = 0;
+    for (int i = 0; i < clientSize; ++i)
+    {
+      range = globalSizeIndex / clientSize;
+      if (i < (globalSizeIndex%clientSize)) ++range;
+      if (i == client->clientRank) break;
+      indexBegin += range;
+    }
+    indexEnd = indexBegin + range - 1;
 
     CServerDistributionDescription serverDescription(nGlobDomain_);
@@ -837 +951 @@
 
     indSrv_.clear();
+    indWrittenSrv_.clear();
     for (; it != ite; ++it)
     {
@@ -853 +968 @@
         }
       }
+      for (int i = 0; i < globalIndexWrittenDomain.numElements(); ++i)
+      {
+        if (binSearch.search(permutIndex.begin(), permutIndex.end(), globalIndexWrittenDomain(i), itVec))
+        {
+          indWrittenSrv_[rank].push_back(globalIndexWrittenDomain(i));
+        }
+      }
     }
 
@@ -888 +1010 @@
 
     list<CMessage> list_msgsIndex;
-    list<CArray<int,1> > list_indi, list_indj;
+    list<CArray<int,1> > list_indi, list_indj, list_writtenInd;
 
     std::map<int, std::vector<size_t> >::const_iterator it, iteMap;
@@ -918 +1040 @@
       list_msgsIndex.back() << isCurvilinear;
       list_msgsIndex.back() << list_indi.back() << list_indj.back();
+
+      if (isCompressible_)
+      {
+        std::vector<int>& writtenIndSrc = indWrittenSrv_[rank];
+        list_writtenInd.push_back(CArray<int,1>(writtenIndSrc.size()));
+        CArray<int,1>& writtenInd = list_writtenInd.back();
+
+        for (n = 0; n < writtenInd.numElements(); ++n)
+          writtenInd(n) = writtenIndSrc[n];
+
+        list_msgsIndex.back() << writtenInd;
+      }
 
       eventIndex.push(rank, nbConnectedClients_[rank], list_msgsIndex.back());
@@ -1118 +1252 @@
   {
     buffer >> ni_srv >> ibegin_srv >> iend_srv >> nj_srv >> jbegin_srv >> jend_srv
-           >> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin;
+           >> global_zoom_ni >> global_zoom_ibegin >> global_zoom_nj >> global_zoom_jbegin
+           >> isCompressible_;
 
     int zoom_iend = global_zoom_ibegin + global_zoom_ni - 1;
@@ -1158 +1293 @@
   void CDomain::recvIndex(CEventServer& event)
   {
+    CDomain* domain;
+
     list<CEventServer::SSubEvent>::iterator it;
     for (it = event.subEvents.begin(); it != event.subEvents.end(); ++it)
@@ -1164 +1301 @@
       string domainId;
       *buffer >> domainId;
-      get(domainId)->recvIndex(it->rank, *buffer);
+      domain = get(domainId);
+      domain->recvIndex(it->rank, *buffer);
+    }
+
+    if (domain->isCompressible_)
+    {
+      std::sort(domain->indexesToWrite.begin(), domain->indexesToWrite.end());
+
+      CContextServer* server = CContext::getCurrent()->server;
+      domain->numberWrittenIndexes_ = domain->indexesToWrite.size();
+      MPI_Allreduce(&domain->numberWrittenIndexes_, &domain->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      MPI_Scan(&domain->numberWrittenIndexes_, &domain->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      domain->offsetWrittenIndexes_ -= domain->numberWrittenIndexes_;
     }
   }
@@ -1178 +1327 @@
     buffer >> type_int >> isCurvilinear >> indiSrv[rank] >> indjSrv[rank];
     type.setValue((type_attr::t_enum)type_int); // probleme des type enum avec les buffers : ToFix
+
+    if (isCompressible_)
+    {
+      CArray<int, 1> writtenIndexes;
+      buffer >> writtenIndexes;
+      indexesToWrite.reserve(indexesToWrite.size() + writtenIndexes.numElements());
+      for (int i = 0; i < writtenIndexes.numElements(); ++i)
+        indexesToWrite.push_back(writtenIndexes(i));
+    }
   }
 

XIOS/trunk/src/node/domain.hpp

@@ -47 +47 @@
          typedef CDomainAttributes SuperClassAttribute;
 
-      public :
+      public:
 
          typedef CDomainAttributes RelAttributes;
@@ -70 +70 @@
          void checkAttributesOnClientAfterTransformation();
 
+         void checkEligibilityForCompressedOutput(void);
+
          void sendCheckedAttributes();
 
@@ -76 +78 @@
          TransMapTypes getAllTransformations();
 
-      public :
+      public:
          const std::set<StdString> & getRelFiles(void) const;
          bool IsWritten(const StdString & filename) const;
+         bool isWrittenCompressed(const StdString& filename) const;
+
+         const std::vector<int>& getIndexesToWrite(void) const;
+         int getNumberWrittenIndexes() const;
+         int getTotalNumberWrittenIndexes() const;
+         int getOffsetWrittenIndexes() const;
+
          bool isEmpty(void) const;
          bool isDistributed(void) const;
-
+         bool isCompressible(void) const;
 
          int global_zoom_ibegin, global_zoom_ni;
@@ -104 +113 @@
         vector< vector<int> > j_indSrv ; // for each server, j global index to send
 
-      public :
+      public:
          /// Mutateur ///
          void addRelFile(const StdString & filename);
+         void addRelFileCompressed(const StdString& filename);
          void completeLonLatClient(void);
          void sendServerAttribut(void) ;
@@ -159 +169 @@
          void sendLonLat();
 
-       private :
+       private:
          bool isChecked;
-         std::set<StdString> relFiles;
+         std::set<StdString> relFiles, relFilesCompressed;
          bool isClientChecked; // Verify whether all attributes of domain on the client side are good
          bool isClientAfterTransformationChecked;
@@ -167 +177 @@
          std::map<int,int> nbConnectedClients_; // Mapping of number of communicating client to a server
          std::map<int, vector<size_t> > indSrv_; // Global index of each client sent to server
+         std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server
+         std::vector<int> indexesToWrite;
+         int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
          std::vector<int> connectedServerRank_;
          bool isDistributed_;
+         //! True if and only if the data defined on the domain can be outputted in a compressed way
+         bool isCompressible_;
          TransMapTypes transformationMap_;
          std::vector<int> nGlobDomain_;

XIOS/trunk/src/node/field.cpp

@@ -35 +35 @@
       , hasOutputFile(false)
       , domAxisIds_("", ""), areAllReferenceSolved(false)
+      , useCompressedOutput(false)
       , isReadDataRequestPending(false)
    { setVirtualVariableGroup(); }
@@ -45 +46 @@
       , hasOutputFile(false)
       , domAxisIds_("", ""), areAllReferenceSolved(false)
+      , useCompressedOutput(false)
       , isReadDataRequestPending(false)
    { setVirtualVariableGroup(); }
@@ -455 +457 @@
    {
       return !this->refObject.empty();
+   }
+
+   //----------------------------------------------------------------
+
+   bool CField::getUseCompressedOutput() const
+   {
+     return useCompressedOutput;
+   }
+
+   void CField::setUseCompressedOutput()
+   {
+     useCompressedOutput = true;
    }
 
@@ -814 +828 @@
       for(it=data_srv.begin();it!=data_srv.end();it++)
       {
-         grid->outputField(it->first, it->second, fieldOut.dataFirst()) ;
+         grid->outputField(it->first, it->second, fieldOut.dataFirst());
       }
    }
@@ -824 +838 @@
       for (it = data_srv.begin(); it != data_srv.end(); it++)
       {
-         grid->outputField(it->first, it->second, fieldOut.dataFirst()) ;
+         grid->outputField(it->first, it->second, fieldOut.dataFirst());
       }
    }
@@ -852 +866 @@
       {
          grid->inputField(it->first, fieldOut.dataFirst(), it->second);
+      }
+   }
+
+   void CField::outputCompressedField(CArray<double,1>& fieldOut)
+   {
+      map<int, CArray<double,1> >::iterator it;
+
+      for (it = data_srv.begin(); it != data_srv.end(); it++)
+      {
+         grid->outputCompressedField(it->first, it->second, fieldOut.dataFirst());
       }
    }

XIOS/trunk/src/node/field.hpp

@@ -99 +99 @@
          bool isActive(void) const;
          bool hasOutputFile;
+
+         bool getUseCompressedOutput() const;
+         void setUseCompressedOutput();
 
          /// Traitements ///
@@ -142 +145 @@
         void inputField(CArray<double,2>& fieldOut);
         void inputField(CArray<double,1>& fieldOut);
+        void outputCompressedField(CArray<double, 1>& fieldOut);
         void scaleFactorAddOffset(double scaleFactor, double addOffset);
         void invertScaleFactorAddOffset(double scaleFactor, double addOffset);
@@ -187 +191 @@
          std::pair<StdString,StdString> domAxisIds_;
          bool isReadDataRequestPending;
+         bool useCompressedOutput;
 
          DECLARE_REF_FUNC(Field,field)

XIOS/trunk/src/node/grid.cpp

@@ -25 +25 @@
       : CObjectTemplate<CGrid>(), CGridAttributes()
       , isChecked(false), isDomainAxisChecked(false)
-      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false)
+      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+      , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
+      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
+      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , transformations_(0), isTransformed_(false)
       , axisPositionInGrid_(), positionDimensionDistributed_(1)
    {
@@ -37 +39 @@
       : CObjectTemplate<CGrid>(id), CGridAttributes()
       , isChecked(false), isDomainAxisChecked(false)
-      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false), clientDistribution_(0), isIndexSent(false)
-      , serverDistribution_(0), clientServerMap_(0), writtenDataSize_(0), globalDim_()
-      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), transformations_(0), isTransformed_(false)
+      , vDomainGroup_(), vAxisGroup_(), axisList_(), isAxisListSet(false), isDomListSet(false)
+      , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
+      , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
+      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , transformations_(0), isTransformed_(false)
       , axisPositionInGrid_(), positionDimensionDistributed_(1)
    {
@@ -149 +153 @@
    }
 
+   //---------------------------------------------------------------
+
+   /*!
+    * Test whether the data defined on the grid can be outputted in a compressed way.
+    * 
+    * \return true if and only if a mask was defined for this grid
+    */
+   bool CGrid::isCompressible(void) const
+   {
+      return isCompressible_;
+   }
+
+   //---------------------------------------------------------------
+
+   void CGrid::addRelFileCompressed(const StdString& filename)
+   {
+      this->relFilesCompressed.insert(filename);
+   }
+
+   bool CGrid::isWrittenCompressed(const StdString& filename) const
+   {
+      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end());
+   }
+
+   //---------------------------------------------------------------
+
    void CGrid::solveDomainAxisRef(bool areAttributesChecked)
    {
@@ -157 +187 @@
      computeGridGlobalDimension(getDomains(), getAxis(), axis_domain_order);
      this->isDomainAxisChecked = areAttributesChecked;
+   }
+
+   void CGrid::checkEligibilityForCompressedOutput()
+   {
+     // We don't check if the mask is valid here, just if a mask has been defined at this point.
+     isCompressible_ = !mask1.isEmpty() || !mask2.isEmpty() || !mask3.isEmpty();
    }
 
@@ -488 +524 @@
    }
 
+   void CGrid::outputCompressedField(int rank, const CArray<double,1>& stored, double* field)
+   {
+     const CArray<size_t,1>& out_i = compressedOutIndexFromClient[rank];
+     StdSize numElements = stored.numElements();
+     for (StdSize n = 0; n < numElements; ++n)
+     {
+       field[out_i(n)] = stored(n);
+     }
+   }
+
    //----------------------------------------------------------------
 
@@ -518 +564 @@
     }
     isDataDistributed_ = false;
+  }
+
+  void CGrid::computeCompressedIndex()
+  {
+    compressedOutIndexFromClient = outIndexFromClient;
+
+    std::map<size_t, size_t> indexes;
+
+    {
+      std::map<int, CArray<size_t,1> >::const_iterator it = compressedOutIndexFromClient.begin();
+      std::map<int, CArray<size_t,1> >::const_iterator itEnd = compressedOutIndexFromClient.end();
+      for (; it != itEnd; ++it)
+      {
+        for (int i = 0; i < it->second.numElements(); ++i)
+          indexes.insert(std::make_pair(it->second(i), 0));
+      }
+    }
+
+    {
+      std::map<size_t, size_t>::iterator it = indexes.begin();
+      std::map<size_t, size_t>::iterator itEnd = indexes.end();
+      for (size_t i = 0; it != itEnd; ++it, ++i)
+        it->second = i;
+    }
+
+    {
+      std::map<int, CArray<size_t,1> >::iterator it = compressedOutIndexFromClient.begin();
+      std::map<int, CArray<size_t,1> >::iterator itEnd = compressedOutIndexFromClient.end();
+      for (; it != itEnd; ++it)
+      {
+        for (int i = 0; i < it->second.numElements(); ++i)
+          it->second(i) = indexes[it->second(i)];
+      }
+    }
   }
 
@@ -547 +627 @@
 
         listMsg.push_back(CMessage());
-        listMsg.back() << getId( )<< isDataDistributed_ << listOutIndex.back();
+        listMsg.back() << getId( )<< isDataDistributed_ << isCompressible_ << listOutIndex.back();
 
         event.push(rank, 1, listMsg.back());
@@ -589 +669 @@
 
           listMsg.push_back(CMessage());
-          listMsg.back() << getId() << isDataDistributed_ << listOutIndex.back();
+          listMsg.back() << getId() << isDataDistributed_ << isCompressible_ << listOutIndex.back();
 
           event.push(rank, 1, listMsg.back());
@@ -650 +730 @@
 
         listMsg.push_back(CMessage());
-        listMsg.back() << getId() << isDataDistributed_ << listOutIndex.back();
+        listMsg.back() << getId() << isDataDistributed_ << isCompressible_ << listOutIndex.back();
 
         event.push(rank, nbSenders[rank], listMsg.back());
@@ -741 +821 @@
   }
 
+  /*!
+    Returns the number of indexes written by each server.
+    \return the number of indexes written by each server
+  */
+  int CGrid::getNumberWrittenIndexes() const
+  {
+    return numberWrittenIndexes_;
+  }
+
+  /*!
+    Returns the total number of indexes written by the servers.
+    \return the total number of indexes written by the servers
+  */
+  int CGrid::getTotalNumberWrittenIndexes() const
+  {
+    return totalNumberWrittenIndexes_;
+  }
+
+  /*!
+    Returns the offset of indexes written by each server.
+    \return the offset of indexes written by each server
+  */
+  int CGrid::getOffsetWrittenIndexes() const
+  {
+    return offsetWrittenIndexes_;
+  }
+
   const CDistributionServer* CGrid::getDistributionServer() const
   {
@@ -762 +869 @@
     CContext* context = CContext::getCurrent();
     CContextServer* server = context->server;
+    numberWrittenIndexes_ = totalNumberWrittenIndexes_ = offsetWrittenIndexes_ = 0;
 
     for (int n = 0; n < ranks.size(); n++)
@@ -768 +876 @@
       CBufferIn& buffer = *buffers[n];
 
-      buffer >> isDataDistributed_;
+      buffer >> isDataDistributed_ >> isCompressible_;
       size_t dataSize = 0;
 
       if (isScalarGrid())
       {
-        writtenDataSize_ = 1;
+        writtenDataSize_ = numberWrittenIndexes_ = totalNumberWrittenIndexes_ = 1;
         CArray<size_t,1> outIndex;
         buffer >> outIndex;
@@ -849 +957 @@
       outIndexFromClient.insert(std::make_pair(rank, outIndex));
       connectedDataSize_[rank] = outIndex.numElements();
-    }
+      numberWrittenIndexes_ += outIndex.numElements();
+    }
+
+    if (isDataDistributed_)
+    {
+      MPI_Allreduce(&numberWrittenIndexes_, &totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      MPI_Scan(&numberWrittenIndexes_, &offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm);
+      offsetWrittenIndexes_ -= numberWrittenIndexes_;
+    }
+    else
+      totalNumberWrittenIndexes_ = numberWrittenIndexes_;
 
     nbSenders = CClientServerMappingDistributed::computeConnectedClients(context->client->serverSize, context->client->clientSize, context->client->intraComm, ranks);

XIOS/trunk/src/node/grid.hpp

@@ -48 +48 @@
          typedef CGridAttributes SuperClassAttribute;
 
-      public :
+      public:
 
          typedef CGridAttributes RelAttributes;
@@ -72 +72 @@
 //         void solveReference(void);
 
+         void checkEligibilityForCompressedOutput();
+
          void solveDomainAxisRef(bool areAttributesChecked);
 
@@ -79 +81 @@
 //         virtual void fromBinary(StdIStream& is);
 
+         void addRelFileCompressed(const StdString& filename);
+
          /// Tests ///
-         bool hasAxis(void) const;
-
-      public :
+         bool isCompressible(void) const;
+         bool isWrittenCompressed(const StdString& filename) const;
+
+      public:
 
          /// Accesseurs ///
@@ -98 +103 @@
          void inputField(int rank, const double* const field, CArray<double,1>& stored);
 
+         void outputCompressedField(int rank, const CArray<double,1>& stored, double* field);
+
          virtual void parse(xml::CXMLNode& node);
 
@@ -103 +110 @@
          virtual ~CGrid(void);
 
-      public :
+      public:
 
          /// Accesseurs statiques ///
@@ -116 +123 @@
          static CGrid* createGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis, CArray<bool,1> axisDomainOrder = CArray<bool,1>());
 
-      public :
+      public:
 
          /// Entrées-sorties de champs (interne) ///
@@ -126 +133 @@
          void computeIndex(void);
          void computeIndexScalarGrid();
+         void computeCompressedIndex();
 
          void solveDomainRef(bool checkAtt);
@@ -163 +171 @@
          bool doGridHaveDataDistributed();
          size_t getWrittenDataSize() const;
+         int getNumberWrittenIndexes() const;
+         int getTotalNumberWrittenIndexes() const;
+         int getOffsetWrittenIndexes() const;
 
          const CDistributionServer* getDistributionServer() const;
@@ -184 +195 @@
          map<int,int> nbSenders;
 
-         map<int, CArray<size_t, 1> > outIndexFromClient;
+         map<int, CArray<size_t, 1> > outIndexFromClient, compressedOutIndexFromClient;
          void checkMask(void);
          void modifyMask(const CArray<int,1>& indexToModify);
@@ -221 +232 @@
 
         std::vector<int> globalDim_;
+
       private:
         CDomainGroup* vDomainGroup_;
@@ -231 +243 @@
         CClientServerMapping* clientServerMap_;
         size_t writtenDataSize_;
+        int numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;
         std::map<int,size_t> connectedDataSize_;
         std::vector<int> connectedServerRank_;
         bool isDataDistributed_;
         int positionDimensionDistributed_;
+         //! True if and only if the data defined on the grid can be outputted in a compressed way
+        bool isCompressible_;
+        std::set<std::string> relFilesCompressed;
 
         bool isTransformed_;

XIOS/trunk/src/output/nc4_data_output.cpp

@@ -741 +741 @@
      }
 
+     //--------------------------------------------------------------
+
+     void CNc4DataOutput::writeGridCompressed_(CGrid* grid)
+     {
+       if (grid->isScalarGrid() || grid->isWrittenCompressed(this->filename)) return;
+
+       try
+       {
+         CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
+         std::vector<StdString> domainList = grid->getDomainList();
+         std::vector<StdString> axisList   = grid->getAxisList();
+         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0;
+
+         std::vector<StdString> dims;
+
+         if (grid->isCompressible())
+         {
+           StdString varId = grid->getId() + "_points";
+
+           int nbIndexes = (SuperClass::type == MULTI_FILE) ? grid->getNumberWrittenIndexes() : grid->getTotalNumberWrittenIndexes();
+           SuperClassWriter::addDimension(varId, nbIndexes);
+
+           dims.push_back(varId);
+           SuperClassWriter::addVariable(varId, NC_INT, dims);
+
+           StdOStringStream compress;
+           for (int i = numElement - 1; i >= 0; --i)
+           {
+             if (axisDomainOrder(i))
+             {
+               CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]);
+               StdString domId = !domain->name.isEmpty() ? domain->name.getValue() : domain->getId();
+               StdString appendDomId  = singleDomain ? "" : "_" + domId;
+
+               switch (domain->type)
+               {
+                 case CDomain::type_attr::curvilinear:
+                   compress << "y" << appendDomId << " x" << appendDomId;
+                   break;
+                 case CDomain::type_attr::rectilinear:
+                   compress << "lat" << appendDomId << " lon" << appendDomId;
+                   break;
+                 case CDomain::type_attr::unstructured:
+                   compress << "cell" << appendDomId;
+                   break;
+               }
+               ++idxDomain;
+             }
+             else
+             {
+               CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]);
+               compress << (!axis->name.isEmpty() ? axis->name.getValue() : axis->getId());
+               ++idxAxis;
+             }
+
+             if (i != 0) compress << ' ';
+           }
+           SuperClassWriter::addAttribute("compress", compress.str(), &varId);
+
+           grid->computeCompressedIndex();
+
+           CArray<int, 1> indexes(grid->getNumberWrittenIndexes());
+           std::map<int, CArray<size_t, 1> >::const_iterator it;
+           for (it = grid->outIndexFromClient.begin(); it != grid->outIndexFromClient.end(); ++it)
+           {
+             const CArray<size_t, 1> compressedIndexes = grid->compressedOutIndexFromClient[it->first];
+             for (int i = 0; i < it->second.numElements(); i++)
+               indexes(compressedIndexes(i)) = it->second(i);
+           }
+
+           switch (SuperClass::type)
+           {
+             case (MULTI_FILE):
+             {
+               SuperClassWriter::writeData(indexes, varId, isCollective, 0);
+               break;
+             }
+             case (ONE_FILE):
+             {
+               if (grid->doGridHaveDataDistributed())
+                 grid->getDistributionServer()->computeGlobalIndex(indexes);
+
+               std::vector<StdSize> start, count;
+               start.push_back(grid->getOffsetWrittenIndexes());
+               count.push_back(grid->getNumberWrittenIndexes());
+
+               SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
+               break;
+             }
+           }
+         }
+         else
+         {
+           for (int i = 0; i < numElement; ++i)
+           {
+             StdString varId, compress;
+             CArray<int, 1> indexes;
+             bool isDistributed;
+             StdSize nbIndexes, totalNbIndexes, offset;
+             int firstGlobalIndex;
+
+             if (axisDomainOrder(i))
+             {
+               CDomain* domain = CDomain::get(domainList[idxDomain]);
+               if (!domain->isCompressible()
+                    || domain->type == CDomain::type_attr::unstructured
+                    || domain->isWrittenCompressed(this->filename))
+                 continue;
+
+               StdString domId = !domain->name.isEmpty() ? domain->name.getValue() : domain->getId();
+               StdString appendDomId  = singleDomain ? "" : "_" + domId;
+
+               varId = domId + "_points";
+               switch (domain->type)
+               {
+                 case CDomain::type_attr::curvilinear:
+                   compress = "y" + appendDomId + " x" + appendDomId;
+                   break;
+                 case CDomain::type_attr::rectilinear:
+                   compress = "lat" + appendDomId + " lon" + appendDomId;
+                   break;
+               }
+
+               const std::vector<int>& indexesToWrite = domain->getIndexesToWrite();
+               indexes.resize(indexesToWrite.size());
+               for (int n = 0; n < indexes.numElements(); ++n)
+                 indexes(n) = indexesToWrite[n];
+
+               isDistributed = domain->isDistributed();
+               nbIndexes = domain->getNumberWrittenIndexes();
+               totalNbIndexes = domain->getTotalNumberWrittenIndexes();
+               offset = domain->getOffsetWrittenIndexes();
+               firstGlobalIndex = domain->ibegin + domain->jbegin * domain->ni_glo;
+
+               domain->addRelFileCompressed(this->filename);
+               ++idxDomain;
+             }
+             else
+             {
+               CAxis* axis = CAxis::get(axisList[idxAxis]);
+               if (!axis->isCompressible() || axis->isWrittenCompressed(this->filename))
+                 continue;
+
+               StdString axisId = !axis->name.isEmpty() ? axis->name.getValue() : axis->getId();
+               varId = axisId + "_points";
+               compress = axisId;
+
+               const std::vector<int>& indexesToWrite = axis->getIndexesToWrite();
+               indexes.resize(indexesToWrite.size());
+               for (int n = 0; n < indexes.numElements(); ++n)
+                 indexes(n) = indexesToWrite[n];
+
+               isDistributed = axis->isDistributed();
+               nbIndexes = axis->getNumberWrittenIndexes();
+               totalNbIndexes = axis->getTotalNumberWrittenIndexes();
+               offset = axis->getOffsetWrittenIndexes();
+               firstGlobalIndex = axis->begin;
+
+               axis->addRelFileCompressed(this->filename);
+               ++idxAxis;
+             }
+
+             if (!varId.empty())
+             {
+               SuperClassWriter::addDimension(varId, (SuperClass::type == MULTI_FILE) ? nbIndexes : totalNbIndexes);
+
+               dims.clear();
+               dims.push_back(varId);
+               SuperClassWriter::addVariable(varId, NC_INT, dims);
+
+               SuperClassWriter::addAttribute("compress", compress, &varId);
+
+               switch (SuperClass::type)
+               {
+                 case (MULTI_FILE):
+                 {
+                   indexes -= firstGlobalIndex;
+                   SuperClassWriter::writeData(indexes, varId, isCollective, 0);
+                   break;
+                 }
+                 case (ONE_FILE):
+                 {
+                   std::vector<StdSize> start, count;
+                   start.push_back(offset);
+                   count.push_back(nbIndexes);
+
+                   SuperClassWriter::writeData(indexes, varId, isCollective, 0, &start, &count);
+                   break;
+                 }
+               }
+             }
+           }
+
+           if (!dims.empty())
+             grid->computeCompressedIndex();
+         }
+
+         grid->addRelFileCompressed(this->filename);
+       }
+       catch (CNetCdfException& e)
+       {
+         StdString msg("On writing compressed grid : ");
+         msg.append(grid->getId()); msg.append("\n");
+         msg.append("In the context : ");
+         CContext* context = CContext::getCurrent();
+         msg.append(context->getId()); msg.append("\n");
+         msg.append(e.what());
+         ERROR("CNc4DataOutput::writeGridCompressed_(CGrid* grid)", << msg);
+       }
+     }
+
+     //--------------------------------------------------------------
+
      void CNc4DataOutput::writeTimeDimension_(void)
      {
@@ -757 +970 @@
        }
      }
+
       //--------------------------------------------------------------
 
@@ -779 +993 @@
          bool hasArea = false;
          StdString cellMeasures = "area:";
+         bool compressedOutput = !field->indexed_output.isEmpty() && field->indexed_output;
 
          for (int i = 0; i < numElement; ++i)
@@ -785 +1000 @@
            {
              CDomain* domain = CDomain::get(domainList[idxDomain]);
-             StdString domid = (!domain->name.isEmpty())
-                                 ? domain->name.getValue() : domain->getId();
-             StdString appendDomid  = (singleDomain) ? "" : "_"+domid ;
+             StdString domId = !domain->name.isEmpty() ? domain->name.getValue() : domain->getId();
+             StdString appendDomId  = singleDomain ? "" : "_" + domId ;
+
+             if (compressedOutput && domain->isCompressible() && domain->type != CDomain::type_attr::unstructured)
+             {
+               dimIdList.push_back(domId + "_points");
+               field->setUseCompressedOutput();
+             }
+
              switch (domain->type)
              {
-               case CDomain::type_attr::curvilinear :
-                 dimXid     = StdString("x").append(appendDomid);
+               case CDomain::type_attr::curvilinear:
+                 if (!compressedOutput || !domain->isCompressible())
+                 {
+                   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::rectilinear:
+                 if (!compressedOutput || !domain->isCompressible())
+                 {
+                   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);
-                 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));
+                 dimCoordList.push_back(StdString("lon").append(appendDomId));
+                 dimCoordList.push_back(StdString("lat").append(appendDomId));
                  break ;
-               case CDomain::type_attr::rectilinear :
-                 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 ;
-            }
-            if (domain->hasArea)
-            {
-              hasArea = true;
-              cellMeasures += " area" + appendDomid;
-            }
-            ++idxDomain;
+             }
+             if (domain->hasArea)
+             {
+               hasArea = true;
+               cellMeasures += " area" + appendDomId;
+             }
+             ++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;
+             StdString axisId = !axis->name.isEmpty() ? axis->name.getValue() : axis->getId();
+
+             if (compressedOutput && axis->isCompressible())
+             {
+               dimIdList.push_back(axisId + "_points");
+               field->setUseCompressedOutput();
+             }
+             else
+               dimIdList.push_back(axisId);
+
+             dimCoordList.push_back(axisId);
+             ++idxAxis;
            }
          }
@@ -867 +1101 @@
          }
 
-         while (!dimIdList.empty())
-         {
-           dims.push_back(dimIdList.back());
-           dimIdList.pop_back();
+         if (compressedOutput && grid->isCompressible())
+         {
+           dims.push_back(grid->getId() + "_points");
+           field->setUseCompressedOutput();
+         }
+         else
+         {
+           while (!dimIdList.empty())
+           {
+             dims.push_back(dimIdList.back());
+             dimIdList.pop_back();
+           }
          }
 
@@ -1211 +1453 @@
          try
          {
-           CArray<double,1> fieldData(grid->getWrittenDataSize());
+           size_t writtenSize;
+           if (field->getUseCompressedOutput())
+             writtenSize = grid->getNumberWrittenIndexes();
+           else
+             writtenSize = grid->getWrittenDataSize();
+
+           CArray<double,1> fieldData(writtenSize);
            if (!field->default_value.isEmpty()) fieldData = field->default_value;
-           field->outputField(fieldData);
+
+           if (field->getUseCompressedOutput())
+             field->outputCompressedField(fieldData);
+           else
+             field->outputField(fieldData);
+
            if (!field->prec.isEmpty() && field->prec==2) fieldData=round(fieldData) ;
 
@@ -1232 +1485 @@
               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)
+                const std::vector<int>& nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
+                const std::vector<int>& nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
+                const std::vector<int>& nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
+
+                std::vector<StdSize> start, count;
+
+                if (field->getUseCompressedOutput())
                 {
-                  start[i] = nZoomBeginServer[ssize-i-1] - nZoomBeginGlobal[ssize-i-1];
-                  count[i] = nZoomSizeServer[ssize-i-1];
+                  if (grid->isCompressible())
+                  {
+                    start.push_back(grid->getOffsetWrittenIndexes());
+                    count.push_back(grid->getNumberWrittenIndexes());
+                  }
+                  else
+                  {
+                    CArray<bool,1> axisDomainOrder = grid->axis_domain_order;
+                    std::vector<StdString> domainList = grid->getDomainList();
+                    std::vector<StdString> axisList   = grid->getAxisList();
+                    int numElement = axisDomainOrder.numElements();
+                    int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
+                    int idx = nZoomBeginGlobal.size() - 1;
+
+                    start.reserve(nZoomBeginGlobal.size());
+                    count.reserve(nZoomBeginGlobal.size());
+
+
+                    for (int i = numElement - 1; i >= 0; --i)
+                    {
+                      if (axisDomainOrder(i))
+                      {
+                        CDomain* domain = CDomain::get(domainList[idxDomain]);
+
+                        if (domain->isCompressible())
+                        {
+                          start.push_back(domain->getOffsetWrittenIndexes());
+                          count.push_back(domain->getNumberWrittenIndexes());
+                        }
+                        else
+                        {
+                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
+                          count.push_back(nZoomSizeServer[idx]);
+                          start.push_back(nZoomBeginServer[idx - 1] - nZoomBeginGlobal[idx - 1]);
+                          count.push_back(nZoomSizeServer[idx - 1]);
+                        }
+
+                        --idxDomain;
+                        idx -= 2;
+                      }
+                      else
+                      {
+                        CAxis* axis = CAxis::get(axisList[idxAxis]);
+
+                        if (axis->isCompressible())
+                        {
+                          start.push_back(axis->getOffsetWrittenIndexes());
+                          count.push_back(axis->getNumberWrittenIndexes());
+                        }
+                        else
+                        {
+                          start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
+                          count.push_back(nZoomSizeServer[idx]);
+                        }
+
+                        --idxAxis;
+                        --idx;
+                      }
+                    }
+                  }
                 }
-
-                SuperClassWriter::writeData(fieldData, fieldid, isCollective, field->getNStep()-1,&start,&count );
+                else
+                {
+                  int ssize = nZoomBeginGlobal.size();
+
+                  start.resize(ssize);
+                  count.resize(ssize);
+
+                  for (int i = 0; i < ssize; ++i)
+                  {
+                    start[i] = nZoomBeginServer[ssize - i - 1] - nZoomBeginGlobal[ssize - i - 1];
+                    count[i] = nZoomSizeServer[ssize - i - 1];
+                  }
+                }
+
+                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);
+                  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);
                 }
 

XIOS/trunk/src/output/nc4_data_output.hpp

@@ -41 +41 @@
 
             /// Ecriture ///
-            virtual void writeDomain_    (CDomain* domain);
-            virtual void writeAxis_      (CAxis* axis);
+            virtual void writeDomain_   (CDomain* domain);
+            virtual void writeAxis_     (CAxis* axis);
+            virtual void writeGridCompressed_(CGrid* grid);
             virtual void writeTimeDimension_(void);
-            virtual void writeField_     (CField* field);
-            virtual void writeAttribute_ (CVariable* var);
-            virtual void writeAttribute_ (CVariable* var, const string& fieldId);
-            virtual void writeFieldData_ (CField* field);
-            virtual void writeFile_      (CFile* file);
-            virtual void closeFile_      (void);
+            virtual void writeField_    (CField* field);
+            virtual void writeAttribute_(CVariable* var);
+            virtual void writeAttribute_(CVariable* var, const string& fieldId);
+            virtual void writeFieldData_(CField* field);
+            virtual void writeFile_     (CFile* file);
+            virtual void closeFile_     (void);
             virtual void syncFile_      (void);
-            virtual void writeTimeAxis_  (CField* field,
-                                          const boost::shared_ptr<CCalendar> cal);
+            virtual void writeTimeAxis_ (CField* field,
+                                         const boost::shared_ptr<CCalendar> cal);
 
          protected :

XIOS/trunk/src/output/onetcdf4_decl.cpp

@@ -9 +9 @@
                                                const std::vector<StdSize> * count) ;
  
-  macro(double,1)
-  macro(double,2)
-  macro(double,3)                                              
+  macro(int, 1)
+  macro(double, 1)
+  macro(double, 2)
+  macro(double, 3)
  
   template void CONetCDF4::setDefaultValue<double>(const StdString & varname, const double* value) ;