Changeset 1078 for XIOS/trunk/src

Timestamp:

03/17/17 16:02:40 (7 years ago)

Author:

mhnguyen

Message:

Adding rectilinear and curvilinear domain for expand_domain transformation
-) Rectilinear/curvilinear is expanded not only locally but also globally, its global size ni_glo, nj_glo become ni_glo+2 and nj_glo+2
-) Two attributes i_periodic, j_periodic are only used for rectilinear/curvilinear to process priodic condition

+) Do some minor modification

Test
+) Add test_connectivity_expand
+) On Curie
+) Work (but need more real tests)

Location:

XIOS/trunk/src

Files:

• config/expand_domain_attribute.conf (modified) (1 diff)
• interface/c_attr/icexpand_domain_attr.cpp (modified) (1 diff)
• interface/fortran_attr/expand_domain_interface_attr.F90 (modified) (1 diff)
• interface/fortran_attr/iexpand_domain_attr.F90 (modified) (8 diffs)
• node/domain.cpp (modified) (7 diffs)
• node/domain.hpp (modified) (2 diffs)
• node/expand_domain.cpp (modified) (1 diff)
• node/grid.cpp (modified) (11 diffs)
• node/grid.hpp (modified) (5 diffs)
• test/test_connectivity_expand.f90 (added)
• transformation/domain_algorithm_expand.cpp (modified) (9 diffs)
• transformation/domain_algorithm_expand.hpp (modified) (1 diff)
• transformation/grid_transformation.cpp (modified) (2 diffs)

XIOS/trunk/src/config/expand_domain_attribute.conf

@@ -2 +2 @@
 
 DECLARE_ENUM2(type,node,edge)
+
+// Flag to determine if domain expension should be periodic (and in which direction)
+DECLARE_ATTRIBUTE(bool,      i_periodic)
+DECLARE_ATTRIBUTE(bool,      j_periodic)

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

