Changeset 1275 for XIOS/dev

Timestamp:

09/25/17 10:59:29 (7 years ago)

Author:

ymipsl

Message:

implement diurnal cycle transformation taken as a grid tranformation : scalar -> axis

YM

Location:

XIOS/dev/XIOS_DEV_CMIP6/src

Files:

• config/node_type.conf (modified) (1 diff)
• config/temporal_splitting.conf (added)
• filter/spatial_transform_filter.cpp (modified) (2 diffs)
• filter/spatial_transform_filter.hpp (modified) (1 diff)
• generate_fortran_interface.cpp (modified) (3 diffs)
• group_factory_decl.cpp (modified) (1 diff)
• group_template_decl.cpp (modified) (1 diff)
• node/axis.cpp (modified) (1 diff)
• node/node_enum.hpp (modified) (1 diff)
• node/node_type.hpp (modified) (1 diff)
• node/temporal_splitting.cpp (added)
• node/temporal_splitting.hpp (added)
• node/transformation_enum.hpp (modified) (1 diff)
• object_factory_decl.cpp (modified) (2 diffs)
• object_template_decl.cpp (modified) (2 diffs)
• test/test_diurnal_cycle.f90 (added)
• transformation/algo_types.hpp (modified) (1 diff)
• transformation/axis_algorithm_temporal_splitting.cpp (added)
• transformation/axis_algorithm_temporal_splitting.hpp (added)
• transformation/axis_algorithm_transformation.cpp (modified) (4 diffs)
• transformation/axis_algorithm_transformation.hpp (modified) (3 diffs)
• transformation/grid_transformation_selector.cpp (modified) (1 diff)
• transformation/grid_transformation_selector.hpp (modified) (1 diff)
• type/type_util.hpp (modified) (2 diffs)
• xml_parser_decl.cpp (modified) (1 diff)

XIOS/dev/XIOS_DEV_CMIP6/src/config/node_type.conf

@@ -87 +87 @@
 #endif //__XIOS_CReduceDomainToScalar__
 
+#ifdef __XIOS_CTemporalSplitting__
+   DECLARE_NODE(TemporalSplitting, temporal_splitting)
+#endif //__XIOS_CTemporalSplitting__
+
 #ifdef __XIOS_CContext__
    DECLARE_NODE_PAR(Context, context)

XIOS/dev/XIOS_DEV_CMIP6/src/filter/spatial_transform_filter.cpp

@@ -27 +27 @@
       size_t inputCount = 1 + (auxInputs.empty() ? 0 : auxInputs.size());
       double defaultValue  = (hasMissingValue) ? std::numeric_limits<double>::quiet_NaN() : 0.0;
-      boost::shared_ptr<CSpatialTransformFilter> filter(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
-
+
+
+      const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ;
+      CGridTransformationSelector::ListAlgoType::const_iterator it  ;
+
+      bool isSpatialTemporal=false ;
+      for (it=algoList.begin();it!=algoList.end();++it)  if (it->second.first == TRANS_TEMPORAL_SPLITTING) isSpatialTemporal=true ;
+
+      boost::shared_ptr<CSpatialTransformFilter> filter ;
+      if( isSpatialTemporal) filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount));
+      else filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
+
+      
       if (!lastFilter)
         lastFilter = filter;
@@ -56 +67 @@
       onOutputReady(outputPacket);
   }
