Changeset 1668

Timestamp:

05/22/19 17:26:47 (5 years ago)

Author:

yushan

Message:

MARK: branch merged with trunk @1663. static graph OK with EP

Location:

XIOS/dev/dev_trunk_omp

Files:

• inputs/COMPLETE/context_surface.xml (modified) (1 diff)
• inputs/iodef.xml (modified) (1 diff)
• src/config/field_attribute.conf (modified) (1 diff)
• src/cxios.cpp (modified) (2 diffs)
• src/filter/file_server_writer_filter.cpp (modified) (1 diff)
• src/filter/file_server_writer_filter.hpp (modified) (2 diffs)
• src/filter/file_writer_filter.cpp (modified) (3 diffs)
• src/filter/file_writer_filter.hpp (modified) (3 diffs)
• src/filter/filter.cpp (modified) (1 diff)
• src/filter/filter.hpp (modified) (1 diff)
• src/filter/garbage_collector.cpp (modified) (1 diff)
• src/filter/garbage_collector.hpp (modified) (1 diff)
• src/filter/input_pin.cpp (modified) (3 diffs)
• src/filter/input_pin.hpp (modified) (2 diffs)
• src/filter/output_pin.cpp (modified) (3 diffs)
• src/filter/output_pin.hpp (modified) (3 diffs)
• src/filter/pass_through_filter.cpp (modified) (1 diff)
• src/filter/pass_through_filter.hpp (modified) (1 diff)
• src/filter/source_filter.cpp (modified) (2 diffs)
• src/filter/source_filter.hpp (modified) (2 diffs)
• src/filter/spatial_transform_filter.cpp (modified) (4 diffs)
• src/filter/spatial_transform_filter.hpp (modified) (3 diffs)
• src/filter/store_filter.cpp (modified) (1 diff)
• src/filter/store_filter.hpp (modified) (2 diffs)
• src/filter/temporal_filter.cpp (modified) (1 diff)
• src/filter/temporal_filter.hpp (modified) (1 diff)
• src/graphviz.cpp (added)
• src/graphviz.hpp (added)
• src/node/field.cpp (modified) (12 diffs)
• src/node/field.hpp (modified) (1 diff)
• src/workflow_graph.cpp (added)
• src/workflow_graph.hpp (added)

XIOS/dev/dev_trunk_omp/inputs/COMPLETE/context_surface.xml

@@ -20 +20 @@
         <variable id="my_attribute5" type="double">100.201</variable>
       </field>
-      <field field_ref="field_A_srf_K" />
+      <field field_ref="field_A_srf_K" build_workflow_graph=".TRUE." />
       <field field_ref="field_A_srf_K_2" name="field_A_srf_K_2" /> <!-- Should be identical to field_A_srf_K -->
       <field field_ref="field_A_srf_K" name="field_A_srf_K_3">field_A_srf_K</field> <!-- Should be identical to field_A_srf_K -->

XIOS/dev/dev_trunk_omp/inputs/iodef.xml

@@ -18 +18 @@
       <file id="output" name="output" enabled=".TRUE.">
         <!-- <field field_ref="field_Domain" name="field_A" /> -->
-        <field field_ref="field_A" name="field_A" /> 
+        <field field_ref="field_A" name="field_A" build_workflow_graph=".TRUE." /> 
         <field field_ref="field_A_zoom" name="field_B" />
      </file>

XIOS/dev/dev_trunk_omp/src/config/field_attribute.conf

@@ -19 +19 @@
 DECLARE_ATTRIBUTE(bool,      indexed_output)
 DECLARE_ATTRIBUTE(bool,      check_if_active)
+DECLARE_ATTRIBUTE(bool,      build_workflow_graph)
 
 DECLARE_ATTRIBUTE(StdString, domain_ref, false)

XIOS/dev/dev_trunk_omp/src/cxios.cpp

@@ -15 +15 @@
 using namespace ep_lib;
 #endif
-
+#include "graphviz.hpp"
 namespace xios
 {
@@ -172 +172 @@
        globalRegistry->toFile("xios_registry.bin") ;
        delete globalRegistry ;
+       
+       CGraphviz::buildStaticWorkflowGraph();
      }
 

XIOS/dev/dev_trunk_omp/src/filter/file_server_writer_filter.cpp

