Changeset 643

Timestamp:

07/17/15 13:58:13 (9 years ago)

Author:

rlacroix

Message:

Use the filter infrastructure to handle the temporal operations.

Add a temporal filter to do so.

Location:

XIOS/trunk/src

Files:

• calendar_util.cpp (modified) (1 diff)
• calendar_util.hpp (modified) (1 diff)
• filter/binary_arithmetic_filter.cpp (modified) (3 diffs)
• filter/data_packet.hpp (modified) (3 diffs)
• filter/source_filter.cpp (modified) (3 diffs)
• filter/source_filter.hpp (modified) (2 diffs)
• filter/temporal_filter.cpp (added)
• filter/temporal_filter.hpp (added)
• filter/unary_arithmetic_filter.cpp (modified) (1 diff)
• node/field.cpp (modified) (3 diffs)
• node/field.hpp (modified) (2 diffs)
• parse_expr/filter_expr_node.cpp (modified) (1 diff)
• parse_expr/filter_expr_node.hpp (modified) (1 diff)
• parse_expr/yacc_parser.cpp (modified) (1 diff)
• parse_expr/yacc_parser.yacc (modified) (1 diff)

XIOS/trunk/src/calendar_util.cpp

@@ -211 +211 @@
     ///----------------------------------------------------------------
 
+    bool DurationFakeLessComparator::operator()(const CDuration& dur1, const CDuration& dur2) const
+    {
+      if (dur1.year < dur2.year)
+        return true;
+      else if (dur1.year == dur2.year)
+      {
+        if (dur1.month < dur2.month)
+          return true;
+        else if (dur1.month == dur2.month)
+        {
+          if (dur1.day < dur2.day)
+            return true;
+          else if (dur1.day == dur2.day)
+          {
+            if (dur1.hour < dur2.hour)
+              return true;
+            else if (dur1.hour == dur2.hour)
+            {
+              if (dur1.minute < dur2.minute)
+                return true;
+              else if (dur1.minute == dur2.minute)
+              {
+                if (dur1.second < dur2.second)
+                  return true;
+                else if (dur1.second == dur2.second)
+                  return (dur1.timestep < dur2.timestep);
+              }
+            }
+          }
+        }
+      }
+      return false;
+    }
+
+    ///----------------------------------------------------------------
+
 } // namespace xios
 

XIOS/trunk/src/calendar_util.hpp

@@ -36 +36 @@
       ///---------------------------------------------------------------
 
+      //!< Provides a fake "less" comparator for durations that can be used as a comparator for maps
+      struct DurationFakeLessComparator {
+        bool operator()(const CDuration& dur1, const CDuration& dur2) const;
+      };
 } // namespace xios
 

XIOS/trunk/src/filter/binary_arithmetic_filter.cpp