@@ -17 +17 @@
 {
   typedef xios::CExpandDomain* expand_domain_Ptr;
+
+  void cxios_set_expand_domain_i_periodic(expand_domain_Ptr expand_domain_hdl, bool i_periodic)
+  {
+    CTimer::get("XIOS").resume();
+    expand_domain_hdl->i_periodic.setValue(i_periodic);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_expand_domain_i_periodic(expand_domain_Ptr expand_domain_hdl, bool* i_periodic)
+  {
+    CTimer::get("XIOS").resume();
+    *i_periodic = expand_domain_hdl->i_periodic.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_expand_domain_i_periodic(expand_domain_Ptr expand_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = expand_domain_hdl->i_periodic.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
+
+  void cxios_set_expand_domain_j_periodic(expand_domain_Ptr expand_domain_hdl, bool j_periodic)
+  {
+    CTimer::get("XIOS").resume();
+    expand_domain_hdl->j_periodic.setValue(j_periodic);
+    CTimer::get("XIOS").suspend();
+  }
+
+  void cxios_get_expand_domain_j_periodic(expand_domain_Ptr expand_domain_hdl, bool* j_periodic)
+  {
+    CTimer::get("XIOS").resume();
+    *j_periodic = expand_domain_hdl->j_periodic.getInheritedValue();
+    CTimer::get("XIOS").suspend();
+  }
+
+  bool cxios_is_defined_expand_domain_j_periodic(expand_domain_Ptr expand_domain_hdl)
+  {
+     CTimer::get("XIOS").resume();
+     bool isDefined = expand_domain_hdl->j_periodic.hasInheritedValue();
+     CTimer::get("XIOS").suspend();
+     return isDefined;
+  }
+
 
   void cxios_set_expand_domain_order(expand_domain_Ptr expand_domain_hdl, int order)

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

@@ -9 +9 @@
   INTERFACE
     ! Do not call directly / interface FORTRAN 2003 <-> C99
+
+    SUBROUTINE cxios_set_expand_domain_i_periodic(expand_domain_hdl, i_periodic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: i_periodic
+    END SUBROUTINE cxios_set_expand_domain_i_periodic
+
+    SUBROUTINE cxios_get_expand_domain_i_periodic(expand_domain_hdl, i_periodic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+      LOGICAL (KIND=C_BOOL)             :: i_periodic
+    END SUBROUTINE cxios_get_expand_domain_i_periodic
+
+    FUNCTION cxios_is_defined_expand_domain_i_periodic(expand_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_expand_domain_i_periodic
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+    END FUNCTION cxios_is_defined_expand_domain_i_periodic
+
+
+    SUBROUTINE cxios_set_expand_domain_j_periodic(expand_domain_hdl, j_periodic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+      LOGICAL (KIND=C_BOOL)      , VALUE :: j_periodic
+    END SUBROUTINE cxios_set_expand_domain_j_periodic
+
+    SUBROUTINE cxios_get_expand_domain_j_periodic(expand_domain_hdl, j_periodic) BIND(C)
+      USE ISO_C_BINDING
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+      LOGICAL (KIND=C_BOOL)             :: j_periodic
+    END SUBROUTINE cxios_get_expand_domain_j_periodic
+
+    FUNCTION cxios_is_defined_expand_domain_j_periodic(expand_domain_hdl) BIND(C)
+      USE ISO_C_BINDING
+      LOGICAL(kind=C_BOOL) :: cxios_is_defined_expand_domain_j_periodic
+      INTEGER (kind = C_INTPTR_T), VALUE :: expand_domain_hdl
+    END FUNCTION cxios_is_defined_expand_domain_j_periodic
+
 
     SUBROUTINE cxios_set_expand_domain_order(expand_domain_hdl, order) BIND(C)

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

@@ -12 +12 @@
 
   SUBROUTINE xios(set_expand_domain_attr)  &
-    ( expand_domain_id, order, type )
+    ( expand_domain_id, i_periodic, j_periodic, order, type )
 
     IMPLICIT NONE
       TYPE(txios(expand_domain))  :: expand_domain_hdl
       CHARACTER(LEN=*), INTENT(IN) ::expand_domain_id
+      LOGICAL  , OPTIONAL, INTENT(IN) :: i_periodic
+      LOGICAL (KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL  , OPTIONAL, INTENT(IN) :: j_periodic
+      LOGICAL (KIND=C_BOOL) :: j_periodic_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
@@ -23 +27 @@
       (expand_domain_id,expand_domain_hdl)
       CALL xios(set_expand_domain_attr_hdl_)   &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(set_expand_domain_attr)
 
   SUBROUTINE xios(set_expand_domain_attr_hdl)  &
-    ( expand_domain_hdl, order, type )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic, j_periodic, order, type )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: i_periodic
+      LOGICAL (KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL  , OPTIONAL, INTENT(IN) :: j_periodic
+      LOGICAL (KIND=C_BOOL) :: j_periodic_tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type
 
       CALL xios(set_expand_domain_attr_hdl_)  &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(set_expand_domain_attr_hdl)
 
   SUBROUTINE xios(set_expand_domain_attr_hdl_)   &
-    ( expand_domain_hdl, order_, type_ )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic_, j_periodic_, order_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL  , OPTIONAL, INTENT(IN) :: i_periodic_
+      LOGICAL (KIND=C_BOOL) :: i_periodic__tmp
+      LOGICAL  , OPTIONAL, INTENT(IN) :: j_periodic_
+      LOGICAL (KIND=C_BOOL) :: j_periodic__tmp
       INTEGER  , OPTIONAL, INTENT(IN) :: order_
       CHARACTER(len = *) , OPTIONAL, INTENT(IN) :: type_
+
+      IF (PRESENT(i_periodic_)) THEN
+        i_periodic__tmp = i_periodic_
+        CALL cxios_set_expand_domain_i_periodic &
+      (expand_domain_hdl%daddr, i_periodic__tmp)
+      ENDIF
+
+      IF (PRESENT(j_periodic_)) THEN
+        j_periodic__tmp = j_periodic_
+        CALL cxios_set_expand_domain_j_periodic &
+      (expand_domain_hdl%daddr, j_periodic__tmp)
+      ENDIF
 
       IF (PRESENT(order_)) THEN
@@ -61 +85 @@
 
   SUBROUTINE xios(get_expand_domain_attr)  &
-    ( expand_domain_id, order, type )
+    ( expand_domain_id, i_periodic, j_periodic, order, type )
 
     IMPLICIT NONE
       TYPE(txios(expand_domain))  :: expand_domain_hdl
       CHARACTER(LEN=*), INTENT(IN) ::expand_domain_id
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: i_periodic
+      LOGICAL (KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: j_periodic
+      LOGICAL (KIND=C_BOOL) :: j_periodic_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
@@ -72 +100 @@
       (expand_domain_id,expand_domain_hdl)
       CALL xios(get_expand_domain_attr_hdl_)   &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(get_expand_domain_attr)
 
   SUBROUTINE xios(get_expand_domain_attr_hdl)  &
-    ( expand_domain_hdl, order, type )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic, j_periodic, order, type )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: i_periodic
+      LOGICAL (KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: j_periodic
+      LOGICAL (KIND=C_BOOL) :: j_periodic_tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: order
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type
 
       CALL xios(get_expand_domain_attr_hdl_)  &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(get_expand_domain_attr_hdl)
 
   SUBROUTINE xios(get_expand_domain_attr_hdl_)   &
-    ( expand_domain_hdl, order_, type_ )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic_, j_periodic_, order_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: i_periodic_
+      LOGICAL (KIND=C_BOOL) :: i_periodic__tmp
+      LOGICAL  , OPTIONAL, INTENT(OUT) :: j_periodic_
+      LOGICAL (KIND=C_BOOL) :: j_periodic__tmp
       INTEGER  , OPTIONAL, INTENT(OUT) :: order_
       CHARACTER(len = *) , OPTIONAL, INTENT(OUT) :: type_
+
+      IF (PRESENT(i_periodic_)) THEN
+        CALL cxios_get_expand_domain_i_periodic &
+      (expand_domain_hdl%daddr, i_periodic__tmp)
+        i_periodic_ = i_periodic__tmp
+      ENDIF
+
+      IF (PRESENT(j_periodic_)) THEN
+        CALL cxios_get_expand_domain_j_periodic &
+      (expand_domain_hdl%daddr, j_periodic__tmp)
+        j_periodic_ = j_periodic__tmp
+      ENDIF
 
       IF (PRESENT(order_)) THEN
@@ -110 +158 @@
 
   SUBROUTINE xios(is_defined_expand_domain_attr)  &
-    ( expand_domain_id, order, type )
+    ( expand_domain_id, i_periodic, j_periodic, order, type )
 
     IMPLICIT NONE
       TYPE(txios(expand_domain))  :: expand_domain_hdl
       CHARACTER(LEN=*), INTENT(IN) ::expand_domain_id
+      LOGICAL, OPTIONAL, INTENT(OUT) :: i_periodic
+      LOGICAL(KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: j_periodic
+      LOGICAL(KIND=C_BOOL) :: j_periodic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
@@ -123 +175 @@
       (expand_domain_id,expand_domain_hdl)
       CALL xios(is_defined_expand_domain_attr_hdl_)   &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(is_defined_expand_domain_attr)
 
   SUBROUTINE xios(is_defined_expand_domain_attr_hdl)  &
-    ( expand_domain_hdl, order, type )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic, j_periodic, order, type )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: i_periodic
+      LOGICAL(KIND=C_BOOL) :: i_periodic_tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: j_periodic
+      LOGICAL(KIND=C_BOOL) :: j_periodic_tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order
       LOGICAL(KIND=C_BOOL) :: order_tmp
@@ -138 +194 @@
 
       CALL xios(is_defined_expand_domain_attr_hdl_)  &
-      ( expand_domain_hdl, order, type )
+      ( expand_domain_hdl, i_periodic, j_periodic, order, type )
 
   END SUBROUTINE xios(is_defined_expand_domain_attr_hdl)
 
   SUBROUTINE xios(is_defined_expand_domain_attr_hdl_)   &
-    ( expand_domain_hdl, order_, type_ )
-
-    IMPLICIT NONE
-      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+    ( expand_domain_hdl, i_periodic_, j_periodic_, order_, type_ )
+
+    IMPLICIT NONE
+      TYPE(txios(expand_domain)) , INTENT(IN) :: expand_domain_hdl
+      LOGICAL, OPTIONAL, INTENT(OUT) :: i_periodic_
+      LOGICAL(KIND=C_BOOL) :: i_periodic__tmp
+      LOGICAL, OPTIONAL, INTENT(OUT) :: j_periodic_
+      LOGICAL(KIND=C_BOOL) :: j_periodic__tmp
       LOGICAL, OPTIONAL, INTENT(OUT) :: order_
       LOGICAL(KIND=C_BOOL) :: order__tmp
@@ -152 +212 @@
       LOGICAL(KIND=C_BOOL) :: type__tmp
 
+      IF (PRESENT(i_periodic_)) THEN
+        i_periodic__tmp = cxios_is_defined_expand_domain_i_periodic &
+      (expand_domain_hdl%daddr)
+        i_periodic_ = i_periodic__tmp
+      ENDIF
+
+      IF (PRESENT(j_periodic_)) THEN
+        j_periodic__tmp = cxios_is_defined_expand_domain_j_periodic &
+      (expand_domain_hdl%daddr)
+        j_periodic_ = j_periodic__tmp
+      ENDIF
+
       IF (PRESENT(order_)) THEN
         order__tmp = cxios_is_defined_expand_domain_order &

XIOS/trunk/src/node/domain.cpp

@@ -31 +31 @@
       : CObjectTemplate<CDomain>(), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
@@ -41 +41 @@
       : CObjectTemplate<CDomain>(id), CDomainAttributes()
       , isChecked(false), relFiles(), isClientChecked(false), nbConnectedClients_(), indSrv_(), connectedServerRank_()
-      , hasBounds(false), hasArea(false), isDistributed_(false), nGlobDomain_(), isCompressible_(false), isUnstructed_(false)
+      , hasBounds(false), hasArea(false), isDistributed_(false), isCompressible_(false), isUnstructed_(false)
       , isClientAfterTransformationChecked(false), hasLonLat(false)
       , lonvalue_client(), latvalue_client(), bounds_lon_client(), bounds_lat_client()
@@ -844 +844 @@
          for (int i = 0; i < ni; ++i) j_index(i+j*ni) = j+jbegin;
      }
-     computeNGlobDomain();
+     
      checkZoom();
      
@@ -1550 +1550 @@
     int nbServer = client->serverSize;
 
-    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    CServerDistributionDescription serverDescription(getNbGlob(), nbServer);
     if (isUnstructed_) serverDescription.computeServerDistribution(false, 0);
     else serverDescription.computeServerDistribution(false, 1);
@@ -1587 +1587 @@
   }
 
-  void CDomain::computeNGlobDomain()
-  {
-    nGlobDomain_.resize(2);
-    nGlobDomain_[0] = ni_glo.getValue();
-    nGlobDomain_[1] = nj_glo.getValue();
+  std::vector<int> CDomain::getNbGlob()
+  {
+     std::vector<int> nbGlob(2);
+     nbGlob[0] = ni_glo.getValue();
+     nbGlob[1] = nj_glo.getValue();
+
+     return nbGlob;
   }
 
@@ -1685 +1687 @@
     size_t globalSizeIndex = 1, indexBegin, indexEnd;
     int range, clientSize = client->clientSize;
-    for (int i = 0; i < nGlobDomain_.size(); ++i) globalSizeIndex *= nGlobDomain_[i];
+    for (int i = 0; i < getNbGlob().size(); ++i) globalSizeIndex *= getNbGlob()[i];
     indexBegin = 0;
     if (globalSizeIndex <= clientSize)
@@ -1704 +1706 @@
     }
 
-    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer);
+    CServerDistributionDescription serverDescription(getNbGlob(), nbServer);
     if (isUnstructed_) serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
     else serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);

XIOS/trunk/src/node/domain.hpp

@@ -123 +123 @@
         vector< vector<int> > j_indSrv ; // for each server, j global index to send
 
+         std::vector<int> getNbGlob();
       public:
          /// Mutateur ///
@@ -210 +211 @@
          bool isCompressible_;
          bool isRedistributed_;
-         TransMapTypes transformationMap_;
-         std::vector<int> nGlobDomain_;
+         TransMapTypes transformationMap_;         
          bool isUnstructed_;
        

XIOS/trunk/src/node/expand_domain.cpp

@@ -38 +38 @@
   void CExpandDomain::checkValid(CDomain* domainDst)
   {
-    if (CDomain::type_attr::unstructured != domainDst->type)
-    {
-      ERROR("CExpandDomain::checkValid(CDomain* domainDst)",
-            << "Domain extension is only supported for unstructured" << std::endl
-            << "Check type of domain destination, id = " << domainDst->getId());
-    }
+    // if (CDomain::type_attr::unstructured != domainDst->type)
+    // {
+    //   ERROR("CExpandDomain::checkValid(CDomain* domainDst)",
+    //         << "Domain extension is only supported for unstructured" << std::endl
+    //         << "Check type of domain destination, id = " << domainDst->getId());
+    // }
 
     if (this->type.isEmpty()) this->type.setValue(CExpandDomain::type_attr::edge);

XIOS/trunk/src/node/grid.cpp

@@ -31 +31 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
    {
@@ -49 +49 @@
       , clientDistribution_(0), isIndexSent(false) , serverDistribution_(0), clientServerMap_(0)
       , writtenDataSize_(0), numberWrittenIndexes_(0), totalNumberWrittenIndexes_(0), offsetWrittenIndexes_(0)
-      , globalDim_(), connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
+      , connectedDataSize_(), connectedServerRank_(), isDataDistributed_(true), isCompressible_(false)
       , transformations_(0), isTransformed_(false)
-      , axisPositionInGrid_(), positionDimensionDistributed_(1), hasDomainAxisBaseRef_(false)
+      , axisPositionInGrid_(), hasDomainAxisBaseRef_(false)
       , gridSrc_(), hasTransform_(false), isGenerated_(false), order_(), globalIndexOnServer_()
    {
@@ -74 +74 @@
 
 
-   StdSize CGrid::getDimension(void) const
-   {
-      return globalDim_.size();
+   StdSize CGrid::getDimension(void)
+   {
+      return getGlobalDimension().size();
    }
 
@@ -185 +185 @@
         for (int i = 0; i < axisListP.size(); ++i)
         {
-          axisListP[i]->checkAttributesOnClientAfterTransformation(globalDim_,axisPositionInGrid_[i]);
+          axisListP[i]->checkAttributesOnClientAfterTransformation(getGlobalDimension(),axisPositionInGrid_[i]);
         }
       }
@@ -232 +232 @@
      this->solveScalarRef(areAttributesChecked);
      this->solveAxisRef(areAttributesChecked);
-     this->solveDomainRef(areAttributesChecked);
-     computeGridGlobalDimension(getDomains(), getAxis(), getScalars(), axis_domain_order);
+     this->solveDomainRef(areAttributesChecked);     
      this->isDomainAxisChecked = areAttributesChecked;
    }
@@ -463 +462 @@
         {
           if (sendAtt)
-            axisListP[i]->sendCheckedAttributes(globalDim_,axisPositionInGrid_[i]);
+            axisListP[i]->sendCheckedAttributes(getGlobalDimension(),axisPositionInGrid_[i]);
           else
             axisListP[i]->checkAttributesOnClient();
@@ -533 +532 @@
      // Compute mapping between client and server
      std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
-     CServerDistributionDescription serverDistributionDescription(globalDim_, client->serverSize);
+     CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize);
      serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement,
                                                                 client->clientRank,
                                                                 client->clientSize,
                                                                 axis_domain_order,
-                                                                positionDimensionDistributed_);
+                                                                getDistributedDimension());
      computeIndexByElement(indexServerOnElement, globalIndexOnServer_);
 
@@ -1323 +1322 @@
   }
 
-  void CGrid::computeGridGlobalDimension(const std::vector<CDomain*>& domains,
-                                         const std::vector<CAxis*>& axis,
-                                         const std::vector<CScalar*>& scalars,
-                                         const CArray<int,1>& axisDomainOrder)
-  {
-    globalDim_.resize(domains.size()*2+axis.size()+scalars.size());
+  /*
+     Compute on the fly the global dimension of a grid with its elements
+     \param[in/out] globalDim global dimension of grid
+     \param[in] domains list of its domains
+     \param[in] axiss list of its axis
+     \param[in] scalars list of its scalars
+     \param[in] axisDomainOrder the order of element in a grid (e.g: scalar then axis)
+     \return The dimension of which we do distribution (often for server)
+  */
+  int CGrid::computeGridGlobalDimension(std::vector<int>& globalDim,
+                                        const std::vector<CDomain*> domains,
+                                        const std::vector<CAxis*> axis,
+                                        const std::vector<CScalar*> scalars,
+                                        const CArray<int,1>& axisDomainOrder)
+  {
+    globalDim.resize(domains.size()*2+axis.size()+scalars.size());
+    int positionDimensionDistributed = 1;
     int idx = 0, idxDomain = 0, idxAxis = 0, idxScalar = 0;
     for (int i = 0; i < axisDomainOrder.numElements(); ++i)
@@ -1336 +1346 @@
         if (!(domains[idxDomain]->type.isEmpty()) && (domains[idxDomain]->type==CDomain::type_attr::unstructured))
         {
-          positionDimensionDistributed_ = idx;
+          positionDimensionDistributed = idx;
         }
         else
         {
-          positionDimensionDistributed_ = idx +1;
-        }
-
-        globalDim_[idx]   = domains[idxDomain]->ni_glo.getValue();
-        globalDim_[idx+1] = domains[idxDomain]->nj_glo.getValue();
+          positionDimensionDistributed = idx +1;
+        }
+
+        globalDim[idx]   = domains[idxDomain]->ni_glo.getValue();
+        globalDim[idx+1] = domains[idxDomain]->nj_glo.getValue();
 
         ++idxDomain;
@@ -1351 +1361 @@
       else if (1 == axisDomainOrder(i))
       {
-        globalDim_[idx] = axis[idxAxis]->n_glo.getValue();
+        globalDim[idx] = axis[idxAxis]->n_glo.getValue();
         ++idxAxis;
         ++idx;
@@ -1357 +1367 @@
       else
       {
-        globalDim_[idx] = 1;
+        globalDim[idx] = 1;
         ++idxScalar;
         ++idx;
       }
     }
-  }
-
+
+    return positionDimensionDistributed;
+  }
+
+  // Retrieve the global dimension of grid
   std::vector<int> CGrid::getGlobalDimension()
   {
-    return globalDim_;
+    std::vector<int> globalDim;
+    computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);
+
+    return globalDim;
+  }
+
+  // Retrieve dimension on which we do distribution (Very often, it should be 2nd dimension)
+  int CGrid::getDistributedDimension()
+  {
+    std::vector<int> globalDim;
+    return computeGridGlobalDimension(globalDim, getDomains(), getAxis(), getScalars(), axis_domain_order);    
   }
 

XIOS/trunk/src/node/grid.hpp

@@ -87 +87 @@
 
          /// Accesseurs ///
-         StdSize getDimension(void) const;
+         StdSize getDimension(void);
 
          StdSize  getDataSize(void) const;
@@ -229 +229 @@
          void modifyMask(const CArray<int,1>& indexToModify);
 
-         void computeGridGlobalDimension(const std::vector<CDomain*>& domains,
-                                         const std::vector<CAxis*>& axis,
-                                         const std::vector<CScalar*>& scalars,
-                                         const CArray<int,1>& axisDomainOrder);
-
       private:
        template<int N>
@@ -261 +256 @@
                                    CClientServerMapping::GlobalIndexMap& globalIndexOnServer);
 
+        int computeGridGlobalDimension(std::vector<int>& globalDim,
+                                       const std::vector<CDomain*> domains,
+                                       const std::vector<CAxis*> axis,
+                                       const std::vector<CScalar*> scalars,
+                                       const CArray<int,1>& axisDomainOrder);
+
+        int getDistributedDimension();
       private:
         CDomainGroup* vDomainGroup_;
@@ -276 +278 @@
         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_;
@@ -285 +287 @@
         std::vector<int> axisPositionInGrid_;
         CGridTransformation* transformations_;
-        bool hasDomainAxisBaseRef_;
-        std::vector<int> globalDim_;
+        bool hasDomainAxisBaseRef_;        
         std::map<CGrid*, std::pair<bool,StdString> > gridSrc_;
         bool hasTransform_;

XIOS/trunk/src/transformation/domain_algorithm_expand.cpp

@@ -45 +45 @@
                                                CDomain* domainSource,
                                                CExpandDomain* expandDomain)
-: CDomainAlgorithmTransformation(domainDestination, domainSource)
+: CDomainAlgorithmTransformation(domainDestination, domainSource),
+  isXPeriodic_(false), isYPeriodic_(false)
 {
   if (domainDestination == domainSource)
@@ -55 +56 @@
   }
 
-//  if (!domainDestination->hasRefTo(domainSource))
-//  {
-//    ERROR("CDomainAlgorithmExpand::CDomainAlgorithmExpand(CDomain* domainDestination,CDomain* domainSource, CExpandDomain* expandDomain)",
-//           << "Domain domain destination must refer to domain source (directly or indirectly) by domain_ref " << std::endl
-//           << "Domain source " <<domainSource->getId() << std::endl
-//           << "Domain destination " <<domainDestination->getId() << std::endl);
-//  }
-
   this->type_ = (ELEMENT_MODIFICATION_WITH_DATA);
   expandDomain->checkValid(domainDestination);
+  if (!expandDomain->i_periodic.isEmpty()) isXPeriodic_ = expandDomain->i_periodic;
+  if (!expandDomain->j_periodic.isEmpty()) isYPeriodic_ = expandDomain->j_periodic;
 
   switch (expandDomain->type)
@@ -92 +87 @@
   CContextClient* client=context->client;
 
+  int type = 1; // For edge
+  CMesh mesh;
   CArray<double,2>& bounds_lon_src = domainSource->bounds_lon_1d;
   CArray<double,2>& bounds_lat_src = domainSource->bounds_lat_1d;
   CArray<int,2> neighborsSrc;
-
-  int type = 1; // For edge
-  CMesh mesh;
-  mesh.getGlobalNghbFaces(type, client->intraComm, domainSource->i_index, bounds_lon_src, bounds_lat_src, neighborsSrc);
-  updateDomainAttributes(domainDestination, domainSource, neighborsSrc);
+  switch (domainSource->type) {
+   case CDomain::type_attr::unstructured:      
+      mesh.getGlobalNghbFaces(type, client->intraComm, domainSource->i_index, bounds_lon_src, bounds_lat_src, neighborsSrc);
+      updateUnstructuredDomainAttributes(domainDestination, domainSource, neighborsSrc);
+      break;
+   default:
+      updateRectilinearDomainAttributes(domainDestination, domainSource, neighborsSrc);
+      break;      
+  }  
 }
 