@@ -28 +28 @@
     return true;
   }
+
+  int CFileServerWriterFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/file_server_writer_filter.hpp

@@ -37 +37 @@
       bool virtual isDataExpected(const CDate& date) const;
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -48 +53 @@
       CField* field; //<! The associated field
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;            //<! Filter's id needed in case of building a workflow
+
   }; // class CFileServerWriterFilter
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/file_writer_filter.cpp

@@ -3 +3 @@
 #include "field.hpp"
 #include "utils.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
 {
-  CFileWriterFilter::CFileWriterFilter(CGarbageCollector& gc, CField* field)
+  CFileWriterFilter::CFileWriterFilter(CGarbageCollector& gc, CField* field, bool buildWorkflowGraph /* =false */)
     : CInputPin(gc, 1)
     , field(field)
@@ -13 +14 @@
       ERROR("CFileWriterFilter::CFileWriterFilter(CField* field)",
             "The field cannot be null.");
+    if (buildWorkflowGraph)
+    {
+      filterId = InvalidableObject::count;
+      InvalidableObject::count++;
+    }
   }
 
@@ -46 +52 @@
     return true;
   }
+
+  int CFileWriterFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/file_writer_filter.hpp

@@ -20 +20 @@
        * \param gc the associated garbage collector
        * \param field the associated field
+       * \param[in] buildWorkflowGraph indicates whether the workflow will be visualized
        */
-      CFileWriterFilter(CGarbageCollector& gc, CField* field);
+      CFileWriterFilter(CGarbageCollector& gc, CField* field, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("File writer filter");};
 
       /*!
@@ -37 +40 @@
       bool virtual isDataExpected(const CDate& date) const;
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -48 +56 @@
       CField* field; //<! The associated field
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;                           //<! Filter's id needed in case of building a workflow
+
   }; // class CFileWriterFilter
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/filter.cpp

@@ -3 +3 @@
 namespace xios
 {
-  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine)
+  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph /*= false*/)
     : CInputPin(gc, inputSlotsCount)
-    , COutputPin(gc)
+    , COutputPin(gc, false, buildWorkflowGraph)
     , engine(engine)
     , inputSlotCount(inputSlotCount)
   { /* Nothing to do */ }
+
+  StdString CFilter::GetName(void)    { return StdString("Filter"); }
 
   void CFilter::onInputReady(std::vector<CDataPacketPtr> data)

XIOS/dev/dev_trunk_omp/src/filter/filter.hpp

@@ -23 +23 @@
        * \param inputSlotsCount the number of input slots
        * \param engine the filter engine
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine);
+      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph = false);
+
+      StdString virtual GetName(void);
 
       /*!

XIOS/dev/dev_trunk_omp/src/filter/garbage_collector.cpp

@@ -3 +3 @@
 namespace xios
 {
+
+  int InvalidableObject::count = 0;
+  #pragma omp threadprivate(InvalidableObject::count)
+  
   void CGarbageCollector::registerObject(InvalidableObject* Object, Time timestamp)
   {

XIOS/dev/dev_trunk_omp/src/filter/garbage_collector.hpp

@@ -20 +20 @@
      */
     void virtual invalidate(Time timestamp) = 0;
+  
+    static int count; //!< Counter used to identify a filter in case building workflow graph
+    #pragma omp threadprivate(count)
+    
   }; // struct InvalidableObject
 

XIOS/dev/dev_trunk_omp/src/filter/input_pin.cpp

@@ -3 +3 @@
 #include "garbage_collector.hpp"
 #include "exception.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
@@ -11 +12 @@
     , triggers(slotsCount)
     , hasTriggers(false)
-  { /* Nothing to do */ }
+  {   }
+
+  StdString CInputPin::GetName(void)
+  {
+    return StdString("Input pin");
+  }
 
   void CInputPin::setInput(size_t inputSlot, CDataPacketPtr packet)
@@ -77 +83 @@
     inputs.erase(inputs.begin(), inputs.lower_bound(timestamp));
   }
+
+  int CInputPin::getFilterId(void)
+  {
+    return -1;
+  }
+
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/input_pin.hpp

@@ -26 +26 @@
        */
       CInputPin(CGarbageCollector& gc, size_t slotsCount);