@@ -12 +12 @@
   {
     CDataPacketPtr packet(new CDataPacket);
+    packet->date = data[0]->date;
     packet->timestamp = data[0]->timestamp;
     packet->status = data[0]->status;
@@ -30 +31 @@
   {
     CDataPacketPtr packet(new CDataPacket);
+    packet->date = data[0]->date;
     packet->timestamp = data[0]->timestamp;
     packet->status = data[0]->status;
@@ -47 +49 @@
   {
     CDataPacketPtr packet(new CDataPacket);
+    packet->date = data[0]->date;
     packet->timestamp = data[0]->timestamp;
 

XIOS/trunk/src/filter/data_packet.hpp

@@ -5 +5 @@
 
 #include "array_new.hpp"
-#include "duration.hpp"
+#include "date.hpp"
 
 namespace xios
@@ -23 +23 @@
 
     CArray<double, 1> data; //!< Array containing the data
+    CDate date;             //!< Date associated to the data
     Time timestamp;         //!< Timestamp of the data
     StatusCode status;      //!< Status of the packet
@@ -35 +36 @@
       p->data.resize(data.shape());
       p->data = data;
+      p->date = date;
       p->timestamp = timestamp;
       p->status = status;

XIOS/trunk/src/filter/source_filter.cpp

@@ -14 +14 @@
 
   template <int N>
-  void CSourceFilter::streamData(Time timestamp, const CArray<double, N>& data)
+  void CSourceFilter::streamData(CDate date, const CArray<double, N>& data)
   {
     CDataPacketPtr packet(new CDataPacket);
-    packet->timestamp = timestamp;
+    packet->date = date;
+    packet->timestamp = date;
     packet->status = CDataPacket::NO_ERROR;
 
@@ -26 +27 @@
   }
 
-  template void CSourceFilter::streamData<1>(Time timestamp, const CArray<double, 1>& data);
-  template void CSourceFilter::streamData<2>(Time timestamp, const CArray<double, 2>& data);
-  template void CSourceFilter::streamData<3>(Time timestamp, const CArray<double, 3>& data);
+  template void CSourceFilter::streamData<1>(CDate date, const CArray<double, 1>& data);
+  template void CSourceFilter::streamData<2>(CDate date, const CArray<double, 2>& data);
+  template void CSourceFilter::streamData<3>(CDate date, const CArray<double, 3>& data);
 
-  void CSourceFilter::streamDataFromServer(Time timestamp, const std::map<int, CArray<double, 1> >& data)
+  void CSourceFilter::streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data)
   {
     CDataPacketPtr packet(new CDataPacket);
-    packet->timestamp = timestamp;
+    packet->date = date;
+    packet->timestamp = date;
     packet->status = CDataPacket::NO_ERROR;
 
     if (data.size() != grid->storeIndex_toSrv.size())
-      ERROR("CSourceFilter::streamDataFromServer(Time timestamp, const std::map<int, CArray<double, 1> >& data)",
+      ERROR("CSourceFilter::streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data)",
             << "Incoherent data received from servers,"
             << " expected " << grid->storeIndex_toSrv.size() << " chunks but " << data.size() << " were given.");
@@ -54 +56 @@
   }
 
-  void CSourceFilter::signalEndOfStream(Time timestamp)
+  void CSourceFilter::signalEndOfStream(CDate date)
   {
     CDataPacketPtr packet(new CDataPacket);
-    packet->timestamp = timestamp;
+    packet->date = date;
+    packet->timestamp = date;
     packet->status = CDataPacket::END_OF_STREAM;
     deliverOuput(packet);

XIOS/trunk/src/filter/source_filter.hpp

@@ -28 +28 @@
        * immediately after this method returns.
        *
-       * \param timestamp the timestamp of the data
+       * \param date the date associated to the data
        * \param data an array containing the data
        */
       template <int N>
-      void streamData(Time timestamp, const CArray<double, N>& data);
+      void streamData(CDate date, const CArray<double, N>& data);
 
       /*!
@@ -39 +39 @@
        * immediately after this method returns.
        *
-       * \param timestamp the timestamp of the data
+       * \param date the date associated to the data
        * \param data an array containing the data
        */
-      void streamDataFromServer(Time timestamp, const std::map<int, CArray<double, 1> >& data);
+      void streamDataFromServer(CDate date, const std::map<int, CArray<double, 1> >& data);
 
       /*!
        * Signals the filter graph that the end of stream was reached.
        *
-       * \param timestamp the timestamp at which the end of stream occurred
+       * \param date the date at which the end of stream occurred
        */
-      void signalEndOfStream(Time timestamp);
+      void signalEndOfStream(CDate date);
 
     private:

XIOS/trunk/src/filter/unary_arithmetic_filter.cpp

@@ -11 +11 @@
   {
     CDataPacketPtr packet(new CDataPacket);
+    packet->date = data[0]->date;
     packet->timestamp = data[0]->timestamp;
     packet->status = data[0]->status;

XIOS/trunk/src/node/field.cpp

@@ -21 +21 @@
 #include "filter_expr_node.hpp"
 #include "lex_parser.hpp"
+#include "temporal_filter.hpp"
 
 namespace xios{
@@ -810 +811 @@
        {
          fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
-         instantDataFilter->connectOutput(fileWriterFilter, 0);
+         getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
        }
      }
@@ -834 +835 @@
 
      return clientSourceFilter;
+   }
+
+   /*!
+    * Returns the temporal filter corresponding to the field's temporal operation
+    * for the specified operation frequency. The filter is created if it does not
+    * exist, otherwise it is reused.
+    *
+    * \param gc the garbage collector to use
+    * \param outFreq the operation frequency, i.e. the frequency at which the output data will be computed
+    * \return the output pin corresponding to the requested temporal filter
+    */
+   boost::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   {
+     std::map<CDuration, boost::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+
+     if (it == temporalDataFilters.end())
+     {
+       if (operation.isEmpty())
+         ERROR("void CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)",
+               << "An operation must be defined for field \"" << getId() << "\".");
+
+       if (freq_op.isEmpty())
+         freq_op.setValue(TimeStep);
+       if (freq_offset.isEmpty())
+         freq_offset.setValue(NoneDu);
+
+       const bool ignoreMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+
+       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                             freq_op, freq_offset, outFreq,
+                                                                             ignoreMissingValue, ignoreMissingValue ? default_value : 0.0));
+       instantDataFilter->connectOutput(temporalFilter, 0);
+
+       it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
+     }
+
+     return it->second;
    }
 

XIOS/trunk/src/node/field.hpp

@@ -134 +134 @@
          void buildFilterGraph(CGarbageCollector& gc, bool enableOutput);
          boost::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc);
+         boost::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
 
 //         virtual void fromBinary(StdIStream & is);
@@ -246 +247 @@
          //! The output pin of the filter providing the instant data for the field
          boost::shared_ptr<COutputPin> instantDataFilter;
+         //! The output pin of the filters providing the result of the field's temporal operation
+         std::map<CDuration, boost::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters;
          //! The source filter for data provided by the client
          boost::shared_ptr<CSourceFilter> clientSourceFilter;

XIOS/trunk/src/parse_expr/filter_expr_node.cpp

@@ -32 +32 @@
 
     return outputPin;
+  }
+
+  CFilterTemporalFieldExprNode::CFilterTemporalFieldExprNode(const std::string& fieldId)
+    : fieldId(fieldId)
+  { /* Nothing to do */ }
+
+  boost::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    if (!CField::has(fieldId))
+      ERROR("boost::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+            << "The field " << fieldId << " does not exist.");
+
+    CField* field = CField::get(fieldId);
+    if (field == &thisField)
+      ERROR("boost::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+            << "The field " << fieldId << " has an invalid reference to itself.");
+
+    field->buildFilterGraph(gc, false);
+    return field->getTemporalDataFilter(gc, thisField.freq_op.isEmpty() ? TimeStep : thisField.freq_op);
   }
 

XIOS/trunk/src/parse_expr/filter_expr_node.hpp

@@ -42 +42 @@
        */
       CFilterFieldExprNode(const std::string& fieldId);
+
+      virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+
+    private:
+      std::string fieldId; //!< The identifier of the field
+  };
+
+  /*!
+   * Expression node corresponding to a field for which the result of
+   * the temporal operation is requested instead of the instant value.
+   */
+  class CFilterTemporalFieldExprNode : public IFilterExprNode
+  {
+    public:
+      /*!
+       * Constructs an expression node corresponding
+       * to the field whose id is provided.
+       *
+       * \param fieldId the identifier of the field
+       */
+      CFilterTemporalFieldExprNode(const std::string& fieldId);
 
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;

XIOS/trunk/src/parse_expr/yacc_parser.cpp

@@ -1373 +1373 @@
   case 15:
 #line 78 "yacc_parser.yacc" /* yacc.c:1646  */
-    { /* TODO: Use temporal operation */ (yyval.filterNode) = new CFilterFieldExprNode(*(yyvsp[0].str)); delete (yyvsp[0].str); }
+    { (yyval.filterNode) = new CFilterTemporalFieldExprNode(*(yyvsp[0].str)); delete (yyvsp[0].str); }
 #line 1377 "yacc_parser.cpp" /* yacc.c:1646  */
     break;

XIOS/trunk/src/parse_expr/yacc_parser.yacc

@@ -76 +76 @@
 Field_expr:
             ID      { $$ = new CFilterFieldExprNode(*$1); delete $1; }
-          | AVERAGE { /* TODO: Use temporal operation */ $$ = new CFilterFieldExprNode(*$1); delete $1; }
+          | AVERAGE { $$ = new CFilterTemporalFieldExprNode(*$1); delete $1; }
           | Field_expr PLUS Field_expr   { $$ = new CFilterFieldFieldOpExprNode($1, "add", $3); }
           | Field_expr MINUS Field_expr  { $$ = new CFilterFieldFieldOpExprNode($1, "minus", $3); }