+
+
+
+
+
+  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount)
+    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount), record(0)
+  {
+      const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ;
+      CGridTransformationSelector::ListAlgoType::const_iterator it  ;
+
+      int pos ;
+      for (it=algoList.begin();it!=algoList.end();++it) 
+        if (it->second.first == TRANS_TEMPORAL_SPLITTING)
+        {
+          pos=it->first ;
+          if (pos < algoList.size()-1)
+            ERROR("SpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount))",
+                  "temporal splitting operation must be the last of whole transformation on same grid") ;
+        }
+          
+      CGrid* grid=gridTransformation->getGridDestination() ;
+
+      CAxis* axis = grid->getAxis(gridTransformation->getElementPositionInGridDst2AxisPosition().find(pos)->second) ;
+
+      nrecords = axis->index.numElements() ;
+  }
+
+
+  void CSpatialTemporalFilter::onInputReady(std::vector<CDataPacketPtr> data)
+  {
+    CSpatialTransformFilterEngine* spaceFilter = static_cast<CSpatialTransformFilterEngine*>(engine);
+    CDataPacketPtr outputPacket = spaceFilter->applyFilter(data, outputDefaultValue);
+
+    if (outputPacket)
+    {
+      size_t nelements=outputPacket->data.numElements() ;
+      if (!tmpData.numElements())
+      {
+        tmpData.resize(nelements);
+        tmpData=outputDefaultValue ;
+      }
+
+      nelements/=nrecords ;
+      size_t offset=nelements*record ;
+      for(size_t i=0;i<nelements;++i)  tmpData(i+offset) = outputPacket->data(i) ;
+    
+      record ++ ;
+      if (record==nrecords)
+      {
+        record=0 ;
+        CDataPacketPtr packet = CDataPacketPtr(new CDataPacket);
+        packet->date = data[0]->date;
+        packet->timestamp = data[0]->timestamp;
+        packet->status = data[0]->status;
+        packet->data.resize(tmpData.numElements());
+        packet->data = tmpData;
+        onOutputReady(packet);
+        tmpData.resize(0) ;
+      }
+    }
+  }
+
 
   CSpatialTransformFilterEngine::CSpatialTransformFilterEngine(CGridTransformation* gridTransformation)

XIOS/dev/XIOS_DEV_CMIP6/src/filter/spatial_transform_filter.hpp

@@ -49 +49 @@
       double outputDefaultValue;
   }; // class CSpatialTransformFilter