@@ -113 +114 @@
   CContextClient* client=context->client;
 
+  int type = 1; // For edge
+  CMesh mesh;
   CArray<double,2>& bounds_lon_src = domainSource->bounds_lon_1d;
   CArray<double,2>& bounds_lat_src = domainSource->bounds_lat_1d;
   CArray<int,2> neighborsSrc;
-
-  int type = 0; // For node
-  CMesh mesh;
-  mesh.getGlobalNghbFaces(type, client->intraComm, domainSource->i_index, bounds_lon_src, bounds_lat_src, neighborsSrc);
-  updateDomainAttributes(domainDestination, domainSource, neighborsSrc);
+  switch (domainSource->type) {
+   case CDomain::type_attr::unstructured:      
+      mesh.getGlobalNghbFaces(type, client->intraComm, domainSource->i_index, bounds_lon_src, bounds_lat_src, neighborsSrc);
+      updateUnstructuredDomainAttributes(domainDestination, domainSource, neighborsSrc);
+      break;
+   default:
+      updateRectilinearDomainAttributes(domainDestination, domainSource, neighborsSrc);
+      break;      
+  }  
+}
+
+/*!
+ *  Extend rectilinear or curvilinear domain destination and update its attributes
+ *  Suppose that domain destination and domain source have the same values for all attributes (by inheritance)
+ *  \param [in/out] domainDestination domain destination
+ *  \param [in] domainSource domain source
+ *  \param [in] neighborsDomainSrc neighbor of domain source. For now, we don't need it for rectilinear
+ */
+void CDomainAlgorithmExpand::updateRectilinearDomainAttributes(CDomain* domainDestination,
+                                                               CDomain* domainSource,
+                                                               CArray<int,2>& neighborsDomainSrc)
+{
+  int index, globalIndex, idx;
+  int iindexDst, jindexDst, globIndexDst;
+  int iindexSrc, jindexSrc, globIndexSrc;
+  CContext* context = CContext::getCurrent();
+  CContextClient* client=context->client;
+
+  // First of all, "copy" all attributes of domain source to domain destination
+  StdString domainDstRef = (!domainDestination->domain_ref.isEmpty()) ? domainDestination->domain_ref.getValue()
+                                                                      : "";
+  if (domainDstRef != domainSource->getId())
+  {
+    domainDestination->domain_ref.setValue(domainSource->getId());
+    domainDestination->solveRefInheritance(true);
+  }
+
+  if (domainDstRef.empty()) domainDestination->domain_ref.reset();
+  else domainDestination->domain_ref.setValue(domainDstRef);
+
+  // Here are attributes of source need tranfering
+  int niGloSrc = domainSource->ni_glo;
+  int njGloSrc = domainSource->nj_glo;
+  int niSrc = domainSource->ni, ibegin = domainSource->ibegin;
+  int njSrc = domainSource->nj, jbegin = domainSource->jbegin;
+  CArray<bool,1>& mask_1d_src = domainSource->mask_1d;
+  CArray<int,1>& i_index_src = domainSource->i_index;
+  CArray<int,1>& j_index_src = domainSource->j_index;
+  CArray<int,1>& data_i_index_src = domainSource->data_i_index;
+  CArray<int,1>& data_j_index_src = domainSource->data_j_index;
+  int data_i_begin_src = domainSource->data_ibegin;
+  int data_j_begin_src = domainSource->data_jbegin;
+  CArray<double,1>& lon_src = domainSource->lonvalue_client;
+  CArray<double,1>& lat_src = domainSource->latvalue_client;
+
+  // We need to generate boundary for longitude and latitude
+  if (domainSource->bounds_lon_1d.isEmpty() || domainSource->bounds_lat_1d.isEmpty())
+  {
+    CArray<double,1> lon = lon_src(Range(0,niSrc-1));
+    CArray<double,1> lat = lat_src(Range(0,lat_src.numElements()-1,niSrc));
+    CArray<double,2>& bounds_lon_src = domainSource->bounds_lon_1d;
+    CArray<double,2>& bounds_lat_src = domainSource->bounds_lat_1d;
+    domainSource->fillInRectilinearBoundLonLat(lon_src, lat_src, bounds_lon_src, bounds_lat_src);
+  }
+
+
+  CArray<double,2>& bounds_lon_src = domainSource->bounds_lon_1d;
+  CArray<double,2>& bounds_lat_src = domainSource->bounds_lat_1d;
+
+  int nVertex       = bounds_lon_src.shape()[0];
+  int oldNbLocal = i_index_src.numElements();
+  int dataIindexBoundSrc = max(i_index_src) - min(i_index_src);
+  int dataJindexBoundSrc = max(j_index_src) - min(j_index_src);
+
+  // Uncompress data_i_index, data_j_index
+  CArray<int,1> data_i_index_src_full(oldNbLocal);
+  CArray<int,1> data_j_index_src_full(oldNbLocal);
+  int nbUnMaskedPointOnLocalDomain = 0;
+  data_i_index_src_full = -1; // Suppose all values are masked
+  data_j_index_src_full = -1; // Suppose all values are masked
+  for (idx = 0; idx < data_i_index_src.numElements(); ++idx)
+  {
+    int dataIidx = data_i_index_src(idx) + data_i_begin_src;
+    int dataJidx = data_j_index_src(idx) + data_j_begin_src;
+    if ((0 <= dataIidx) && (dataIidx <= dataIindexBoundSrc) &&
+        (0 <= dataJidx) && (dataJidx <= dataJindexBoundSrc))
+    {
+      data_i_index_src_full(nbUnMaskedPointOnLocalDomain) = dataIidx;
+      data_j_index_src_full(nbUnMaskedPointOnLocalDomain) = dataJidx;
+      ++nbUnMaskedPointOnLocalDomain;
+    }
+  }
+
+  // Expand domain destination, not only local but also global
+  int niGloDst = niGloSrc + 2;
+  int njGloDst = njGloSrc + 2;
+  int niDst = niSrc + 2;
+  int njDst = njSrc + 2;
+  domainDestination->ni_glo.setValue(niGloDst);
+  domainDestination->nj_glo.setValue(njGloDst);
+  domainDestination->ni.setValue(niDst);
+  domainDestination->nj.setValue(njDst);
+  domainDestination->global_zoom_ni.setValue(domainSource->global_zoom_ni+2);
+  domainDestination->global_zoom_nj.setValue(domainSource->global_zoom_nj+2);
+
+  CArray<bool,1>& mask_1d_dst = domainDestination->mask_1d;
+  CArray<int,1>& i_index_dst  = domainDestination->i_index;
+  CArray<int,1>& j_index_dst  = domainDestination->j_index;  
+  CArray<int,1>& data_i_index_dst  = domainDestination->data_i_index;
+  CArray<int,1>& data_j_index_dst  = domainDestination->data_j_index;
+  
+  // Make sure that we use only lonvalue_client, latvalue_client
+  if (!domainDestination->lonvalue_1d.isEmpty()) domainDestination->lonvalue_1d.reset();
+  if (!domainDestination->latvalue_1d.isEmpty()) domainDestination->latvalue_1d.reset();
+  if (!domainDestination->lonvalue_2d.isEmpty()) domainDestination->lonvalue_2d.reset();
+  if (!domainDestination->latvalue_2d.isEmpty()) domainDestination->latvalue_2d.reset();
+
+  // Recalculate i_index, j_index of extended domain
+  // Should be enough for common case, but if we have arbitrary distribution?
+  int newNbLocalDst = niDst * njDst;     
+
+  mask_1d_dst.resize(newNbLocalDst);
+  i_index_dst.resize(newNbLocalDst);
+  j_index_dst.resize(newNbLocalDst);
+  CArray<int,1> data_i_index_dst_full(newNbLocalDst, -1);
+  CArray<int,1> data_j_index_dst_full(newNbLocalDst, -1);
+
+  domainDestination->lonvalue_client.resizeAndPreserve(newNbLocalDst);  
+  domainDestination->latvalue_client.resizeAndPreserve(newNbLocalDst);
+  domainDestination->bounds_lon_1d.resizeAndPreserve(nVertex, newNbLocalDst);
+  domainDestination->bounds_lat_1d.resizeAndPreserve(nVertex, newNbLocalDst);
+  CArray<double,1>& lon_dst   = domainDestination->lonvalue_client;
+  CArray<double,1>& lat_dst   = domainDestination->latvalue_client;
+  CArray<double,2>& bounds_lon_dst = domainDestination->bounds_lon_1d;
+  CArray<double,2>& bounds_lat_dst = domainDestination->bounds_lat_1d;
+
+  // Update i_index, j_index
+  for (int j = 0; j < njDst; ++j)
+    for (int i = 0; i < niDst; ++i)
+    {
+      idx = j * niDst + i; 
+      i_index_dst(idx) = i + ibegin;
+      j_index_dst(idx) = j + jbegin;
+    }
+
+ 
+
+  // 1. Fill in array relating to global index (i_index, j_index, transmap, etc, ...)
+  // Global index mapping between destination and source
+  this->transformationMapping_.resize(1);
+  this->transformationWeight_.resize(1);
+  TransformationIndexMap& transMap = this->transformationMapping_[0];
+  TransformationWeightMap& transWeight = this->transformationWeight_[0];
+
+  transMap.rehash(std::ceil(newNbLocalDst/transMap.max_load_factor()));
+  transWeight.rehash(std::ceil(newNbLocalDst/transWeight.max_load_factor()));
+  
+  // Index mapping for local domain
+  // Mapping global index of expanded domain into original one 
+  // (Representing global index of expanded domain in form of global index of original one)
+  CArray<size_t,1> globalIndexSrcOnDstDomain(newNbLocalDst); 
+  for (idx = 0; idx < newNbLocalDst; ++idx)
+  {
+    iindexDst = i_index_dst(idx);
+    jindexDst = j_index_dst(idx);
+    globIndexDst = jindexDst * niGloDst + iindexDst;
+    globIndexSrc = (((jindexDst-1)+njGloSrc) % njGloSrc) * niGloSrc + (((iindexDst-1)+niGloSrc) % niGloSrc) ;
+    globalIndexSrcOnDstDomain(idx) = globIndexSrc;
+
+    transMap[globIndexDst].push_back(globIndexSrc);
+    transWeight[globIndexDst].push_back(1.0); 
+  }
+
+  // 2. Exchange local info among domains (lon,lat,bounds,mask,etc,...)
+  CClientClientDHTDouble::Index2VectorInfoTypeMap localData;
+  localData.rehash(std::ceil(oldNbLocal/localData.max_load_factor()));
+
+  // Information exchanged among domains (attention to their order), number in parentheses presents size of data
+  // lon(1) + lat(1) + bounds_lon(nVertex) + bounds_lat(nVertex) + mask(1) + data_i_index(1)
+  int dataPackageSize =  1 + 1 + // lon + lat
+                         nVertex + nVertex + //bounds_lon + bounds_lat
+                         1 + // mask_1d_dst;
+                         1 + 1; // data_i_index + data_j_index
+  // Initialize database
+  for (int idx = 0; idx < oldNbLocal; ++idx)
+  {
+    index = i_index_src(idx) + j_index_src(idx) * niGloSrc;
+    localData[index].resize(dataPackageSize);
+    std::vector<double>& data = localData[index];
+
+    //Pack data
+    int dataIdx = 0;
+    data[dataIdx] = lon_src(idx);++dataIdx;
+    data[dataIdx] = lat_src(idx);++dataIdx;
+    for (int i = 0; i < nVertex; ++i)
+    {
+      data[dataIdx] = bounds_lon_src(i,idx); ++dataIdx;
+    }
+    for (int i = 0; i < nVertex; ++i)
+    {
+      data[dataIdx] = bounds_lat_src(i,idx); ++dataIdx;
+    }
+    data[dataIdx] = mask_1d_src(idx) ? 1.0 : -1.0; ++dataIdx;
+    data[dataIdx] = data_i_index_src_full(idx);++dataIdx;
+    data[dataIdx] = data_j_index_src_full(idx);
+  }
+
+  CClientClientDHTDouble dhtData(localData,client->intraComm);
+  dhtData.computeIndexInfoMapping(globalIndexSrcOnDstDomain);
+  CClientClientDHTDouble::Index2VectorInfoTypeMap& neighborData = dhtData.getInfoIndexMap();
+  CClientClientDHTDouble::Index2VectorInfoTypeMap::iterator ite = neighborData.end(), it;
+
+  // Ok get all data for destination
+  // If domain is not periodic, then we mask all extended part.
+  int nbUnMaskedPointOnExtendedPart = 0, remainder = 0, dataIIndex, dataJIndex;
+  size_t nIdx;
+  double maskValue = 1.0;
+  for (index = 0; index < newNbLocalDst; ++index)
+  {
+     nIdx = globalIndexSrcOnDstDomain(index);
+     it = neighborData.find(nIdx);
+     if (ite != it)
+     {
+        std::vector<double>& data = it->second;
+        // Unpack data
+        int dataIdx = 0;
+        lon_dst(index) = data[dataIdx]; ++dataIdx;
+        lat_dst(index) = data[dataIdx]; ++dataIdx;
+        for (int i = 0; i < nVertex; ++i)
+        {
+          bounds_lon_dst(i,index) = data[dataIdx]; ++dataIdx;
+        }
+        for (int i = 0; i < nVertex; ++i)
+        {
+          bounds_lat_dst(i,index) = data[dataIdx]; ++dataIdx;
+        }
+        
+        // Check whether we have x periodic. If we don't, we should mask all point at 0 and niGloDst-1
+        maskValue = data[dataIdx];
+        if (!isXPeriodic_) 
+        {
+          remainder = i_index_dst(index) % (niGloDst-1);
+          if (0 == remainder) 
+          {
+            maskValue = -1.0;
+          }
+        }
+
+        if (!isYPeriodic_) 
+        {
+          remainder = j_index_dst(index) % (njGloDst-1);
+          if (0 == remainder) 
+          {
+            maskValue = -1.0;
+          }
+        }
+
+        mask_1d_dst(index) = (1.0 == maskValue) ? true : false; ++dataIdx;
+
+        dataIIndex = (int) data[dataIdx];
+        if (!isXPeriodic_) 
+        {
+          remainder = i_index_dst(index) % (niGloDst-1);
+          if (0 == remainder) 
+          {
+            dataIIndex = -1;
+          }
+        }
+        data_i_index_dst_full(index) = dataIIndex; ++dataIdx;
+        
+        dataJIndex = (int) data[dataIdx];
+        if (!isYPeriodic_) 
+        {
+          remainder = j_index_dst(index) % (njGloDst-1);
+          if (0 == remainder) 
+          {
+            dataJIndex = -1;
+          }
+        }        
+        data_j_index_dst_full(index) = dataJIndex;
+
+        if ((0 <= data_i_index_dst_full(index)) && (0 <= data_j_index_dst_full(index)))
+        {
+          ++nbUnMaskedPointOnExtendedPart;
+        }
+     }
+  }
+
+  
+  // Finally, update data_i_index, data_j_index
+  data_i_index_dst.resize(nbUnMaskedPointOnExtendedPart);
+  data_j_index_dst.resize(nbUnMaskedPointOnExtendedPart); 
+  int count = 0; 
+  for (idx = 0; idx < newNbLocalDst; ++idx)
+  {
+    dataIIndex = data_i_index_dst_full(idx);
+    dataJIndex = data_j_index_dst_full(idx);
+    if ((0 <= dataIIndex) && (0 <= dataJIndex))
+    {
+      data_i_index_dst(count) = i_index_dst(idx) - i_index_dst(0);
+      data_j_index_dst(count) = j_index_dst(idx) - j_index_dst(0);
+      ++count;
+    }
+  }
+
+  // Update data_ni, data_nj
+  domainDestination->data_ni.setValue(niDst);
+  domainDestination->data_nj.setValue(njDst);
+  domainDestination->data_ibegin.setValue(0);
+  domainDestination->data_jbegin.setValue(0);
+
+
+  // Update longitude and latitude 
+  if (niSrc == domainSource->lonvalue_1d.numElements() && njSrc == domainSource->latvalue_1d.numElements()) // Ok, we have rectilinear here
+  {
+     domainDestination->lonvalue_1d.resize(niDst);
+     domainDestination->lonvalue_1d = lon_dst(Range(0,niDst-1));
+     domainDestination->latvalue_1d.resize(njDst);
+     domainDestination->latvalue_1d = lat_dst(Range(0,lat_dst.numElements()-1,niDst));
+  }
+  else // It should be curvilinear
+  {
+     domainDestination->lonvalue_1d.resize(lon_dst.numElements());
+     domainDestination->lonvalue_1d = lon_dst;
+     domainDestination->latvalue_1d.resize(lat_dst.numElements());
+     domainDestination->latvalue_1d = (lat_dst);
+  }
+
 }
 
