Changeset 727 for XIOS/trunk

Timestamp:

10/09/15 14:51:28 (9 years ago)

Author:

mhnguyen

Message:

Add more attributes to generate_rectilinear_domain

+) Longitude and latitude of an auto-generated domain can be specified by its boundaries whose values are determined by range

Test
+) On Curie
+) test_remap passes

Location:

XIOS/trunk/src

Files:

• client_client_dht_template.hpp (modified) (1 diff)
• config/generate_rectilinear_domain_attribute.conf (modified) (1 diff)
• node/domain.cpp (modified) (5 diffs)
• node/domain.hpp (modified) (1 diff)
• node/generate_rectilinear_domain.cpp (modified) (1 diff)
• transformation/domain_algorithm_generate_rectilinear.cpp (modified) (1 diff)

XIOS/trunk/src/client_client_dht_template.hpp

@@ -32 +32 @@
   public:
     typedef T InfoType;
-    const int infoTypeSize = sizeof(InfoType);
+    static const int infoTypeSize = sizeof(InfoType);
 
   public:

XIOS/trunk/src/config/generate_rectilinear_domain_attribute.conf

@@ +1 @@
+/* GLOBAL */
+DECLARE_ATTRIBUTE(double    , bounds_lon_start)
+DECLARE_ATTRIBUTE(double    , bounds_lon_end)
+DECLARE_ATTRIBUTE(double    , bounds_lat_start)
+DECLARE_ATTRIBUTE(double    , bounds_lat_end)
 
+DECLARE_ATTRIBUTE(double    , lon_start)
+DECLARE_ATTRIBUTE(double    , lon_end)
+DECLARE_ATTRIBUTE(double    , lat_start)
+DECLARE_ATTRIBUTE(double    , lat_end)

XIOS/trunk/src/node/domain.cpp

@@ -174 +174 @@
      if (type_attr::rectilinear == type)
      {
+        this->isRedistributed_ = true;
+
         CContext* context = CContext::getCurrent();
         CContextClient* client = context->client;
@@ -271 +273 @@
         // Now fill other attributes
         fillInRectilinearLonLat();
-        this->isRedistributed_ = true;
      }
    }
@@ -287 +288 @@
      latvalue_1d.resize(nj);
 
-     double lonStep = double(360/ni_glo.getValue());
-     double latStep = double(180/nj_glo.getValue());
+     double lonRange = lon_end - lon_start;
+     double latRange = lat_end - lat_start;
+
+     double lonStep = lonRange/double(ni_glo.getValue());
+     double latStep = latRange/double(nj_glo.getValue());
 
      // Assign lon value
      for (int i = 0; i < ni; ++i)
      {
-       lonvalue_1d(i) = static_cast<double>(ibegin + i) * lonStep -180 + lonStep/2;
+       if (0 == (ibegin + i))
+       {
+         lonvalue_1d(i) = lon_start;
+       }
+       else if (ni_glo == (ibegin + i + 1))
+       {
+         lonvalue_1d(i) = lon_end;
+       }
+       else
+       {
+         lonvalue_1d(i) = (ibegin + i) * lonStep  + lon_start;
+       }
      }
 
      for (int j = 0; j < nj; ++j)
      {
-       latvalue_1d(j) = static_cast<double>(jbegin + j) * latStep - 90 + latStep/2;
+       if (0 == (jbegin + j))
+       {
+          latvalue_1d(j) = lat_start;
+       }
+       else if (nj_glo == (jbegin + j + 1))
+       {
+          latvalue_1d(j) = lat_end;
+       }
+       else
+       {
+         latvalue_1d(j) =  (jbegin + j) * latStep + lat_start;
+       }
      }
    }
@@ -307 +333 @@
      const int nvertexValue = 4;
 
+     double boundsLonRange = bounds_lon_end - bounds_lon_start;
+     double boundsLatRange = bounds_lat_end - bounds_lat_start;
+
      boundsLon.resize(nvertexValue,ni*nj);
      boundsLat.resize(nvertexValue,nj*ni);
 
-     double lonStep = double(360/ni_glo.getValue());
-     double latStep = double(180/nj_glo.getValue());
+     double lonStep = boundsLonRange/double(ni_glo.getValue());
+     double latStep = boundsLatRange/double(nj_glo.getValue());
 
      for(j=0;j<nj;++j)