+
+
+ /*!
+   * A specific spatial filter for the temporal_splitting transformation scalar -> axis. An incoming flux will be stored in an aditional dimension given by the destination axis.
+   * At each flux received, the storing index (record) is increased. When it reach the size of the axis (nrecords) a new flux is generated and the record is reset to 0
+   */
+
+ class CSpatialTemporalFilter : public CSpatialTransformFilter
+  {
+    public:
+      /*!
+       * Constructs a filter wrapping the specified spatial transformation.
+       *
+       * \param gc the associated garbage collector
+       * \param engine the engine defining the spatial transformation
+       * \param [in] gridTransformation the associated transformations
+       * \param outputValue default value of output pin
+       * \param [in] inputSlotsCount number of input, by default there is only one for field src
+       */
+      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount = 1);
+
+
+    protected:
+      /*!
+        Overriding this function to process transformations with auxillary inputs
+      */
+      void virtual onInputReady(std::vector<CDataPacketPtr> data);
+      //! Current record in the filter
+      int record ;
+      //! Maximum number of records
+      int nrecords;
+      //! Temporary storage for output flux
+      CArray<double, 1> tmpData; 
+
+
+  }; // class CSpatialTemporalFilter
+
 
   /*!

XIOS/dev/XIOS_DEV_CMIP6/src/generate_fortran_interface.cpp

@@ -41 +41 @@
   CReduceDomainToAxis reduceDomainToAxis;
   CExtractDomainToAxis extractDomainToAxis;
+  CTemporalSplitting temporalSplitting;
 
   CReduceAxisToScalar reduceAxisToScalar;
   CExtractAxisToScalar extractAxisToScalar;
   CReduceDomainToScalar reduceDomainToScalar;
-
+  
   ostringstream oss;
   ofstream file;
@@ -354 +355 @@
   file.close();
 
+  file.open((path+"temporal_splitting_interface_attr.F90").c_str());
+  temporalSplitting.generateFortran2003Interface(file);
+  file.close();
+
   file.open((path+"icextract_domain_to_axis_attr.cpp").c_str());
   extractDomainToAxis.generateCInterface(file);
   file.close();
 
+  file.open((path+"ictemporal_splitting_attr.cpp").c_str());
+  temporalSplitting.generateCInterface(file);
+  file.close();
+
   file.open((path+"iextract_domain_to_axis_attr.F90").c_str());
   extractDomainToAxis.generateFortranInterface(file);
+  file.close();
+
+  file.open((path+"itemporal_splitting_attr.F90").c_str());
+  temporalSplitting.generateFortranInterface(file);
   file.close();
 
@@ -394 +407 @@
   file.close();
 
+  file.open((path+"temporal_splitting_interface_attr.F90").c_str());
+  temporalSplitting.generateFortran2003Interface(file);
+  file.close();
+
   file.open((path+"icreduce_domain_to_scalar_attr.cpp").c_str());
   reduceDomainToScalar.generateCInterface(file);

XIOS/dev/XIOS_DEV_CMIP6/src/group_factory_decl.cpp

@@ -39 +39 @@
   macro(CExtractAxisToScalarGroup)
   macro(CReduceDomainToScalarGroup)
+  macro(CTemporalSplittingGroup)
+
 }

XIOS/dev/XIOS_DEV_CMIP6/src/group_template_decl.cpp

@@ -28 +28 @@
   macro(ExtractAxisToScalar)
   macro(ReduceDomainToScalar)
-
+  macro(TemporalSplitting)
 }

XIOS/dev/XIOS_DEV_CMIP6/src/node/axis.cpp

@@ -52 +52 @@
      m["reduce_domain"] = TRANS_REDUCE_DOMAIN_TO_AXIS;
      m["extract_domain"] = TRANS_EXTRACT_DOMAIN_TO_AXIS;
+     m["temporal_splitting"] = TRANS_TEMPORAL_SPLITTING;
    }
 

XIOS/dev/XIOS_DEV_CMIP6/src/node/node_enum.hpp

@@ -33 +33 @@
          eExpandDomain,
          eExtractAxisToScalar,
-         eReduceDomainToScalar
-
+         eReduceDomainToScalar,
+         eTemporalSplitting
       } ENodeType;
 

XIOS/dev/XIOS_DEV_CMIP6/src/node/node_type.hpp

@@ -24 +24 @@
 #include "extract_axis_to_scalar.hpp"
 #include "reduce_domain_to_scalar.hpp"
+#include "temporal_splitting.hpp"
 
 

XIOS/dev/XIOS_DEV_CMIP6/src/node/transformation_enum.hpp

@@ -20 +20 @@
         TRANS_EXTRACT_AXIS_TO_SCALAR = 11,
         TRANS_REDUCE_DOMAIN_TO_SCALAR = 12,
+        TRANS_TEMPORAL_SPLITTING = 13,
       } ETranformationType;
 

XIOS/dev/XIOS_DEV_CMIP6/src/object_factory_decl.cpp

@@ -40 +40 @@
   macro(CExtractAxisToScalar)
   macro(CReduceDomainToScalar)
+  macro(CTemporalSplitting)
 
   macro(CFieldGroup)
@@ -62 +63 @@
   macro(CExtractAxisToScalarGroup)
   macro(CReduceDomainToScalarGroup)
+  macro(CTemporalSplittingGroup)
 }

XIOS/dev/XIOS_DEV_CMIP6/src/object_template_decl.cpp

@@ -27 +27 @@
   template class CObjectTemplate<CExtractAxisToScalar>;
   template class CObjectTemplate<CReduceDomainToScalar>;
+  template class CObjectTemplate<CTemporalSplitting>;
 
   template class CObjectTemplate<CContextGroup>;
@@ -49 +50 @@
   template class CObjectTemplate<CExtractAxisToScalarGroup>;
   template class CObjectTemplate<CReduceDomainToScalarGroup>;
+  template class CObjectTemplate<CTemporalSplittingGroup>;
 }

XIOS/dev/XIOS_DEV_CMIP6/src/transformation/algo_types.hpp

@@ -20 +20 @@
 #include "axis_algorithm_transformation.hpp"
 #include "axis_algorithm_extract_domain.hpp"
+#include "axis_algorithm_temporal_splitting.hpp"
 
 #include "domain_algorithm_zoom.hpp"

XIOS/dev/XIOS_DEV_CMIP6/src/transformation/axis_algorithm_transformation.cpp

@@ -19 +19 @@
 
 CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource)
- : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource), domainSrc_(0)
+ : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(axisSource), domainSrc_(0),scalarSrc_(0)
 {
   axisDestGlobalSize_ = axisDestination->n_glo.getValue();
@@ -30 +30 @@
 
 CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CDomain* domainSource)
- : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(domainSource)
+ : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(domainSource),scalarSrc_(0)
 {
   axisDestGlobalSize_ = axisDestination->n_glo.getValue();
@@ -40 +40 @@
 }
 
+CAxisAlgorithmTransformation::CAxisAlgorithmTransformation(CAxis* axisDestination, CScalar* scalarSource)
+ : CGenericAlgorithmTransformation(), axisDest_(axisDestination), axisSrc_(0), domainSrc_(0), scalarSrc_(scalarSource)
+{
+  axisDestGlobalSize_ = axisDestination->n_glo.getValue();
+  int niDest = axisDestination->n.getValue();
+  int ibeginDest = axisDestination->begin.getValue();
+
+  for (int idx = 0; idx < niDest; ++idx)
+    if ((axisDestination->mask)(idx)) axisDestGlobalIndex_.push_back(ibeginDest+idx);
+}
 CAxisAlgorithmTransformation::~CAxisAlgorithmTransformation()
 {
@@ -66 +76 @@
   if (2 == elementType) nIndexSize = domainSrc_->i_index.numElements();
   else if (1 == elementType) nIndexSize = axisSrc_->index.numElements();
+  else nIndexSize=1  ; //  scalar
+  
   CClientClientDHTInt::Index2VectorInfoTypeMap globalIndex2ProcRank;
   globalIndex2ProcRank.rehash(std::ceil(nIndexSize/globalIndex2ProcRank.max_load_factor()));
   for (int idx = 0; idx < nIndexSize; ++idx)
   {
-    if (2 == elementType)
+    if (2 == elementType) // domain
     {
       globalIndex = domainSrc_->i_index(idx) + domainSrc_->j_index(idx) * domainSrc_->ni_glo;
     }
-    else if (1 == elementType)
+    else if (1 == elementType) // axis
     {
       globalIndex = axisSrc_->index(idx);
+    }
+    else // scalar
+    {
+      globalIndex = 0;
     }
 

XIOS/dev/XIOS_DEV_CMIP6/src/transformation/axis_algorithm_transformation.hpp

@@ -17 +17 @@
 class CAxis;
 class CDomain;
-
+class CScalar;
 /*!
   \class CAxisAlgorithmTransformation
@@ -27 +27 @@
   CAxisAlgorithmTransformation(CAxis* axisDestination, CAxis* axisSource);
   CAxisAlgorithmTransformation(CAxis* axisDestination, CDomain* domainSource);
+  CAxisAlgorithmTransformation(CAxis* axisDestination, CScalar* scalarSource);
 
   virtual ~CAxisAlgorithmTransformation();
@@ -52 +53 @@
   //! Domain on grid source
   CDomain* domainSrc_;
+
+  //! Scalar on grid source
+
+  CScalar* scalarSrc_;
 };
 

XIOS/dev/XIOS_DEV_CMIP6/src/transformation/grid_transformation_selector.cpp

@@ -29 +29 @@
   CAxisAlgorithmInverse::registerTrans();
   CAxisAlgorithmReduceDomain::registerTrans();
+  CAxisAlgorithmTemporalSplitting::registerTrans();
 
   //! Domain

XIOS/dev/XIOS_DEV_CMIP6/src/transformation/grid_transformation_selector.hpp

@@ -51 +51 @@
   const std::vector<StdString>& getAuxInputs() const { return auxInputs_; }
   const std::vector<CGenericAlgorithmTransformation*>& getAlgos() const { return algoTransformation_; }
+  const std::map<int, int> getElementPositionInGridSrc2AxisPosition() const { return elementPositionInGridSrc2AxisPosition_ ;}
+  const std::map<int, int> getElementPositionInGridSrc2DomainPosition() const { return elementPositionInGridSrc2DomainPosition_ ;}
+  const std::map<int, int> getElementPositionInGridSrc2ScalarPosition() const { return elementPositionInGridSrc2ScalarPosition_ ;}
+  const std::map<int, int> getElementPositionInGridDst2AxisPosition() const { return elementPositionInGridDst2AxisPosition_ ;}
+  const std::map<int, int> getElementPositionInGridDst2DomainPosition() const { return elementPositionInGridDst2DomainPosition_ ;}
+  const std::map<int, int> getElementPositionInGridDst2ScalarPosition() const { return elementPositionInGridDst2ScalarPosition_ ;}
+
 
 protected:

XIOS/dev/XIOS_DEV_CMIP6/src/type/type_util.hpp

@@ -48 +48 @@
     class CReduceDomainToScalar;
     class CReduceDomainToScalarGroup;
-
+    class CTemporalSplitting;
+    class CTemporalSplittingGroup;
+    
   template <typename T> inline string getStrType(void);
 
@@ -112 +114 @@
   macro(CReduceDomainToScalar)
   macro(CReduceDomainToScalarGroup)
+  macro(CTemporalSplitting)
+  macro(CTemporalSplittingGroup)
   
 #undef macro

XIOS/dev/XIOS_DEV_CMIP6/src/xml_parser_decl.cpp

@@ -33 +33 @@
     macro( ExtractAxisToScalar )
     macro( ReduceDomainToScalar )
+    macro( TemporalSplitting )
   }
 }