@@ -130 +456 @@
  *  \param [in] neighborsDomainSrc domain extended part
  */
-void CDomainAlgorithmExpand::updateDomainAttributes(CDomain* domainDestination,
-                                                    CDomain* domainSource,
-                                                    CArray<int,2>& neighborsDomainSrc)
-{
+void CDomainAlgorithmExpand::updateUnstructuredDomainAttributes(CDomain* domainDestination,
+                                                                CDomain* domainSource,
+                                                                CArray<int,2>& neighborsDomainSrc)
+{
+
   CContext* context = CContext::getCurrent();
   CContextClient* client=context->client;
@@ -255 +582 @@
       data[dataIdx] = bounds_lat_src(i,idx); ++dataIdx;
     }
-    data[dataIdx] = mask_1d_src(idx) ? 1.0 : -1; ++dataIdx;
+    data[dataIdx] = mask_1d_src(idx) ? 1.0 : -1.0; ++dataIdx;
     data[dataIdx] = data_i_index_src_full(idx);
   }
@@ -308 +635 @@
   {
     dataIdx = data_i_index_dst_full(idx);
-    if ((0 <= dataIdx) && (dataIdx < newNbLocalDst))
+    if ((0 <= dataIdx))
     {
       ++count;
@@ -322 +649 @@
   {
     dataIdx = data_i_index_dst_full(idx);
-    if ((0 <= dataIdx) && (dataIdx < newNbLocalDst))
+    if ((0 <= dataIdx))
     {
       data_i_index_dst(count) = dataIdx;
@@ -331 +658 @@
   // Update ni
   domainDestination->ni.setValue(newNbLocalDst);
-
 }
 

XIOS/trunk/src/transformation/domain_algorithm_expand.hpp

@@ -30 +30 @@
 
 protected:
+  bool isXPeriodic_; // Flag to determine the periodicity of expansion (only for rectilinear)
+  bool isYPeriodic_; // Flag to determine the periodicity of expansion (only for rectilinear)
+
+protected:
   void expandDomainEdgeConnectivity(CDomain* domainDestination, CDomain* domainSource);
   void expandDomainNodeConnectivity(CDomain* domainDestination, CDomain* domainSource);
-  void updateDomainAttributes(CDomain* domainDestination,
-                              CDomain* domainSource,
-                              CArray<int,2>& neighborsDomainSrc);
+  void updateRectilinearDomainAttributes(CDomain* domainDestination,
+                                         CDomain* domainSource,
+                                         CArray<int,2>& neighborsDomainSrc);
+
+  void updateUnstructuredDomainAttributes(CDomain* domainDestination,
+                                          CDomain* domainSource,
+                                          CArray<int,2>& neighborsDomainSrc);
 
 protected:

XIOS/trunk/src/transformation/grid_transformation.cpp

@@ -236 +236 @@
   }
 
-  tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, scalarDst, elementOrder);
-  tmpGridDestination_->computeGridGlobalDimension(domainDst, axisDst, scalarDst, elementOrder);
+  tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, scalarDst, elementOrder);  
   tempGridDests_.push_back(tmpGridDestination_);
 }
@@ -322 +321 @@
   }
 
-  gridSource_ = CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);
-  gridSource_->computeGridGlobalDimension(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);
+  gridSource_ = CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);  
 
   tempGridSrcs_.push_back(gridSource_);