+      
+      StdString virtual GetName(void);
 
       /*!
@@ -79 +81 @@
        */
       void virtual invalidate(Time timestamp);
+      
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       * This function should never be called from this class, instead functions defined in derived classes or in class COutputPin should be used
+       */
+      int virtual getFilterId();
 
     protected:

XIOS/dev/dev_trunk_omp/src/filter/output_pin.cpp

@@ -1 +1 @@
 #include "output_pin.hpp"
 #include "exception.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios
 {
-  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/)
+  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/, bool buildWorkflowGraph /* =false */)
     : gc(gc)
     , manualTrigger(manualTrigger)
-  { /* Nothing to do */ }
+    , buildWorkflowGraph(buildWorkflowGraph)
+  {
+    if (buildWorkflowGraph)
+    {
+      filterId = InvalidableObject::count;
+      InvalidableObject::count++;
+    }
+  }
+
+  StdString COutputPin::GetName(void)
+  {
+    return StdString("Output pin");
+  }
 
   void COutputPin::connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot)
@@ -26 +39 @@
       ERROR("void COutputPin::onOutputReady(CDataPacketPtr packet)",
             "The packet cannot be null.");
+
+    if (buildWorkflowGraph)
+    {
+        if(CWorkflowGraph::mapFilterTimestamps_ptr==0) CWorkflowGraph::mapFilterTimestamps_ptr = new std::unordered_map <int, vector<Time> >;
+      if(CWorkflowGraph::timestamps_ptr==0) CWorkflowGraph::timestamps_ptr = new set<Time>;
+      (*CWorkflowGraph::mapFilterTimestamps_ptr)[this->getFilterId()].push_back(packet->timestamp);
+        CWorkflowGraph::timestamps_ptr->insert(packet->timestamp);
+    }
 
     if (manualTrigger) // Don't use canBeTriggered here, this function is virtual and can be overriden
@@ -101 +122 @@
     outputPackets.erase(outputPackets.begin(), outputPackets.lower_bound(timestamp));
   }
+
+  int COutputPin::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/output_pin.hpp

@@ -19 +19 @@
        * \param gc the garbage collector associated with this ouput pin
        * \param slotsCount the number of slots
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      COutputPin(CGarbageCollector& gc, bool manualTrigger = false);
+      COutputPin(CGarbageCollector& gc, bool manualTrigger = false, bool buildWorkflowGraph = false);
 
+      StdString virtual GetName(void);
+      
       /*!
        * Connects to a specific slot of the input pin of a downstream filter.
@@ -66 +69 @@
       void virtual invalidate(Time timestamp);
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -97 +105 @@
       //! Output buffer, store the packets until the output is triggered
       std::map<Time, CDataPacketPtr> outputPackets;
+
+      //! Indicates whether the workflow will be visualized
+      bool buildWorkflowGraph;
+
+      //! Filter's id needed in case of building a workflow graph
+      int filterId;
+
+
   }; // class COutputPin
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/pass_through_filter.cpp

@@ -3 +3 @@
 namespace xios
 {
-  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc)
-    : CFilter(gc, 1, this)
+  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, 1, this, buildWorkflowGraph)
   { /* Nothing to do */ }
 

XIOS/dev/dev_trunk_omp/src/filter/pass_through_filter.hpp

@@ -17 +17 @@
        *
        * \param gc the associated garbage collector
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CPassThroughFilter(CGarbageCollector& gc);
+      CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Pass through filter");};
 
     protected:

XIOS/dev/dev_trunk_omp/src/filter/source_filter.cpp

@@ -4 +4 @@
 #include "calendar_util.hpp"
 #include <limits> 
+#include "workflow_graph.hpp"
 
 namespace xios
@@ -11 +12 @@
                                const CDuration offset /*= NoneDu*/, bool manualTrigger /*= false*/,
                                bool hasMissingValue /*= false*/,
-                               double defaultValue /*= 0.0*/)
-    : COutputPin(gc, manualTrigger)
+                               double defaultValue /*= 0.0*/,
+                               bool buildWorkflowGraph /*= false*/)
+    : COutputPin(gc, manualTrigger, buildWorkflowGraph)
     , grid(grid)
     , compression(compression)