@@ -317 +346 @@
        {
          k=j*ni+i;
-         boundsLon(0,k) = boundsLon(1,k) = (0 != (ibegin + i)) ? (ibegin + i) * lonStep -180
-                                                               : -180;
-         boundsLon(2,k) = boundsLon(3,k) = ((ibegin + i + 1) != ni_glo) ? (ibegin + i +1) * lonStep -180
-                                                                        : 180;
-
-         boundsLat(1,k) = boundsLat(2,k) = (0 != (jbegin + j)) ? (jbegin + j) * latStep - 90
-                                                               : -90;
-         boundsLat(0,k) = boundsLat(3,k) = ((jbegin + j +1) != nj_glo) ? (jbegin + j +1) * latStep - 90
-                                                               : +90;
+         boundsLon(0,k) = boundsLon(1,k) = (0 != (ibegin + i)) ? (ibegin + i) * lonStep + bounds_lon_start
+                                                               : bounds_lon_start;
+         boundsLon(2,k) = boundsLon(3,k) = ((ibegin + i + 1) != ni_glo) ? (ibegin + i +1) * lonStep + bounds_lon_start
+                                                                        : bounds_lon_end;
+
+         boundsLat(1,k) = boundsLat(2,k) = (0 != (jbegin + j)) ? (jbegin + j) * latStep + bounds_lat_start
+                                                               : bounds_lat_start;
+         boundsLat(0,k) = boundsLat(3,k) = ((jbegin + j +1) != nj_glo) ? (jbegin + j +1) * latStep + bounds_lat_start
+                                                               : bounds_lat_end;
        }
    }

XIOS/trunk/src/node/domain.hpp

@@ -103 +103 @@
          int nj_srv,jbegin_srv,jend_srv ;
          int zoom_nj_srv,zoom_jbegin_srv,zoom_jend_srv ;
+
+         double bounds_lon_start, bounds_lon_end;
+         double bounds_lat_start, bounds_lat_end;
+         double lon_start, lon_end;
+         double lat_start, lat_end;
 
          CArray<double, 1> lonvalue_srv, latvalue_srv ;

XIOS/trunk/src/node/generate_rectilinear_domain.cpp

@@ -23 +23 @@
   ENodeType CGenerateRectilinearDomain::GetType(void)    { return eGenerateRectilinearDomain; }
 