XIOS/dev/dev_trunk_omp/src/filter/source_filter.hpp

@@ -27 +27 @@
        * \param hasMissingValue whether data has missing value
        * \param defaultValue missing value to detect
+       * \param[in] buildWorkflowGraph indicates whether the workflow will be visualized
        */
       CSourceFilter(CGarbageCollector& gc, CGrid* grid,
@@ -33 +34 @@
                     const CDuration offset = NoneDu, bool manualTrigger = false,
                     bool hasMissingValue = false,
-                    double defaultValue = 0.0);
+                    double defaultValue = 0.0,
+                                        bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Source filter");};
 
       /*!

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

@@ -8 +8 @@
 using namespace ep_lib;
 #endif
-
+#include "workflow_graph.hpp"
 namespace xios
 {
-  CSpatialTransformFilter::CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, double outputValue, size_t inputSlotsCount)
-    : CFilter(gc, inputSlotsCount, engine), outputDefaultValue(outputValue)
+  CSpatialTransformFilter::CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                                                   double outputValue, size_t inputSlotsCount, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, inputSlotsCount, engine, buildWorkflowGraph), outputDefaultValue(outputValue)
   { /* Nothing to do */ }
 
   std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
-  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue)
+  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue,
+                                            bool buildWorkflowGraph)
   {
     if (!srcGrid || !destGrid)
@@ -41 +43 @@
 
       std::shared_ptr<CSpatialTransformFilter> filter ;
-      if( isSpatialTemporal) filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount));
-      else filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
+      if( isSpatialTemporal)
+        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount, buildWorkflowGraph));
+      else
+        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount, buildWorkflowGraph));
 
       
@@ -48 +52 @@
         lastFilter = filter;
       else
+      {
         filter->connectOutput(firstFilter, 0);
+        if (buildWorkflowGraph)
+        {
+          if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+          if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+          int filterOut = (std::static_pointer_cast<COutputPin>(filter))->getFilterId();
+          int filterIn = (std::static_pointer_cast<COutputPin>(firstFilter))->getFilterId();
+          // PASS field's id here
+          (*CWorkflowGraph::mapFieldToFilters_ptr)["XXX"].push_back(filterOut);
+          (*CWorkflowGraph::mapFieldToFilters_ptr)["XXX"].push_back(filterIn);
+          (*CWorkflowGraph::mapFilters_ptr)[filterOut] = "Spatial transform filter";
+          (*CWorkflowGraph::mapFilters_ptr)[filterIn] = "Spatial transform filter";
+        }
+      }
 
       firstFilter = filter;
@@ -73 +91 @@
   }
 
-  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount)
-    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount), record(0)
+  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                                                  CGridTransformation* gridTransformation, double outputValue,
+                                                  size_t inputSlotsCount, bool buildWorkflowGraph)
+    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount, buildWorkflowGraph), record(0)
   {
       const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ;

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

@@ -23 +23 @@
        * \param outputValue default value of output pin
        * \param [in] inputSlotsCount number of input, by default there is only one for field src
+       * \param buildWorkflowGraph indicates whether data will be visualized
        */
-      CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, double outputValue, size_t inputSlotsCount = 1);
+      CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine,
+                              double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Spatial transform filter");};
 
       /*!
@@ -34 +38 @@
        * \param hasMissingValue whether field source has missing value
        * \param defaultValue default value
+       * \param buildWorkflowGraph indicates whether data will be visualized
        * \return the first and the last filters of the filter graph
        */
       static std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
-      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue);
+      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue, bool buildWorkflowGraph = false);
 
     protected:
@@ -67 +72 @@
        * \param outputValue default value of output pin
        * \param [in] inputSlotsCount number of input, by default there is only one for field src
+       * \param buildWorkflowGraph indicates whether data will be visualized
+       *
        */
-      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, double outputValue, size_t inputSlotsCount = 1);
+      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation,
+                            double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false);
 
 

XIOS/dev/dev_trunk_omp/src/filter/store_filter.cpp

@@ -138 +138 @@
     packets.erase(packets.begin(), packets.lower_bound(timestamp));
   }
+
+  int CStoreFilter::getFilterId(void)
+  {
+    return filterId;
+  }
+
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/store_filter.hpp

@@ -73 +73 @@
       void virtual invalidate(Time timestamp);
 
+      /*!
+       * Returns filter's id needed in case of building workflow graph
+       */
+      int getFilterId();
+
     protected:
       /*!
@@ -88 +93 @@
       const double missingValue; //!< The value to use to replace missing values
       std::map<Time, CDataPacketPtr> packets; //<! The stored packets
+      int filterId;                     //!< Filter's id needed in case of building a workflow
+
   }; // class CStoreFilter
 } // namespace xios

XIOS/dev/dev_trunk_omp/src/filter/temporal_filter.cpp

@@ -9 +9 @@
   CTemporalFilter::CTemporalFilter(CGarbageCollector& gc, const std::string& opId,
                                    const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq,
-                                   bool ignoreMissingValue /*= false*/)
-    : CFilter(gc, 1, this)
+                                   bool ignoreMissingValue /*= false*/, bool buildWorkflowGraph /*= false*/)
+    : CFilter(gc, 1, this, buildWorkflowGraph)
     , functor(createFunctor(opId, ignoreMissingValue, tmpData))
     , isOnceOperation(functor->timeType() == func::CFunctor::once)

XIOS/dev/dev_trunk_omp/src/filter/temporal_filter.hpp

@@ -29 +29 @@
       CTemporalFilter(CGarbageCollector& gc, const std::string& opId,
                       const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq,
-                      bool ignoreMissingValue = false);
+                      bool ignoreMissingValue = false, bool buildWorkflowGraph = false);
+
+      inline StdString GetName(void) {return StdString("Temporal filter");};
 
       /*!

XIOS/dev/dev_trunk_omp/src/node/field.cpp

@@ -24 +24 @@
 #include "spatial_transform_filter.hpp"
 #include "file_server_writer_filter.hpp"
+#include "workflow_graph.hpp"
 
 namespace xios{
@@ -1120 +1121 @@
 
      const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
      const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0);
 
@@ -1171 +1173 @@
            if (!field_ref.isEmpty())
            {
-             CGrid* gridRef = CField::get(field_ref)->grid;
+             CField* fieldRef = CField::get(field_ref);
+             fieldRef->build_workflow_graph.setValue(buildWorkflowGraph);
+             CGrid* gridRef = fieldRef->grid;
 
              if (grid && grid != gridRef && grid->hasTransform())
              {
-                 std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue); 
+               std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid,
+                                                                                         detectMissingValues, defaultValue, buildWorkflowGraph);
 
                filter->connectOutput(filters.first, 0);
+
+               if (buildWorkflowGraph)
+               {
+                 if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+                 if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+                 int filterOut = filter->getFilterId();
+                 int filterIn = (std::static_pointer_cast<COutputPin>(filters.second))->getFilterId();
+                 (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterOut);
+                 (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterIn);
+                 (*CWorkflowGraph::mapFilters_ptr)[filterOut] = filter->GetName();
+                 (*CWorkflowGraph::mapFilters_ptr)[filterIn] = filters.second->GetName();
+               }
                filter = filters.second;
              }
@@ -1186 +1203 @@
          // Check if we have a reference on another field
          else if (!field_ref.isEmpty())
+         {
+           CField::get(field_ref)->build_workflow_graph.setValue(buildWorkflowGraph);
            instantDataFilter = getFieldReference(gc);
+         }
          // Check if the data is to be read from a file
          else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read)
@@ -1192 +1212 @@
            checkTimeAttributes();
            instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false, freq_offset, true,
-                                                                                                       detectMissingValues, defaultValue));
+                                                                                                       detectMissingValues, defaultValue, buildWorkflowGraph));
          }
          else // The data might be passed from the model
@@ -1198 +1218 @@
             if (check_if_active.isEmpty()) check_if_active = false; 
             instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, true, NoneDu, false,
-                                                                                                        detectMissingValues, defaultValue));
+                                                                                                      detectMissingValues, defaultValue, buildWorkflowGraph));
+            if (buildWorkflowGraph) 
+            {
+              if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+              (*CWorkflowGraph::mapFilters_ptr)[instantDataFilter->getFilterId()] = instantDataFilter->GetName();
+            }  
          }
        }
@@ -1214 +1239 @@
          if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
          {
-           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this, buildWorkflowGraph));
            getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
+           if (buildWorkflowGraph)
+           {
+             if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+             if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+             int filterOut = getTemporalDataFilter(gc, file->output_freq)->getFilterId();
+             int filterIn = fileWriterFilter->getFilterId();
+             (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterOut);
+             (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterIn);
+             (*CWorkflowGraph::mapFilters_ptr)[filterOut] = "Temporal filter";
+             (*CWorkflowGraph::mapFilters_ptr)[filterIn] = fileWriterFilter->GetName();
+           }
          }
        }
@@ -1238 +1274 @@
      CField* fieldRef = CField::get(field_ref);
      fieldRef->buildFilterGraph(gc, false);
+     bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
 
      std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters;
@@ -1245 +1282 @@
        bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true);
        double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);                                
-       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue);
+       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue, buildWorkflowGraph);
      }
      else
-       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc));
+     {
+       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc, buildWorkflowGraph));
+     }
 
      fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
 
+     if (buildWorkflowGraph)
+     {
+       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+       int filterOut = fieldRef->instantDataFilter->getFilterId();
+       int filterIn = (std::static_pointer_cast<COutputPin>(filters.first))->getFilterId();
+       (*CWorkflowGraph::mapFieldToFilters_ptr)[fieldRef->getId()].push_back(filterOut);
+       (*CWorkflowGraph::mapFieldToFilters_ptr)[fieldRef->getId()].push_back(filterIn);
+       (*CWorkflowGraph::mapFilters_ptr)[filterOut] = fieldRef->getInstantDataFilter()->GetName();
+       (*CWorkflowGraph::mapFilters_ptr)[filterIn] = filters.first->GetName();
+     }
      return filters.second;
    }
@@ -1324 +1374 @@
    {
      std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
 
      if (it == temporalDataFilters.end())
@@ -1334 +1385 @@
 
        const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true);
-       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
-                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
-                                                                             freq_op, freq_offset, outFreq, detectMissingValues));
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                             freq_op, freq_offset, outFreq,
+                                                                             detectMissingValues, buildWorkflowGraph));
 
        instantDataFilter->connectOutput(temporalFilter, 0);
+
+       if (buildWorkflowGraph)
+       {
+         if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+         if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+         int filterOut = instantDataFilter->getFilterId();
+         int filterIn = (std::static_pointer_cast<COutputPin>(temporalFilter))->getFilterId();
+         (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterOut);
+         (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterIn);
+         (*CWorkflowGraph::mapFilters_ptr)[filterOut] = getInstantDataFilter()->GetName();
+         (*CWorkflowGraph::mapFilters_ptr)[filterIn] = temporalFilter->GetName();
+       }
 
        it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first;
@@ -1374 +1437 @@
 
        const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true);
+       const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true);
        std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
-                                                                             CContext::getCurrent()->getCalendar()->getInitDate(),
-                                                                             freq_op, freq_offset, outFreq, detectMissingValues));
+                                                                           CContext::getCurrent()->getCalendar()->getInitDate(),
+                                                                           freq_op, freq_offset, outFreq,
+                                                                           detectMissingValues, buildWorkflowGraph));
 
        selfReferenceFilter->connectOutput(temporalFilter, 0);
+       if (buildWorkflowGraph)
+
+       {
+         if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>;
+         if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >;
+         int filterOut = selfReferenceFilter->getFilterId();
+         int filterIn = (std::static_pointer_cast<COutputPin>(temporalFilter))->getFilterId();
+         (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterOut);
+         (*CWorkflowGraph::mapFieldToFilters_ptr)[this->getId()].push_back(filterIn);
+         (*CWorkflowGraph::mapFilters_ptr)[filterOut] = selfReferenceFilter->GetName();
+         (*CWorkflowGraph::mapFilters_ptr)[filterIn] = temporalFilter->GetName();
+       }
+
        return temporalFilter ;
      }

XIOS/dev/dev_trunk_omp/src/node/field.hpp

@@ -7 +7 @@
 #include "functor.hpp"
 #include "functor_type.hpp"
+#include "filter.hpp"
 #include "duration.hpp"
 #include "date.hpp"