-  void CGenerateRectilinearDomain::checkValid(CDomain* domainSrc)
+  void CGenerateRectilinearDomain::checkValid(CDomain* domainDst)
   {
+    const double defaultBndsLonStart = 0;
+    const double defaultBndsLonEnd = 360;
+
+    const double defaultBndsLatStart = -90;
+    const double defaultBndsLatEnd = 90;
+
+    if ((!lon_start.isEmpty() && lon_end.isEmpty()) ||
+        (lon_start.isEmpty() && !lon_end.isEmpty()))
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only longitude start or longitude end attribute is defined." << std::endl
+               << "Must define both: 'lon_start' and 'lon_end'.");
+
+    if ((!lat_start.isEmpty() && lat_end.isEmpty()) ||
+        (lat_start.isEmpty() && !lat_end.isEmpty()))
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only latitude start or latitude end attribute is defined." << std::endl
+               << "Must define both: 'lat_start' and 'lat_end'.");
+
+    if ((!bounds_lon_start.isEmpty() && bounds_lon_end.isEmpty()) ||
+        (bounds_lon_start.isEmpty() && !bounds_lon_end.isEmpty()))
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only longitude boundary start or longitude boundary end attribute is defined." << std::endl
+               << "Must define both: 'bounds_lon_start' and 'bounds_lon_end'.");
+
+    if ((!bounds_lat_start.isEmpty() && bounds_lat_end.isEmpty()) ||
+        (bounds_lat_start.isEmpty() && !bounds_lat_end.isEmpty()))
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only latitude boundary start or latitude boundary end attribute is defined." << std::endl
+               << "Must define both: 'bounds_lat_start' and 'bounds_lat_end'.");
+
+    if (!bounds_lon_start.isEmpty() && !lon_start.isEmpty())
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only one longitude boundary attribute or longitude can be used but both 'bounds_lon_start' and 'lon_start' are defined." << std::endl
+               << "Define only one attribute: 'bounds_lon_start' or 'lon_start'.");
+
+    if (!bounds_lat_start.isEmpty() && !lat_start.isEmpty())
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only one latitude boundary attribute or latitude can be used but both 'bounds_lat_start' and 'lat_start' are defined." << std::endl
+               << "Define only one attribute: 'bounds_lat_start' or 'lat_start'.");
+
+    if (!bounds_lon_start.isEmpty() && !lat_start.isEmpty())
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only one latitude boundary attribute or latitude can be used but both 'bounds_lon_start' and 'lat_start' are defined." << std::endl
+               << "Define only one pair of attributes: ('bounds_lon_start' and 'bounds_lat_start') or ('lon_start' and 'lat_start').");
+
+    if (!bounds_lat_start.isEmpty() && !lon_start.isEmpty())
+         ERROR("CGenerateRectilinearDomain::checkValid(CDomain* domainDst)",
+               << "[ id = " << this->getId() << " , context = '" << CObjectFactory::GetCurrentContextId() << " ] "
+               << "Only one latitude boundary attribute or latitude can be used but both 'bounds_lat_start' and 'lon_start' are defined." << std::endl
+               << "Define only one pair of attributes: ('bounds_lon_start' and 'bounds_lat_start') or ('lon_start' and 'lat_start').");
+
+    if (bounds_lon_start.isEmpty() && bounds_lat_start.isEmpty() &&
+        lon_start.isEmpty() && lat_start.isEmpty())
+    {
+      bounds_lon_start.setValue(defaultBndsLonStart);
+      bounds_lon_end.setValue(defaultBndsLonEnd);
+      bounds_lat_start.setValue(defaultBndsLatStart);
+      bounds_lat_end.setValue(defaultBndsLatEnd);
+    }
+
+    if (!bounds_lon_start.isEmpty())
+    {
+      int niGlo = domainDst->ni_glo.getValue();
+
+      double boundsLonRange = bounds_lon_end - bounds_lon_start;
+      double boundsLonStep = boundsLonRange/double(niGlo);
+      domainDst->bounds_lon_start = bounds_lon_start;
+      domainDst->bounds_lon_end   = bounds_lon_end;
+      domainDst->lon_start = bounds_lon_start + boundsLonStep/2;
+      domainDst->lon_end   = bounds_lon_end   - boundsLonStep/2;
+    }
+
+    if (!bounds_lat_start.isEmpty())
+    {
+      int njGlo = domainDst->nj_glo.getValue();
+
+      double boundsLatRange = bounds_lat_end - bounds_lat_start;
+      double boundsLatStep = boundsLatRange/double(njGlo);
+      domainDst->bounds_lat_start = bounds_lat_start;
+      domainDst->bounds_lat_end   = bounds_lat_end;
+      domainDst->lat_start = bounds_lat_start + boundsLatStep/2;
+      domainDst->lat_end   = bounds_lat_end   - boundsLatStep/2;
+    }
+
+    if (lon_start.isEmpty() && lat_start.isEmpty()) return;
+
+    if (!lon_start.isEmpty())
+    {
+      int niGlo = domainDst->ni_glo.getValue();
+
+      double lonRange = lon_end - lon_start;
+      double lonStep = lonRange/double(niGlo);
+      domainDst->lon_start = lon_start;
+      domainDst->lon_end   = lon_end;
+      domainDst->bounds_lon_start = lon_start - lonStep/2;
+      domainDst->bounds_lon_end   = lon_end   + lonStep/2;
+    }
+
+    if (!lat_start.isEmpty())
+    {
+      int njGlo = domainDst->nj_glo.getValue();
+
+      double latRange = lat_end - lat_start;
+      double latStep = latRange/double(njGlo);
+      domainDst->lat_start = lat_start;
+      domainDst->lat_end   = lat_end;
+      domainDst->bounds_lat_start = lat_start - latStep/2;
+      domainDst->bounds_lat_end   = lat_end   + latStep/2;
+    }
   }
 

XIOS/trunk/src/transformation/domain_algorithm_generate_rectilinear.cpp

@@ -20 +20 @@
 : CDomainAlgorithmTransformation(domainDestination, domainSource), gridSrc_(gridSource), nbDomainDistributedPart_(0)
 {
-  genRectDomain->checkValid(domainSource);
+  genRectDomain->checkValid(domainDestination);
   computeDistributionGridSource();
   fillInAttributesDomainDestination();