Changeset 1679


Ignore:
Timestamp:
07/02/19 11:42:27 (5 years ago)
Author:
yushan
Message:

MARK: Dynamic workflow graph developement. Branch up to date with trunk @1676. Using vis.js

Location:
XIOS/dev/dev_trunk_omp
Files:
44 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_trunk_omp/GENERIC_TESTCASE/context_atm.xml

    r1678 r1679  
    289289   
    290290  <field_definition level="1" prec="8" operation="instant" freq_op="1ts" enabled=".true." default_value="1.e+20" detect_missing_value="true"> 
    291     <field id="field2D" grid_ref="grid2D"/> 
    292     <field id="field3D" grid_ref="grid3D" /> 
     291    <field id="field2D" grid_ref="grid2D" /> 
     292    <field id="field3D" grid_ref="grid3D" build_workflow_graph=".TRUE." /> 
    293293    <field id="pressure" grid_ref="grid3D"  /> 
    294     <field id="field3D_recv" read_access="true" grid_ref="grid3D"  field_ref="field3D"/> 
     294    <field id="field3D_recv" read_access="true" grid_ref="grid3D"  field_ref="field3D" /> 
    295295    <field id="field3D_resend" grid_ref="grid3D" /> 
    296296 
    … …  
    407407       <field field_ref="field_YZW" enabled="true"/> 
    408408    </file> 
     409     
    409410 
    410411    <file id="atm_output_reorder" output_freq="1ts" enabled="false" > 

  • XIOS/dev/dev_trunk_omp/GENERIC_TESTCASE/iodef.xml

    r1678 r1679  
    5454        <variable id="info_level" type="int">100</variable> 
    5555        <variable id="print_file" type="bool">true</variable> 
    56         <variable id="using_server2" type="bool">false</variable> 
     56        <variable id="using_server2" type="bool">true</variable> 
    5757        <variable id="ratio_server2" type="int">50</variable> 
    5858        <variable id="pure_one_sided" type="bool">false</variable> 

  • XIOS/dev/dev_trunk_omp/bld.cfg

    r1665 r1679  
    5656bld::target test_client.exe 
    5757bld::target test_omp.exe 
     58bld::target generic_testcase.exe 
    5859#bld::target test_omp2.exe 
    5960#bld::target test_send.exe 

  • XIOS/dev/dev_trunk_omp/inputs/iodef.xml

    r1677 r1679  
    77 
    88   <field_definition level="1" enabled=".TRUE."> 
    9      <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A"/> 
     9     <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A" build_workflow_graph=".FALSE."/> 
    1010     <field id="field_B"  operation="average" freq_op="3600s" grid_ref="grid_A"/> 
    1111     <field id="field_C"  operation="average" freq_op="3600s" grid_ref="grid_A"/> 
    … …  
    1717 
    1818 
    19    <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" > 
     19   <file_definition type="one_file" par_access="collective" output_freq="4h" output_level="10" > 
    2020      <file id="output" name="output" enabled=".TRUE."> 
    2121        <!-- <field field_ref="field_Domain" name="field_A" /> --> 
    22         <field field_ref="field_A" name="field_A_name" enabled=".TRUE." build_workflow_graph=".TRUE." />  
    23         <field field_ref="field_B" name="field_B_name" enabled=".TRUE." build_workflow_graph=".FALSE."/>  
     22        <field field_ref="field_A" name="field_A_name"  build_workflow_graph=".FALSE." />  
     23        <field field_ref="field_B" name="field_B_name" build_workflow_graph=".FALSE."/>  
    2424        <!-- <field field_ref="field_C" name="field_C_name" enabled=".TRUE." />  --> 
    25         <field id="field_D" field_ref="field_A" operation="instant" build_workflow_graph=".FALSE." name="field_D_name" enabled=".TRUE."> field_A + field_B</field> 
    26         <field id="field_E" field_ref="field_A" operation="instant" build_workflow_graph=".FALSE." name="field_E_name" enabled=".TRUE."> field_D </field> 
     25        <field id="field_D" field_ref="field_A" operation="instant" build_workflow_graph=".TRUE." name="field_D_name" build_workflow_graph_start="1h"  > field_A + field_B</field> 
     26        <!-- <field id="field_E" field_ref="field_A" operation="instant" build_workflow_graph=".TRUE." name="field_E_name" build_workflow_graph_start="1h" > field_D*2 </field> --> 
    2727        <!-- <field field_ref="field_A_zoom" name="field_B" build_workflow_graph=".TRUE."/> --> 
    2828     </file> 
    29      <file id="output1" name="output1" enabled=".TRUE."> 
     29     <file id="output1" name="output1" output_freq="8h" enabled=".FALSE."> 
    3030        <!-- <field field_ref="field_Domain" name="field_A" /> --> 
    31         <field id="field_F" field_ref="field_A" name="field_A_zoom" grid_ref="grid_A_zoom" build_workflow_graph=".TRUE."/>         
     31        <field id="field_F" field_ref="field_A" name="field_A_zoom" grid_ref="grid_A_zoom" build_workflow_graph=".TRUE."   />         
     32         
    3233     </file>   
    33      <file id="output2" name="output2" enabled=".FALSE."> 
    34         <!-- <field field_ref="field_Domain" name="field_A" /> --> 
    35         <field field_ref="field_Scalar" name="field_A_scalar" build_workflow_graph=".TRUE."/>         
     34     <file id="output2" name="output2" output_freq="4h" enabled=".TRUE."> 
     35        <field id="field_G" field_ref="field_A" name="field_G_zoom" grid_ref="grid_A_zoom" build_workflow_graph=".TRUE." build_workflow_graph_start="1h" build_workflow_graph_end="4h" />         
     36        <!-- <field field_ref="field_Scalar" name="field_A_scalar" build_workflow_graph=".TRUE."/>         --> 
    3637     </file> 
    3738 <!--     <file id="output_s" name="output_s" mode="read" > 

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

    r1668 r1679  
    1919DECLARE_ATTRIBUTE(bool,      indexed_output) 
    2020DECLARE_ATTRIBUTE(bool,      check_if_active) 
    21 DECLARE_ATTRIBUTE(bool,      build_workflow_graph) 
     21 
    2222 
    2323DECLARE_ATTRIBUTE(StdString, domain_ref, false) 
    … …  
    4141DECLARE_ATTRIBUTE(StdString, cell_methods) 
    4242DECLARE_ENUM4(cell_methods_mode,  overwrite, prefix, suffix, none) 
     43 
     44 
     45DECLARE_ATTRIBUTE(bool,      build_workflow_graph) 
     46DECLARE_ATTRIBUTE(CDuration,      build_workflow_graph_start) 
     47DECLARE_ATTRIBUTE(CDuration,      build_workflow_graph_end) 

  • XIOS/dev/dev_trunk_omp/src/cxios.cpp

    r1677 r1679  
    174174        
    175175       // CGraphviz::showStaticWorkflowGraph(); 
    176        CGraphviz::buildStaticWorkflowGraph(); 
     176       CGraphviz::buildWorkflowGraphDot(); 
     177       CGraphviz::buildWorkflowGraphVisjs_with_info(); 
    177178 
    178179      StdString commande_string="dot -Tpdf graph.dot -o graph.pdf";   

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

    r1677 r1679  
    11#include "binary_arithmetic_filter.hpp" 
    22#include "workflow_graph.hpp" 
     3 
    34 
    45namespace xios 
    … …  
    3637  CDataPacketPtr CScalarFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    3738  { 
    38     if(this->tag) 
    39     { 
    40       this->filterID = InvalidableObject::filterIdGenerator++;     
    41  
    42       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    43       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    44  
    45       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "S "+op_expression +" F Filter" ; 
     39    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     40 
     41    if(building_graph) 
     42    { 
     43      this->filterID = InvalidableObject::filterIdGenerator++;    
     44      int edgeID = InvalidableObject::edgeIdGenerator++;  
     45 
     46      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     47      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     48 
    4649      std::cout<<"CScalarFieldArithmeticFilter::apply filter tag = "<<this->tag<<std::endl; 
    4750 
    48       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    49       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    50       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
     51      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "S "+op_expression +" F Filter" ; 
     52      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2 ; 
     53      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1 ; 
     54      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1 ; 
     55      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date ; 
     56      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp ; 
     57 
     58      if(CWorkflowGraph::build_begin) 
     59      { 
     60        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     61 
     62        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     63      } 
     64      else CWorkflowGraph::build_begin = true; 
    5165    } 
    5266 
    … …  
    5569    packet->timestamp = data[0]->timestamp; 
    5670    packet->status = data[0]->status; 
    57     if(this->tag) packet->src_filterID = this->filterID; 
    58     packet->fieldID = this->output_field_id; 
     71    if(building_graph) packet->src_filterID = this->filterID; 
     72    packet->field = this->field; 
    5973 
    6074    if (packet->status == CDataPacket::NO_ERROR) 
    … …  
    98112  CDataPacketPtr CFieldScalarArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    99113  { 
    100     if(this->tag) 
     114    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     115 
     116    if(building_graph) 
    101117    { 
    102118      this->filterID = InvalidableObject::filterIdGenerator++; 
     119      int edgeID = InvalidableObject::edgeIdGenerator++; 
    103120  
    104       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    105       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    106  
    107       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "F "+op_expression +" S Filter" ; 
     121      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     122      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     123 
    108124      std::cout<<"CFieldScalarArithmeticFilter::apply filter tag = "<<this->tag<<std::endl; 
    109125 
    110       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    111       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    112       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
     126      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "F "+op_expression +" S Filter" ; 
     127      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2 ; 
     128      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1 ; 
     129      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1 ; 
     130      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date ; 
     131      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp ; 
     132 
     133      if(CWorkflowGraph::build_begin) 
     134      { 
     135        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     136 
     137        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     138      } 
     139      else CWorkflowGraph::build_begin = true; 
    113140    } 
    114141 
    … …  
    117144    packet->timestamp = data[0]->timestamp; 
    118145    packet->status = data[0]->status; 
    119     if(this->tag) packet->src_filterID = this->filterID; 
    120     packet->fieldID = this->output_field_id; 
     146    if(building_graph) packet->src_filterID = this->filterID; 
     147    packet->field = this->field; 
    121148     
    122149 
    … …  
    160187  CDataPacketPtr CFieldFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    161188  { 
    162     if(this->tag) 
     189    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     190 
     191    if(building_graph) 
    163192    { 
    164193 
    165194      this->filterID = InvalidableObject::filterIdGenerator++; 
     195      int edgeID = InvalidableObject::edgeIdGenerator++; 
    166196    
    167       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    168       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    169  
    170       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "F "+op_expression +" F Filter" ; 
     197      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     198      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     199 
    171200      std::cout<<"CFieldFieldArithmeticFilter::apply filter tag = "<<this->tag<<std::endl; 
    172201 
    173       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    174       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    175       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    176  
    177       str = data[1]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    178  
    179       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[1]->src_filterID); 
    180       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
     202      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "F "+op_expression +" F Filter" ; 
     203      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2 ; 
     204      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1 ; 
     205      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 2 ; 
     206      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date ; 
     207      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp ; 
     208 
     209      if(CWorkflowGraph::build_begin) 
     210      { 
     211 
     212        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     213 
     214        edgeID = InvalidableObject::edgeIdGenerator++; 
     215 
     216        CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
     217 
     218        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     219        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
     220      } 
     221      CWorkflowGraph::build_begin = true; 
    181222    } 
    182223 
    … …  
    185226    packet->date = data[0]->date; 
    186227    packet->timestamp = data[0]->timestamp; 
    187     if(this->tag) packet->src_filterID = this->filterID; 
    188     packet->fieldID = this->output_field_id; 
     228    if(building_graph) packet->src_filterID = this->filterID; 
     229    packet->field = this->field; 
    189230     
    190231 

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

    r1677 r1679  
    99namespace xios 
    1010{ 
     11  class CField; 
    1112  /*! 
    1213   * A packet corresponds to a timestamped array of data. 
    … …  
    2829    int src_filterID; 
    2930    std::vector<int> filterIDoutputs; 
    30     StdString fieldID; 
     31    CField *field; 
    3132     
    3233    /*! 

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

    r1677 r1679  
    4949      CField* field; //<! The associated field 
    5050      std::map<Time, CDataPacketPtr> packets; //<! The stored packets 
    51       int filterId;            //<! Filter's id needed in case of building a workflow 
    5251 
    5352  }; // class CFileServerWriterFilter 

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

    r1677 r1679  
    1010namespace xios 
    1111{ 
    12   CFileWriterFilter::CFileWriterFilter(CGarbageCollector& gc, CField* field, bool buildWorkflowGraph /* =false */) 
     12  CFileWriterFilter::CFileWriterFilter(CGarbageCollector& gc, CField* field) 
    1313    : CInputPin(gc, 1) 
    1414    , field(field) 
    … …  
    2121  void CFileWriterFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    2222  { 
    23     if(this->tag) 
     23    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph: false; 
     24    if(building_graph) 
    2425    { 
    2526      this->filterID = InvalidableObject::filterIdGenerator++; 
     27      int edgeID = InvalidableObject::edgeIdGenerator++; 
    2628 
    27       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    28       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
     29      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     30      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
    2931 
    30       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "File Writer Filter"; 
     32      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "File Writer Filter"; 
     33      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 4; 
     34      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 0; 
     35      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     36      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     37      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
    3138 
    32       if(CXios::isClient) std::cout<<"CFileWriterFilter::apply filter tag = "<<this->tag<<std::endl; 
     39      if(CXios::isClient) std::cout<<"CFileWriterFilter::apply filter tag = "<<this->tag<<" start = "<<start_graph<<" end = "<<end_graph<<std::endl; 
    3340 
    34       if(CXios::isClient)  
     41      if(CXios::isClient && CWorkflowGraph::build_begin)  
    3542      { 
    36         StdString str = this->output_field_id +" ts=" + to_string(data[0]->timestamp); 
    37         // StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    38         (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    39         (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID);   
     43 
     44        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     45 
     46        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
    4047      } 
     48      else CWorkflowGraph::build_begin=true; 
    4149    } 
    4250     

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

    r1677 r1679  
    44#include "input_pin.hpp" 
    55#include "file.hpp" 
     6#include "duration.hpp" 
    67 
    78namespace xios 
    … …  
    1617    public: 
    1718      int tag; 
    18       StdString output_field_id; 
     19      Time start_graph; 
     20      Time end_graph; 
     21      CField* field; //<! The associated field 
     22      int filterID; 
     23 
    1924      /*! 
    2025       * Constructs the filter (with one input slot) associated to the specified field 
    … …  
    2328       * \param gc the associated garbage collector 
    2429       * \param field the associated field 
    25        * \param[in] buildWorkflowGraph indicates whether the workflow will be visualized 
    2630       */ 
    27       CFileWriterFilter(CGarbageCollector& gc, CField* field, bool buildWorkflowGraph = false); 
     31      CFileWriterFilter(CGarbageCollector& gc, CField* field); 
    2832 
    29       //inline StdString GetName(void) {return StdString("File writer filter");}; 
    30       inline StdString GetName(void) {return StdString("File writer filter : ") + StdString(this->field->file->name);}; 
     33      inline StdString GetName(void) {return "File writer filter";}; 
    3134 
    3235 
    … …  
    4649 
    4750 
    48       int filterID; 
     51       
    4952 
    5053 
    … …  
    5861 
    5962    private: 
    60       CField* field; //<! The associated field 
    6163      std::map<Time, CDataPacketPtr> packets; //<! The stored packets 
    6264 

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

    r1677 r1679  
    33namespace xios 
    44{ 
    5   CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph /*= false*/) 
     5  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine) 
    66    : CInputPin(gc, inputSlotsCount) 
    7     , COutputPin(gc, false, buildWorkflowGraph) 
     7    , COutputPin(gc, false) 
    88    , engine(engine) 
    99    , inputSlotCount(inputSlotCount) 
    … …  
    1414  void CFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    1515  { 
    16     // std::cout<<"CFilter::onInputReady"<<std::endl; 
    1716    CDataPacketPtr outputPacket = engine->apply(data); 
    1817    if (outputPacket) 
    1918    { 
    20       // std::cout<<"Filter onOutputReady"<<std::endl; 
    2119      onOutputReady(outputPacket); 
    2220    }  

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

    r1677 r1679  
    2323       * \param inputSlotsCount the number of input slots 
    2424       * \param engine the filter engine 
    25        * \param buildWorkflowGraph indicates whether data will be visualized 
    2625       */ 
    27       CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine, bool buildWorkflowGraph = false); 
     26      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine); 
    2827 
    2928      StdString virtual GetName(void); 

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

    r1677 r1679  
    55  int InvalidableObject::filterIdGenerator = 0; 
    66  #pragma omp threadprivate(InvalidableObject::filterIdGenerator) 
     7 
     8  int InvalidableObject::edgeIdGenerator = 0; 
     9  #pragma omp threadprivate(InvalidableObject::edgeIdGenerator) 
    710   
    811  void CGarbageCollector::registerObject(InvalidableObject* Object, Time timestamp) 

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

    r1677 r1679  
    2525    static int filterIdGenerator; 
    2626    #pragma omp threadprivate(filterIdGenerator) 
     27 
     28    static int edgeIdGenerator; 
     29    #pragma omp threadprivate(edgeIdGenerator) 
    2730 
    2831     

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

    r1677 r1679  
    1212    , triggers(slotsCount) 
    1313    , hasTriggers(false) 
    14   { 
    15     // parent_filters = new std::list< std::shared_ptr<COutputPin> >; 
    16   } 
     14  {  } 
    1715 
    1816  StdString CInputPin::GetName(void) 
    … …  
    4442      gc.unregisterObject(this, packet->timestamp); 
    4543      onInputReady(it->second.packets); 
    46       //if(CXios::isClient) std::cout<<"setInput timestamp = "<<packet->timestamp<<std::endl; 
    4744      inputs.erase(it); 
    4845    } 

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

    r1677 r1679  
    77 
    88 
    9   COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/, bool buildWorkflowGraph /* =false */) 
     9  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/) 
    1010    : gc(gc) 
    1111    , manualTrigger(manualTrigger) 
    12     , buildWorkflowGraph(buildWorkflowGraph) 
    13   { 
    14     // parent_filter = new std::vector< void >(0); 
    15   } 
     12  {  } 
    1613 
    1714  StdString COutputPin::GetName(void) 
    … …  
    3734      ERROR("void COutputPin::onOutputReady(CDataPacketPtr packet)", 
    3835            "The packet cannot be null."); 
    39  
    40     //if(CXios::isClient) std::cout<<"onOutputReady"<<std::endl;  
    4136   
    4237 
    … …  
    120115    for(int i=0; i<parent_filters.size(); i++) 
    121116    { 
     117 
     118      if(parent_filters[i]->start_graph==0) parent_filters[i]->start_graph = start_graph; 
     119      else if(parent_filters[i]->start_graph<0) parent_filters[i]->start_graph = start_graph; 
     120      else parent_filters[i]->start_graph = min(parent_filters[i]->start_graph, start_graph); 
     121 
     122 
     123      if(parent_filters[i]->end_graph==9223372036854775807) parent_filters[i]->end_graph = end_graph;   
     124      else if(parent_filters[i]->end_graph<0) parent_filters[i]->end_graph = end_graph;   
     125      else parent_filters[i]->end_graph = max(parent_filters[i]->end_graph, end_graph); 
     126       
     127       
    122128      parent_filters[i]->tag += tag; 
    123129      parent_filters[i]->setParentFiltersTag(); 

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

    r1677 r1679  
    44#include "garbage_collector.hpp" 
    55#include "input_pin.hpp" 
     6#include "duration.hpp" 
    67 
    78namespace xios 
    89{ 
     10  class CField; 
    911  class CInputPin; 
    1012  class CFilter; 
     13  class CDuration; 
    1114  /*! 
    1215   * An output pin handles the connections with downstream filters. 
    … …  
    1518  { 
    1619    public: 
    17       StdString output_field_id; 
     20      // StdString output_field_id; 
    1821      int tag; 
     22      Time start_graph; 
     23      Time end_graph; 
     24      CField *field; 
     25 
     26 
    1927 
    2028      std::vector< std::shared_ptr<COutputPin> > parent_filters; 
    … …  
    2836       * \param buildWorkflowGraph indicates whether data will be visualized 
    2937       */ 
    30       COutputPin(CGarbageCollector& gc, bool manualTrigger = false, bool buildWorkflowGraph = false); 
     38      COutputPin(CGarbageCollector& gc, bool manualTrigger = false); 
    3139 
    3240      StdString virtual GetName(void); 
    … …  
    111119      std::map<Time, CDataPacketPtr> outputPackets; 
    112120 
    113       //! Indicates whether the workflow will be visualized 
    114       bool buildWorkflowGraph; 
    115  
    116  
    117121  }; // class COutputPin 
    118122} // namespace xios 

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

    r1677 r1679  
    11#include "pass_through_filter.hpp" 
    22#include "workflow_graph.hpp" 
     3#include "field.hpp" 
    34 
    45namespace xios 
    56{ 
    6   CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph /*= false*/) 
    7     : CFilter(gc, 1, this, buildWorkflowGraph) 
     7  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc) 
     8    : CFilter(gc, 1, this) 
    89  {  
    910  } 
    … …  
    1112  CDataPacketPtr CPassThroughFilter::apply(std::vector<CDataPacketPtr> data) 
    1213  { 
    13         if(this->tag) 
     14        bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     15 
     16    if(building_graph) 
    1417    { 
    15       std::cout<<"CPassThroughFilter::apply tag = "<<this->tag<<std::endl; 
     18      std::cout<<"CPassThroughFilter::apply tag = "<<this->tag<<" start = "<<start_graph<<" end = "<<end_graph<<std::endl; 
    1619      this->filterID = InvalidableObject::filterIdGenerator++; 
    17       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
     20      int edgeID = InvalidableObject::edgeIdGenerator++; 
     21      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
    1822 
    19       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "Pass Through Filter"; 
     23      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "Pass Through Filter"; 
     24      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 5; 
     25      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     26      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     27      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     28      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
    2029 
    21       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
     30      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
    2231       
    23       StdString str = data[0]->fieldID + " ts=" + to_string(data[0]->timestamp); 
    24       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    25       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
     32      if(CWorkflowGraph::build_begin) 
     33      { 
     34        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     35        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0; 
     36      } 
     37      else CWorkflowGraph::build_begin = true; 
     38       
    2639      data[0]->src_filterID=this->filterID; 
    2740 
    2841    } 
    29      
    30     data[0]->fieldID = this->output_field_id; 
     42    data[0]->field = this->field; 
    3143     
    3244 

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

    r1668 r1679  
    1717       * 
    1818       * \param gc the associated garbage collector 
    19        * \param buildWorkflowGraph indicates whether data will be visualized 
    2019       */ 
    21       CPassThroughFilter(CGarbageCollector& gc, bool buildWorkflowGraph = false); 
     20      CPassThroughFilter(CGarbageCollector& gc); 
    2221 
    2322      inline StdString GetName(void) {return StdString("Pass through filter");}; 

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

    r1677 r1679  
    1212                               const CDuration offset /*= NoneDu*/, bool manualTrigger /*= false*/, 
    1313                               bool hasMissingValue /*= false*/, 
    14                                double defaultValue /*= 0.0*/, 
    15                                bool buildWorkflowGraph /*= false*/) 
    16     : COutputPin(gc, manualTrigger, buildWorkflowGraph) 
     14                               double defaultValue /*= 0.0*/) 
     15    : COutputPin(gc, manualTrigger) 
    1716    , grid(grid) 
    1817    , compression(compression) 
    … …  
    6362    } 
    6463 
    65     packet->fieldID = field_id; 
    66     this->output_field_id = field_id; 
    67  
    68  
    69     if(this->tag) 
    70     { 
    71       this->filterID.first = InvalidableObject::filterIdGenerator++;   
    72       packet->src_filterID=this->filterID.first; 
     64     
     65    bool building_graph = this->tag ? packet->timestamp >= this->start_graph && packet->timestamp <= this->end_graph : false; 
     66 
     67    if(building_graph) 
     68    { 
     69      this->filterID = InvalidableObject::filterIdGenerator++;   
     70      packet->src_filterID=this->filterID; 
     71      packet->field = this->field; 
    7372       
    7473       
    75       if(CXios::isClient) std::cout<<"source filter tag = "<<this->tag<<std::endl; 
    76      
    77       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    78  
    79       (*CWorkflowGraph::mapFilters_ptr)[this->filterID.first] = "Source Filter"; 
    80  
    81       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    82  
    83  
     74      if(CXios::isClient) std::cout<<"source filter tag = "<<this->tag<<" start = "<<start_graph<<" end = "<<end_graph<<std::endl; 
     75     
     76      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     77 
     78      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "Source Filter "+ this->field->getId(); 
     79      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 1; 
     80      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     81      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 0; 
     82      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = date; 
     83      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = packet->timestamp; 
     84 
     85      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge>; 
     86 
     87      CWorkflowGraph::build_begin = true; 
    8488    } 
    8589 
    … …  
    132136      } 
    133137    } 
    134     this->filterID.first = InvalidableObject::filterIdGenerator++; 
    135     packet->src_filterID=this->filterID.first; 
     138    this->filterID = InvalidableObject::filterIdGenerator++; 
     139    packet->src_filterID=this->filterID; 
    136140 
    137141    if(CXios::isClient) std::cout<<"source filter filter tag = "<<this->tag<<std::endl; 
    138      
    139     if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    140  
    141     (*CWorkflowGraph::mapFilters_ptr)[this->filterID.first] = "Source Filter"; 
    142  
    143  
    144142 
    145143    onOutputReady(packet); 

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

    r1677 r1679  
    2727       * \param hasMissingValue whether data has missing value 
    2828       * \param defaultValue missing value to detect 
    29        * \param[in] buildWorkflowGraph indicates whether the workflow will be visualized 
    3029       */ 
    3130      CSourceFilter(CGarbageCollector& gc, CGrid* grid, 
    … …  
    3433                    const CDuration offset = NoneDu, bool manualTrigger = false, 
    3534                    bool hasMissingValue = false, 
    36                     double defaultValue = 0.0, 
    37                                         bool buildWorkflowGraph = false); 
     35                    double defaultValue = 0.0); 
    3836 
    3937      inline StdString GetName(void) {return StdString("Source filter");}; 
    … …  
    6967       */ 
    7068      void signalEndOfStream(CDate date); 
    71       std::pair<int, int> filterID; 
    72       std::vector<int> filterIDoutputs; 
     69      int filterID; 
    7370 
    7471    private: 

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

    r1677 r1679  
    1212{ 
    1313  CSpatialTransformFilter::CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, 
    14                                                    double outputValue, size_t inputSlotsCount, bool buildWorkflowGraph /*= false*/) 
    15     : CFilter(gc, inputSlotsCount, engine, buildWorkflowGraph), outputDefaultValue(outputValue) 
     14                                                   double outputValue, size_t inputSlotsCount) 
     15    : CFilter(gc, inputSlotsCount, engine), outputDefaultValue(outputValue) 
    1616  { /* Nothing to do */ } 
    1717 
    1818  std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> > 
    19   CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue, 
    20                                             bool buildWorkflowGraph) 
     19  CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue) 
    2120  { 
    2221    if (!srcGrid || !destGrid) 
    … …  
    4443      std::shared_ptr<CSpatialTransformFilter> filter ; 
    4544      if( isSpatialTemporal) 
    46         filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount, buildWorkflowGraph)); 
     45        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount)); 
    4746      else 
    48         filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount, buildWorkflowGraph)); 
     47        filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount)); 
    4948 
    5049       
    … …  
    7372  void CSpatialTransformFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    7473  { 
    75     // if(CXios::isClient) std::cout<<"CSpatialTransformFilter onInputReady"<<std::endl; 
    7674 
    7775    CSpatialTransformFilterEngine* spaceFilter = static_cast<CSpatialTransformFilterEngine*>(engine); 
    78     CDataPacketPtr outputPacket = spaceFilter->applyFilter(data, outputDefaultValue, this->tag, this->output_field_id); 
     76    CDataPacketPtr outputPacket = spaceFilter->applyFilter(data, outputDefaultValue, this->tag, this->start_graph, this->end_graph, this->field); 
    7977    if (outputPacket) 
    8078    { 
    81       // std::cout<<"Spatial Transform Filter onOutputReady"<<std::endl; 
    8279      onOutputReady(outputPacket); 
    8380    }  
    … …  
    8683  CSpatialTemporalFilter::CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, 
    8784                                                  CGridTransformation* gridTransformation, double outputValue, 
    88                                                   size_t inputSlotsCount, bool buildWorkflowGraph) 
    89     : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount, buildWorkflowGraph), record(0) 
     85                                                  size_t inputSlotsCount) 
     86    : CSpatialTransformFilter(gc, engine, outputValue, inputSlotsCount), record(0) 
    9087  { 
    9188      const CGridTransformationSelector::ListAlgoType& algoList = gridTransformation->getAlgoList() ; 
    … …  
    112109  void CSpatialTemporalFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    113110  { 
    114     if(CXios::isClient) std::cout<<"CSpatialTemporalFilter onInputReady"<<std::endl; 
    115111 
    116112    CSpatialTransformFilterEngine* spaceFilter = static_cast<CSpatialTransformFilterEngine*>(engine); 
    117     CDataPacketPtr outputPacket = spaceFilter->applyFilter(data, outputDefaultValue, this->tag, this->output_field_id); 
     113    CDataPacketPtr outputPacket = spaceFilter->applyFilter(data, outputDefaultValue, this->tag, this->start_graph, this->end_graph, this->field); 
    118114 
    119115    if (outputPacket) 
    … …  
    140136        packet->data.resize(tmpData.numElements()); 
    141137        packet->data = tmpData; 
    142         std::cout<<"Spatial temporal filter onOutputReady"<<std::endl; 
     138        packet->field = this->field; 
    143139        onOutputReady(packet); 
    144140        tmpData.resize(0) ; 
    … …  
    182178  } 
    183179 
    184   CDataPacketPtr CSpatialTransformFilterEngine::applyFilter(std::vector<CDataPacketPtr> data, double defaultValue, int tag, StdString fieldID) 
    185   { 
    186     if(tag) 
     180  CDataPacketPtr CSpatialTransformFilterEngine::applyFilter(std::vector<CDataPacketPtr> data, double defaultValue, int tag, Time start_graph, Time end_graph, CField *field) 
     181  { 
     182    bool building_graph = tag ? data[0]->timestamp >= start_graph && data[0]->timestamp <= end_graph : false; 
     183    if(building_graph) 
    187184    { 
    188185      this->filterID = InvalidableObject::filterIdGenerator++; 
    189      
    190       std::cout<<"CSpatialTransformFilter::apply filter tag = "<<tag<<std::endl; 
    191      
    192  
    193       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    194  
    195       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "Spatial Transform Filter"; 
    196  
    197       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    198  
    199       StdString str = data[0]->fieldID + " ts=" + to_string(data[0]->timestamp); 
    200       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    201       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
     186      int edgeID = InvalidableObject::edgeIdGenerator++; 
     187     
     188      std::cout<<"CSpatialTransformFilter::apply filter tag = "<<tag<<" start = "<<start_graph<<" end = "<<end_graph<<std::endl; 
     189     
     190 
     191      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     192 
     193 
     194      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "Spatial Transform Filter"; 
     195      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 6; 
     196      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     197      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     198      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     199      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     200 
     201 
     202      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     203 
     204      if(CWorkflowGraph::build_begin) 
     205      { 
     206        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     207 
     208        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0; 
     209      } 
     210      else CWorkflowGraph::build_begin = true; 
    202211    } 
    203212 
    … …  
    207216    packet->timestamp = data[0]->timestamp; 
    208217    packet->status = data[0]->status; 
     218     
    209219 
    210220    if (packet->status == CDataPacket::NO_ERROR) 
    … …  
    219229      if (0 != packet->data.numElements()) 
    220230        (packet->data)(0) = defaultValue; 
    221       apply(data[0]->data, packet->data); 
    222     } 
    223  
    224     if(tag) packet->src_filterID=this->filterID; 
    225     packet->fieldID=fieldID; 
     231      apply(data[0]->data, packet->data, this->filterID); 
     232    } 
     233 
     234    if(building_graph) packet->src_filterID=this->filterID; 
     235    packet->field = field; 
    226236 
    227237    return packet; 
    228238  } 
    229239 
    230   void CSpatialTransformFilterEngine::apply(const CArray<double, 1>& dataSrc, CArray<double,1>& dataDest) 
     240  void CSpatialTransformFilterEngine::apply(const CArray<double, 1>& dataSrc, CArray<double,1>& dataDest, int filterID) 
    231241  { 
    232242    CTimer::get("CSpatialTransformFilterEngine::apply").resume();  
    … …  
    343353        const std::vector<std::pair<int,double> >& localIndex_p = itRecv->second; 
    344354        int srcRank = itRecv->first; 
     355 
     356        if(filterID >=0) (*CWorkflowGraph::mapFilters_ptr_with_info)[filterID].transform_type = (*itAlgo)->getName(); 
    345357        if (srcRank != rank) 
    346358        { 

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

    r1677 r1679  
    33 
    44#include "filter.hpp" 
     5#include "field.hpp" 
    56 
    67namespace xios 
    … …  
    910  class CGridTransformation; 
    1011  class CSpatialTransformFilterEngine; 
     12 
     13  class CField; 
    1114 
    1215  /*! 
    … …  
    2326       * \param outputValue default value of output pin 
    2427       * \param [in] inputSlotsCount number of input, by default there is only one for field src 
    25        * \param buildWorkflowGraph indicates whether data will be visualized 
    2628       */ 
    2729      CSpatialTransformFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, 
    28                               double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false); 
     30                              double outputValue, size_t inputSlotsCount = 1); 
    2931 
    3032      inline StdString GetName(void) {return StdString("Spatial transform filter");}; 
    … …  
    3840       * \param hasMissingValue whether field source has missing value 
    3941       * \param defaultValue default value 
    40        * \param buildWorkflowGraph indicates whether data will be visualized 
    4142       * \return the first and the last filters of the filter graph 
    4243       */ 
    4344      static std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> > 
    44       buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue, bool buildWorkflowGraph = false); 
     45      buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue); 
    4546 
    4647    protected: 
    … …  
    7273       * \param outputValue default value of output pin 
    7374       * \param [in] inputSlotsCount number of input, by default there is only one for field src 
    74        * \param buildWorkflowGraph indicates whether data will be visualized 
    7575       * 
    7676       */ 
    7777      CSpatialTemporalFilter(CGarbageCollector& gc, CSpatialTransformFilterEngine* engine, CGridTransformation* gridTransformation, 
    78                             double outputValue, size_t inputSlotsCount = 1, bool buildWorkflowGraph = false); 
     78                            double outputValue, size_t inputSlotsCount = 1); 
    7979 
    8080 
    … …  
    104104      int filterID; 
    105105      int tag; 
     106      CField *field; 
    106107      /*! 
    107108       * Returns the engine wrapping the specified grid transformation. 
    … …  
    120121       * \return the result of the grid transformation 
    121122       */ 
    122       CDataPacketPtr applyFilter(std::vector<CDataPacketPtr> data, double defaultValue = 0, int tag=0, StdString fieldID=0); 
     123      CDataPacketPtr applyFilter(std::vector<CDataPacketPtr> data, double defaultValue = 0, int tag=0, Time start_graph=0, Time end_graph=-1, CField *field=0); 
    123124 
    124125       /*! 
    … …  
    147148       * \param dataDest the resulting transformed data 
    148149       */ 
    149       void apply(const CArray<double, 1>& dataSrc, CArray<double,1>& dataDest); 
     150      void apply(const CArray<double, 1>& dataSrc, CArray<double,1>& dataDest, int filterID=-1); 
    150151 
    151152      CGridTransformation* gridTransformation; //!< The grid transformation used by the engine 

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

    r1677 r1679  
    9090  void CStoreFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    9191  { 
    92     if(CXios::isClient) std::cout<<"CStoreFilter onInputReady"<<std::endl; 
    9392 
    94     if(this->tag) 
     93    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     94 
     95    if(building_graph) 
    9596    { 
    9697      this->filterID = InvalidableObject::filterIdGenerator++; 
     98      int edgeID = InvalidableObject::edgeIdGenerator++; 
    9799 
    98       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    99       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
     100      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     101      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
    100102 
    101       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "Store Filter"; 
     103 
     104      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "Store Filter"; 
     105      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 4; 
     106      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     107      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     108      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     109      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
    102110 
    103111      if(CXios::isClient) std::cout<<"CStoreFilter::apply filter tag = "<<this->tag<<std::endl; 
    104112 
    105       if(CXios::isClient)  
     113      if(CXios::isClient && CWorkflowGraph::build_begin)  
    106114      { 
    107         StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    108         (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    109         (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID);   
     115        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]);; 
     116        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0; 
    110117      } 
     118      else CWorkflowGraph::build_begin = true; 
    111119    } 
    112120 

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

    r1677 r1679  
    1010  class CContext; 
    1111  class CGrid; 
     12  class CField; 
    1213 
    1314  /*! 
    … …  
    7778      int filterID; 
    7879      int tag; 
     80      Time start_graph; 
     81      Time end_graph; 
     82      CField *field; 
    7983 
    8084 

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

    r1677 r1679  
    1010  CTemporalFilter::CTemporalFilter(CGarbageCollector& gc, const std::string& opId, 
    1111                                   const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq, 
    12                                    bool ignoreMissingValue /*= false*/, bool buildWorkflowGraph /*= false*/) 
    13     : CFilter(gc, 1, this, buildWorkflowGraph) 
     12                                   bool ignoreMissingValue /*= false*/) 
     13    : CFilter(gc, 1, this) 
    1414    , functor(createFunctor(opId, ignoreMissingValue, tmpData)) 
    1515    , isOnceOperation(functor->timeType() == func::CFunctor::once) 
    … …  
    3333  CDataPacketPtr CTemporalFilter::apply(std::vector<CDataPacketPtr> data) 
    3434  { 
     35    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
    3536    
    36     if(this->tag) 
     37    if(building_graph) 
    3738    { 
    3839      if(this->filterIDoutputs.size()==0) this->filterID = InvalidableObject::filterIdGenerator++; 
     40      int edgeID = InvalidableObject::edgeIdGenerator++; 
    3941       
    4042 
    41       std::cout<<"CTemporalFilter::apply filter tag = "<<this->tag<<std::endl; 
     43      std::cout<<"CTemporalFilter::apply filter tag = "<<this->tag<<" start = "<<this->start_graph<<" end = "<<this->end_graph<<std::endl; 
    4244 
    43       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
     45      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
    4446 
    45       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    46       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    47       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    48         
    49      
    50       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
     47      if(CWorkflowGraph::build_begin) 
     48      { 
    5149 
    52       if(this->filterIDoutputs.size()==0) (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "Temporal Filter";   
     50        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     51 
     52        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     53      } 
     54       
     55      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     56 
     57      if(this->filterIDoutputs.size()==0) 
     58      { 
     59        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "Temporal Filter";    
     60        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 3;    
     61        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1;    
     62        // (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = (initDate + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth) / data[0]->date +1 ;    
     63        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb =-1;    
     64        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date;    
     65        (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp;    
     66      } 
     67 
    5368 
    5469      this->filterIDoutputs.push_back(data[0]->src_filterID);  
    … …  
    102117 
    103118        isFirstOperation = false; 
    104         if(this->tag) packet->src_filterID=this->filterID; 
    105         packet->fieldID = this->output_field_id; 
    106         if(this->tag) this->filterIDoutputs.clear(); 
     119        if(building_graph) packet->src_filterID=this->filterID; 
     120        packet->field = this->field; 
     121        if(building_graph) this->filterIDoutputs.clear(); 
     122        if(building_graph) CWorkflowGraph::build_begin=true; 
    107123      } 
    108124    } 

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

    r1677 r1679  
    2929      CTemporalFilter(CGarbageCollector& gc, const std::string& opId, 
    3030                      const CDate& initDate, const CDuration samplingFreq, const CDuration samplingOffset, const CDuration opFreq, 
    31                       bool ignoreMissingValue = false, bool buildWorkflowGraph = false); 
     31                      bool ignoreMissingValue = false); 
    3232 
    3333      inline StdString GetName(void) {return StdString("Temporal filter");}; 

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

    r1677 r1679  
    1313  CDataPacketPtr CScalarScalarFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    1414  { 
    15     if(this->tag) 
    16     { 
    17       this->filterID = InvalidableObject::filterIdGenerator++; 
    18      
    19  
    20       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    21       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    22  
    23       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "SSF Filter" ; 
     15    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     16    
     17    if(building_graph) 
     18    { 
     19      this->filterID = InvalidableObject::filterIdGenerator++; 
     20       int edgeID = InvalidableObject::edgeIdGenerator++; 
     21     
     22      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     23      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     24 
    2425      std::cout<<"CScalarScalarFieldArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    2526 
    26       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    27       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    28       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    29     } 
    30  
    31     CDataPacketPtr packet(new CDataPacket); 
    32     packet->date = data[0]->date; 
    33     packet->timestamp = data[0]->timestamp; 
    34     packet->status = data[0]->status; 
    35     if(this->tag) packet->src_filterID = this->filterID; 
    36     packet->fieldID = this->output_field_id; 
     27      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "SSF Filter"; 
     28      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     29      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     30      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     31      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     32      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     33 
     34 
     35      if(CWorkflowGraph::build_begin) 
     36      { 
     37 
     38        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     39 
     40        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     41      } 
     42      else CWorkflowGraph::build_begin = true; 
     43    } 
     44 
     45    CDataPacketPtr packet(new CDataPacket); 
     46    packet->date = data[0]->date; 
     47    packet->timestamp = data[0]->timestamp; 
     48    packet->status = data[0]->status; 
     49    if(building_graph) packet->src_filterID = this->filterID; 
     50    packet->field = this->field; 
    3751 
    3852    if (packet->status == CDataPacket::NO_ERROR) 
    … …  
    5165  CDataPacketPtr CScalarFieldScalarArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    5266  { 
    53     if(this->tag) 
    54     { 
    55       this->filterID = InvalidableObject::filterIdGenerator++; 
    56      
    57  
    58       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    59       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    60  
    61       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "SFS Filter" ; 
     67    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     68    
     69    if(building_graph) 
     70    { 
     71      this->filterID = InvalidableObject::filterIdGenerator++; 
     72       int edgeID = InvalidableObject::edgeIdGenerator++; 
     73     
     74 
     75      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     76      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     77 
    6278      std::cout<<"CScalarFieldScalarArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    6379 
    64       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    65       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    66       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    67     } 
    68  
    69     CDataPacketPtr packet(new CDataPacket); 
    70     packet->date = data[0]->date; 
    71     packet->timestamp = data[0]->timestamp; 
    72     packet->status = data[0]->status; 
    73     if(this->tag) packet->src_filterID = this->filterID; 
    74     packet->fieldID = this->output_field_id; 
     80      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "SFS Filter"; 
     81      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     82      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     83      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     84      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     85      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     86 
     87      if(CWorkflowGraph::build_begin) 
     88      { 
     89 
     90        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     91        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     92      } 
     93      else CWorkflowGraph::build_begin = true; 
     94    } 
     95 
     96    CDataPacketPtr packet(new CDataPacket); 
     97    packet->date = data[0]->date; 
     98    packet->timestamp = data[0]->timestamp; 
     99    packet->status = data[0]->status; 
     100    if(building_graph) packet->src_filterID = this->filterID; 
     101    packet->field = this->field; 
    75102 
    76103    if (packet->status == CDataPacket::NO_ERROR) 
    … …  
    88115  CDataPacketPtr CScalarFieldFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    89116  { 
    90     if(this->tag) 
    91     { 
    92       this->filterID = InvalidableObject::filterIdGenerator++; 
    93      
    94  
    95       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    96       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    97  
    98       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "SFF Filter" ; 
     117    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     118    
     119    if(building_graph) 
     120    { 
     121      this->filterID = InvalidableObject::filterIdGenerator++; 
     122      int edgeID = InvalidableObject::edgeIdGenerator++; 
     123     
     124 
     125      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     126      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     127 
    99128      std::cout<<"CScalarFieldFieldArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    100129 
    101       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    102       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    103       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    104  
    105       str = data[1]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    106       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[1]->src_filterID); 
    107       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    108     } 
    109  
    110     CDataPacketPtr packet(new CDataPacket); 
    111     packet->date = data[0]->date; 
    112     packet->timestamp = data[0]->timestamp; 
    113     packet->status = data[0]->status; 
    114     if(this->tag) packet->src_filterID = this->filterID; 
    115     packet->fieldID = this->output_field_id; 
     130      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "SFF Filter"; 
     131      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     132      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     133      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 2; 
     134      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     135      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     136 
     137      if(CWorkflowGraph::build_begin) 
     138      { 
     139 
     140        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     141 
     142 
     143        edgeID = InvalidableObject::edgeIdGenerator++; 
     144 
     145        CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
     146 
     147        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     148        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
     149      } 
     150      else CWorkflowGraph::build_begin = true; 
     151    } 
     152 
     153    CDataPacketPtr packet(new CDataPacket); 
     154    packet->date = data[0]->date; 
     155    packet->timestamp = data[0]->timestamp; 
     156    packet->status = data[0]->status; 
     157    if(building_graph) packet->src_filterID = this->filterID; 
     158    packet->field = this->field; 
    116159 
    117160    if (data[0]->status != CDataPacket::NO_ERROR) 
    … …  
    138181  CDataPacketPtr CFieldScalarScalarArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    139182  { 
    140     if(this->tag) 
    141     { 
    142       this->filterID = InvalidableObject::filterIdGenerator++; 
    143      
    144  
    145       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    146       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    147  
    148       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "FSS Filter" ; 
     183    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     184    
     185    if(building_graph) 
     186    { 
     187      this->filterID = InvalidableObject::filterIdGenerator++; 
     188      int edgeID = InvalidableObject::edgeIdGenerator++; 
     189     
     190 
     191      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     192      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     193 
    149194      std::cout<<"CFieldScalarScalarArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    150195 
    151       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    152       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    153       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    154     } 
    155  
    156     CDataPacketPtr packet(new CDataPacket); 
    157     packet->date = data[0]->date; 
    158     packet->timestamp = data[0]->timestamp; 
    159     packet->status = data[0]->status; 
    160     if(this->tag) packet->src_filterID = this->filterID; 
    161     packet->fieldID = this->output_field_id; 
     196      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "FSS Filter"; 
     197      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     198      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     199      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     200      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     201      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     202 
     203      if(CWorkflowGraph::build_begin) 
     204      { 
     205 
     206        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     207 
     208        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     209      } 
     210      else CWorkflowGraph::build_begin = true; 
     211    } 
     212 
     213    CDataPacketPtr packet(new CDataPacket); 
     214    packet->date = data[0]->date; 
     215    packet->timestamp = data[0]->timestamp; 
     216    packet->status = data[0]->status; 
     217    if(building_graph) packet->src_filterID = this->filterID; 
     218    packet->field = this->field; 
    162219 
    163220    if (packet->status == CDataPacket::NO_ERROR) 
    … …  
    176233  CDataPacketPtr CFieldScalarFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    177234  { 
    178     if(this->tag) 
    179     { 
    180       this->filterID = InvalidableObject::filterIdGenerator++; 
    181      
    182  
    183       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    184       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    185  
    186       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "FSF Filter" ; 
     235    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     236    
     237    if(building_graph) 
     238    { 
     239      this->filterID = InvalidableObject::filterIdGenerator++; 
     240      int edgeID = InvalidableObject::edgeIdGenerator++; 
     241     
     242 
     243      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     244      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     245 
    187246      std::cout<<"CFieldScalarFieldArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    188247 
    189       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    190       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    191       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    192  
    193       str = data[1]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    194       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[1]->src_filterID); 
    195       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    196     } 
    197  
    198     CDataPacketPtr packet(new CDataPacket); 
    199     packet->date = data[0]->date; 
    200     packet->timestamp = data[0]->timestamp; 
    201     packet->status = data[0]->status; 
    202     if(this->tag) packet->src_filterID = this->filterID; 
    203     packet->fieldID = this->output_field_id; 
     248      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "FSF Filter"; 
     249      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     250      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     251      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 2; 
     252      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     253      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     254 
     255      if(CWorkflowGraph::build_begin) 
     256      { 
     257 
     258        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     259 
     260        edgeID = InvalidableObject::edgeIdGenerator++; 
     261 
     262        CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
     263 
     264        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     265        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
     266      } 
     267      else CWorkflowGraph::build_begin = true; 
     268    } 
     269 
     270    CDataPacketPtr packet(new CDataPacket); 
     271    packet->date = data[0]->date; 
     272    packet->timestamp = data[0]->timestamp; 
     273    packet->status = data[0]->status; 
     274    if(building_graph) packet->src_filterID = this->filterID; 
     275    packet->field = this->field; 
    204276 
    205277    if (data[0]->status != CDataPacket::NO_ERROR) 
    … …  
    223295  CDataPacketPtr CFieldFieldScalarArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    224296  { 
    225     if(this->tag) 
    226     { 
    227       this->filterID = InvalidableObject::filterIdGenerator++; 
    228      
    229  
    230       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    231       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    232  
    233       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "FFS Filter" ; 
     297    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     298    
     299    if(building_graph) 
     300    { 
     301      this->filterID = InvalidableObject::filterIdGenerator++; 
     302      int edgeID = InvalidableObject::edgeIdGenerator++; 
     303     
     304      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     305      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     306 
    234307      std::cout<<"CFieldFieldScalarArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    235308 
    236       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    237       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    238       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    239  
    240       str = data[1]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    241       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[1]->src_filterID); 
    242       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    243     } 
    244  
    245     CDataPacketPtr packet(new CDataPacket); 
    246     packet->date = data[0]->date; 
    247     packet->timestamp = data[0]->timestamp; 
    248     packet->status = data[0]->status; 
    249     if(this->tag) packet->src_filterID = this->filterID; 
    250     packet->fieldID = this->output_field_id; 
     309      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "FFS Filter"; 
     310      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     311      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     312      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 2; 
     313      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     314      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     315 
     316      if(CWorkflowGraph::build_begin) 
     317      { 
     318 
     319        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     320 
     321        int edgeID = InvalidableObject::edgeIdGenerator++; 
     322 
     323        CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
     324 
     325        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     326        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
     327      } 
     328      else CWorkflowGraph::build_begin = true; 
     329    } 
     330 
     331    CDataPacketPtr packet(new CDataPacket); 
     332    packet->date = data[0]->date; 
     333    packet->timestamp = data[0]->timestamp; 
     334    packet->status = data[0]->status; 
     335    if(building_graph) packet->src_filterID = this->filterID; 
     336    packet->field = this->field; 
    251337 
    252338    if (data[0]->status != CDataPacket::NO_ERROR) 
    … …  
    270356  CDataPacketPtr CFieldFieldFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    271357  { 
    272     if(this->tag) 
    273     { 
    274       this->filterID = InvalidableObject::filterIdGenerator++; 
    275      
    276  
    277       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    278       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
    279  
    280       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = "FFF Filter" ; 
     358    bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     359    
     360    if(building_graph) 
     361    { 
     362      this->filterID = InvalidableObject::filterIdGenerator++; 
     363      int edgeID = InvalidableObject::edgeIdGenerator++; 
     364     
     365 
     366      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     367      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
     368 
    281369      std::cout<<"CFieldFieldFieldArithmeticFilter::apply connection = "<<data[0]->src_filterID<<" <-> "<<this->filterID<<std::endl; 
    282370 
    283       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    284       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    285       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    286  
    287       str = data[1]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    288       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[1]->src_filterID); 
    289       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    290  
    291       str = data[2]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    292       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[2]->src_filterID); 
    293       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID); 
    294     } 
    295  
    296  
    297     CDataPacketPtr packet(new CDataPacket); 
    298     packet->date = data[0]->date; 
    299     packet->timestamp = data[0]->timestamp; 
    300     packet->status = data[0]->status; 
    301     if(this->tag) packet->src_filterID = this->filterID; 
    302     packet->fieldID = this->output_field_id; 
     371      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "FFF Filter"; 
     372      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     373      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     374      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 3; 
     375      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     376      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     377 
     378      if(CWorkflowGraph::build_begin) 
     379      { 
     380 
     381        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     382 
     383 
     384        edgeID = InvalidableObject::edgeIdGenerator++; 
     385 
     386        CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
     387 
     388 
     389        edgeID = InvalidableObject::edgeIdGenerator++; 
     390 
     391        CWorkflowGraph::addEdge(edgeID, this->filterID, data[2]); 
     392 
     393        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
     394        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
     395        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[2]->src_filterID].filter_filled = 0 ; 
     396      } 
     397      else CWorkflowGraph::build_begin = true; 
     398    } 
     399 
     400 
     401    CDataPacketPtr packet(new CDataPacket); 
     402    packet->date = data[0]->date; 
     403    packet->timestamp = data[0]->timestamp; 
     404    packet->status = data[0]->status; 
     405    if(building_graph) packet->src_filterID = this->filterID; 
     406    packet->field = this->field; 
    303407 
    304408    if (data[0]->status != CDataPacket::NO_ERROR) 

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

    r1677 r1679  
    3030  CDataPacketPtr CUnaryArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
    3131  { 
    32     if(this->tag) 
     32    bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
     33 
     34    if(building_graph) 
    3335    { 
    3436      this->filterID = InvalidableObject::filterIdGenerator++; 
     37      int edgeID = InvalidableObject::edgeIdGenerator++; 
    3538       
    36       if(CWorkflowGraph::mapFieldToFilters_ptr==0) CWorkflowGraph::mapFieldToFilters_ptr = new std::unordered_map <StdString, vector <int> >; 
    37       if(CWorkflowGraph::mapFilters_ptr==0) CWorkflowGraph::mapFilters_ptr = new std::unordered_map <int, StdString>; 
     39      if(CWorkflowGraph::mapFieldToFilters_ptr_with_info==0) CWorkflowGraph::mapFieldToFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_edge >; 
     40      if(CWorkflowGraph::mapFilters_ptr_with_info==0) CWorkflowGraph::mapFilters_ptr_with_info = new std::unordered_map <int, graph_info_box_node>; 
    3841 
    39  
    40       (*CWorkflowGraph::mapFilters_ptr)[this->filterID] = op_expression +" F Filter" ; 
    4142      std::cout<<"CunaryArithmeticFilter::apply filter tag = "<<this->tag<<std::endl; 
    4243 
    43       StdString str = data[0]->fieldID +" ts=" + to_string(data[0]->timestamp); 
    44       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(data[0]->src_filterID); 
    45       (*CWorkflowGraph::mapFieldToFilters_ptr)[str].push_back(this->filterID);    
     44      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_name = "F Filter"; 
     45      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_class = 2; 
     46      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_filled = 1; 
     47      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb = 1; 
     48      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].date = data[0]->date; 
     49      (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].timestamp = data[0]->timestamp; 
     50 
     51      if(CWorkflowGraph::build_begin) 
     52      { 
     53 
     54        CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
     55 
     56        (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ;  
     57      } 
     58      else CWorkflowGraph::build_begin = true; 
    4659   
    4760    } 
    … …  
    5164    packet->timestamp = data[0]->timestamp; 
    5265    packet->status = data[0]->status; 
    53     packet->fieldID = this->output_field_id; 
     66    packet->field = this->field; 
    5467 
    5568    if (packet->status == CDataPacket::NO_ERROR) 
    5669      packet->data.reference(op(data[0]->data)); 
    5770 
    58     if(this->tag) packet->src_filterID = this->filterID; 
     71    if(building_graph) packet->src_filterID = this->filterID; 
    5972 
    6073    return packet; 

  • XIOS/dev/dev_trunk_omp/src/graphviz.cpp

    r1671 r1679  
    1111   * 
    1212   */ 
    13   void CGraphviz::buildStaticWorkflowGraph() 
     13  void CGraphviz::buildWorkflowGraphDot() 
    1414  TRY 
    1515  { 
    16     if (CWorkflowGraph::mapFieldToFilters_ptr !=0 && !CWorkflowGraph::mapFieldToFilters_ptr->empty()) 
     16    if (CWorkflowGraph::mapFieldToFilters_ptr_with_info !=0 && !CWorkflowGraph::mapFieldToFilters_ptr_with_info->empty()) 
    1717    { 
    1818      CWorkflowGraph::buildStaticWorkflow(); 
    … …  
    6565 
    6666 
     67 
     68  void CGraphviz::buildWorkflowGraphVisjs_with_info() 
     69  TRY 
     70  { 
     71    if (CWorkflowGraph::mapFilters_ptr_with_info !=0 && !CWorkflowGraph::mapFilters_ptr_with_info->empty()) 
     72    { 
     73      CWorkflowGraph::buildStaticWorkflow_with_info(); 
     74     
     75      std::ofstream fs_json; 
     76      fs_json.open ("graph_data.json", std::fstream::out); 
     77 
     78      fs_json << "{ \"node\" : ["<<std::endl; 
     79     
     80      for (auto it=CWorkflowGraph::mapFilters_ptr_with_info->begin(); it != CWorkflowGraph::mapFilters_ptr_with_info->end(); it++) 
     81      { 
     82        fs_json << "        {\"id\": "<<it->first +1<<"}, "<<std::endl; 
     83        fs_json << "            {\"label\": \""<<it->second.filter_name<<"\"}, "<<std::endl  ; 
     84        fs_json << "            {\"class\": "<<it->second.filter_class<<"}, "<<std::endl  ; 
     85        fs_json << "            {\"filled\": "<<it->second.filter_filled<<"}, "<<std::endl  ; 
     86        fs_json << "            {\"entry\": "<<it->second.expected_entry_nb<<"}, "<<std::endl  ; 
     87        // fs_json << "            {\"date\": \""<<it->second.date<<"\"}, "<<std::endl  ; 
     88        fs_json << "            {\"type\": \""<<it->second.transform_type<<"\"}, "<<std::endl  ; 
     89      } 
     90      fs_json << "    ]}"<<std::endl<<std::endl; 
     91 
     92      fs_json << "{ \"edge\" : ["<<std::endl; 
     93 
     94      for (auto it=CWorkflowGraph::mapFieldToFilters_ptr_with_info->begin(); it != CWorkflowGraph::mapFieldToFilters_ptr_with_info->end(); it++) 
     95      { 
     96        fs_json << "        {\"id\": "<<it->first +1<<"}, "<<std::endl; 
     97        fs_json << "            {\"from\": "<<it->second.from +1<<"}, "<<std::endl; 
     98        fs_json << "            {\"to\": "<<it->second.to+1<<"}, "<<std::endl  ; 
     99        fs_json << "            {\"fid\": \""<<it->second.field_id<<"\"}, "<<std::endl  ; 
     100        fs_json << "            {\"fname\": \""<<it->second.field_name<<"\"}, "<<std::endl  ; 
     101        fs_json << "            {\"gid\": \""<<it->second.grid_id<<"\"}, "<<std::endl  ; 
     102        fs_json << "            {\"date\": \""<<it->second.date<<"\"}, "<<std::endl  ; 
     103      } 
     104      fs_json << "    ]}"<<std::endl<<std::endl; 
     105 
     106 
     107       
     108 
     109       
     110 
     111      fs_json.close(); 
     112 
     113 
     114 
     115 
     116      std::ofstream fs; 
     117      fs.open ("graph_with_info.html", std::fstream::out); 
     118 
     119      fs << "<html>" <<std::endl; 
     120      fs << "<head>" <<std::endl; 
     121      fs << "    <script type=\"text/javascript\" src=\"../../../vis-4.21.0/dist/vis.js\"></script>" <<std::endl; 
     122      fs << "    <link href=\"../../../vis-4.21.0/dist/vis.css\" rel=\"stylesheet\" type=\"text/css\" />" <<std::endl <<std::endl; 
     123      fs << "    <style type=\"text/css\">"<<std::endl; 
     124      fs << "        #mynetwork {"<<std::endl; 
     125      fs << "            width: 1000px;"<<std::endl; 
     126      fs << "            height: 800px;"<<std::endl; 
     127      fs << "            border: 1px solid lightgray"<<std::endl; 
     128      fs << "        }"<<std::endl; 
     129      fs << "    </style>"<<std::endl; 
     130      fs << "</head>"<<std::endl; 
     131      fs << "<body>"<<std::endl; 
     132      fs << "<div id=\"mynetwork\"></div>"<<std::endl<<std::endl; 
     133      fs << "<script type=\"text/javascript\">"<<std::endl; 
     134 
     135      fs << "    var nodes = new vis.DataSet(["<<std::endl; 
     136      for(int i=0; i<CWorkflowGraph::filters.size(); i++) 
     137      { 
     138        fs << "        {id: "<<i+1<<", label: \'"<<CWorkflowGraph::filters[i]<<"\'},"<<std::endl  ; 
     139      } 
     140      fs << "    ]);"<<std::endl<<std::endl; 
     141 
     142 
     143      fs << "    var edges = new vis.DataSet(["<<std::endl; 
     144      for(int i=0; i<CWorkflowGraph::fieldsToFilters.size(); i++) 
     145      { 
     146        fs <<"        {from: "<<CWorkflowGraph::fieldsToFilters[i].first+1<<", to: "<<CWorkflowGraph::fieldsToFilters[i].second+1<<", label: \'"<<CWorkflowGraph::fields[i]<<"\'},"<<std::endl; 
     147      } 
     148      fs << "    ]);"<<std::endl<<std::endl; 
     149 
     150   
     151      fs << "    var container = document.getElementById(\'mynetwork\');" <<std::endl<<std::endl; 
     152      fs << "    var data = {" <<std::endl; 
     153      fs << "        nodes: nodes," <<std::endl; 
     154      fs << "        edges: edges" <<std::endl; 
     155      fs << "    };" <<std::endl; 
     156      fs << "    var options = {"<<std::endl; 
     157      fs << "        edges:{"<<std::endl; 
     158      fs << "            smooth: false,"<<std::endl; 
     159      fs << "            arrows: \'to\',"<<std::endl; 
     160      fs << "            color: 'red',"<<std::endl; 
     161      fs << "            font:{align: \'middle\'},"<<std::endl; 
     162      fs << "        },"<<std::endl; 
     163      fs << "        physics:{"<<std::endl; 
     164      fs << "            enabled: false,"<<std::endl; 
     165      fs << "        },"<<std::endl; 
     166      fs << "};" <<std::endl<<std::endl; 
     167 
     168      fs << "    var network = new vis.Network(container, data, options);" <<std::endl<<std::endl; 
     169 
     170      fs << "</script>"<<std::endl; 
     171      fs << "</body>"<<std::endl; 
     172      fs << "</html>"<<std::endl; 
     173 
     174       
     175 
     176      fs.close(); 
     177          
     178    } 
     179  } 
     180  CATCH 
     181 
     182 
     183 
    67184  void CGraphviz::showStaticWorkflowGraph() 
    68185  TRY 

  • XIOS/dev/dev_trunk_omp/src/graphviz.hpp

    r1671 r1679  
    1616 
    1717      CGraphviz(); 
    18       static void buildStaticWorkflowGraph(); 
     18      static void buildWorkflowGraphDot(); 
     19      static void buildWorkflowGraphVisjs_with_info(); 
    1920      static void showStaticWorkflowGraph(); 
    2021 

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

    r1677 r1679  
    11331133 
    11341134     const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     1135      
    11351136     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true); 
     1137 
     1138      
    11361139     const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
    11371140 
    11381141     CContext* context = CContext::getCurrent(); 
     1142     Time filter_start; 
     1143     if(!build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = context->calendar->getInitDate()+build_workflow_graph_start; 
     1144     else if(build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = 0; 
     1145     else filter_start = -1; 
     1146 
     1147     Time filter_end; 
     1148     if(!build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = context->calendar->getInitDate()+build_workflow_graph_end; 
     1149     else if(build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = 9223372036854775807; 
     1150     else filter_end = -1; 
     1151      
     1152 
    11391153     bool hasWriterServer = context->hasServer && !context->hasClient; 
    11401154     bool hasIntermediateServer = context->hasServer && context->hasClient; 
    … …  
    11811195           boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0')); 
    11821196           std::shared_ptr<COutputPin> filter = expr->reduce(gc, *this); 
    1183            filter->output_field_id = this->getId(); 
    11841197 
    11851198           // Check if a spatial transformation is needed 
    … …  
    11931206             { 
    11941207               std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, 
    1195                                                                                          detectMissingValues, defaultValue, buildWorkflowGraph); 
     1208                                                                                         detectMissingValues, defaultValue); 
    11961209 
    11971210               filter->connectOutput(filters.first, 0); 
    1198                filters.second->output_field_id = this->getId(); 
    11991211 
    12001212 
    … …  
    12051217 
    12061218           instantDataFilter = filter; 
    1207            instantDataFilter->output_field_id = this->getId(); 
    1208            filter->output_field_id = this->getId(); 
     1219           instantDataFilter->field = this; 
    12091220           filter->tag = buildWorkflowGraph; 
    1210            // std::cout<<"=====1============= output_field_id = "<<this->getId()<<" =========== tag="<<filter->tag<<std::endl; 
     1221            
     1222           filter->start_graph = filter_start; 
     1223           filter->end_graph = filter_end; 
     1224 
    12111225           for(int i=0; i<filter->parent_filters.size(); i++) 
    12121226           { 
    1213              // std::cout<<"transforme filter cout= "<<std::shared_ptr<COutputPin>(filter)<<" parent filter = "<<filter->parent_filters[i]<<std::endl;  
    12141227             filter->tag = filter->tag || filter->parent_filters[i]->tag; 
    12151228           } 
    … …  
    12261239           instantDataFilter = getFieldReference(gc); 
    12271240           instantDataFilter->tag = buildWorkflowGraph; 
     1241           instantDataFilter->start_graph = filter_start; 
     1242           instantDataFilter->end_graph = filter_end; 
    12281243         } 
    12291244         // Check if the data is to be read from a file 
    … …  
    12321247           checkTimeAttributes(); 
    12331248           instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, false, freq_offset, true, 
    1234                                                                                                        detectMissingValues, defaultValue, buildWorkflowGraph)); 
     1249                                                                                                       detectMissingValues, defaultValue)); 
    12351250           instantDataFilter->tag = buildWorkflowGraph; 
     1251           instantDataFilter->start_graph = filter_start; 
     1252           instantDataFilter->end_graph = filter_end; 
     1253           instantDataFilter->field = this; 
     1254 
    12361255         } 
    12371256         else // The data might be passed from the model 
    … …  
    12391258            if (check_if_active.isEmpty()) check_if_active = false;  
    12401259            instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, true, NoneDu, false, 
    1241                                                                                                       detectMissingValues, defaultValue, buildWorkflowGraph));  
     1260                                                                                                      detectMissingValues, defaultValue));  
    12421261            instantDataFilter->tag = buildWorkflowGraph; 
    1243             // std::cout<<"=====4============= output_field_id = "<<this->getId()<<" =========== tag="<<instantDataFilter->tag<<std::endl; 
    1244             // std::cout<<"Source filter cout = "<<std::shared_ptr<COutputPin>(clientSourceFilter)<<std::endl; 
     1262            instantDataFilter->start_graph = filter_start; 
     1263            instantDataFilter->end_graph = filter_end; 
     1264            instantDataFilter->field = this; 
    12451265         } 
    12461266       } 
    … …  
    12561276 
    12571277           storeFilter->tag = (instantDataFilter->tag || buildWorkflowGraph); 
     1278           instantDataFilter->start_graph = filter_start; 
     1279           instantDataFilter->end_graph = filter_end; 
     1280 
    12581281           instantDataFilter->setParentFiltersTag(); 
     1282           storeFilter->start_graph = filter_start; 
     1283           storeFilter->end_graph = filter_end; 
     1284           storeFilter->field = this; 
    12591285         } 
    12601286 
    12611287         if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write)) 
    12621288         { 
    1263            fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this, buildWorkflowGraph)); 
     1289           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this)); 
    12641290           getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0); 
    1265            std::cout<<"=====10============= output_field_id = "<<this->name<<std::endl; 
    1266            // std::cout<<"CFileWriterFilter filter = "<<fileWriterFilter<<" parent filter = "<<std::shared_ptr<COutputPin>(getTemporalDataFilter(gc, file->output_freq))<<std::endl; 
    12671291            
    12681292           fileWriterFilter->tag = (getTemporalDataFilter(gc, file->output_freq)->tag || buildWorkflowGraph); 
    1269            fileWriterFilter->output_field_id = this->name; 
     1293           getTemporalDataFilter(gc, file->output_freq)->start_graph = filter_start; 
     1294           getTemporalDataFilter(gc, file->output_freq)->end_graph = filter_end; 
    12701295           getTemporalDataFilter(gc, file->output_freq)->setParentFiltersTag(); 
     1296           fileWriterFilter->start_graph = filter_start; 
     1297           fileWriterFilter->end_graph = filter_end; 
     1298 
     1299           std::cout<<"CFileWriterFilter filter start = "<<filter_start<<" end = "<<filter_end<<std::endl; 
     1300 
    12711301         } 
    12721302       } 
    … …  
    12911321     CField* fieldRef = CField::get(field_ref); 
    12921322     fieldRef->buildFilterGraph(gc, false); 
    1293      bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true); 
     1323     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true); 
     1324 
     1325     CContext* context = CContext::getCurrent(); 
     1326 
     1327     Time filter_start; 
     1328     if(!build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = context->calendar->getInitDate()+build_workflow_graph_start; 
     1329     else if(build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = 0; 
     1330     else filter_start = -1; 
     1331 
     1332     Time filter_end; 
     1333     if(!build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = context->calendar->getInitDate()+build_workflow_graph_end; 
     1334     else if(build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = 9223372036854775807; 
     1335     else filter_end = -1; 
     1336 
    12941337 
    12951338     std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters; 
    … …  
    12991342       bool hasMissingValue = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    13001343       double defaultValue  = hasMissingValue ? default_value : (!default_value.isEmpty() ? default_value : 0.0);                                 
    1301        filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue, buildWorkflowGraph); 
     1344       filters = CSpatialTransformFilter::buildFilterGraph(gc, fieldRef->grid, grid, hasMissingValue, defaultValue); 
    13021345 
    13031346       fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0); 
    13041347 
    1305        filters.second->output_field_id = this->getId(); 
    13061348      
    13071349 
    … …  
    13101352 
    13111353       filters.second->tag = (buildWorkflowGraph || filters.second->parent_filters[0]->tag); 
    1312  
    1313        // std::cout<<"=====5============= output_field_id = "<<this->getId()<<std::endl; 
    1314        // std::cout<<"CSpatialTransformFilter first filter cout = "<<std::shared_ptr<COutputPin>(filters.first)<<"  second filter cout = "<<std::shared_ptr<COutputPin>(filters.second)<< " parent filter = "<<fieldRef->getInstantDataFilter()<<std::endl; 
    13151354        
     1355       filters.second->start_graph = filter_start; 
     1356       filters.second->end_graph = filter_end; 
     1357       filters.second->field = this; 
     1358        
    13161359     } 
    13171360     else 
    13181361     { 
    1319        filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc, buildWorkflowGraph)); 
     1362       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc)); 
    13201363 
    13211364       fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0); 
    1322        filters.second->output_field_id = this->getId(); 
    13231365      
    13241366 
    … …  
    13281370       filters.second->tag = buildWorkflowGraph || filters.second->parent_filters[0]->tag; 
    13291371 
    1330        // std::cout<<"=====6============= output_field_id = "<<this->getId()<<" =========== tag="<<filters.second->tag<<std::endl; 
    1331        // std::cout<<"Pass through filter cout = "<<std::shared_ptr<COutputPin>(filters.second)<<" parent filter = "<<filters.second->parent_filters[0]<<std::endl; 
     1372       filters.second->start_graph = filter_start; 
     1373       filters.second->end_graph = filter_end; 
     1374       filters.second->field = this; 
    13321375 
    13331376     } 
    … …  
    13911434 
    13921435     selfReferenceFilter->tag = buildWorkflowGraph; 
     1436     selfReferenceFilter->field = this; 
    13931437     return selfReferenceFilter; 
    13941438   } 
    … …  
    14081452   { 
    14091453     std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq); 
    1410      bool buildWorkflowGraph = buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true); 
     1454     const bool buildWorkflowGraph = (!build_workflow_graph.isEmpty() && build_workflow_graph == true); 
     1455 
     1456     CContext* context = CContext::getCurrent(); 
     1457 
     1458     Time filter_start; 
     1459     if(!build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = context->calendar->getInitDate()+build_workflow_graph_start; 
     1460     else if(build_workflow_graph_start.isEmpty() && buildWorkflowGraph) filter_start = 0; 
     1461     else filter_start = -1; 
     1462 
     1463     Time filter_end; 
     1464     if(!build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = context->calendar->getInitDate()+build_workflow_graph_end; 
     1465     else if(build_workflow_graph_end.isEmpty() && buildWorkflowGraph) filter_end = 9223372036854775807; 
     1466     else filter_end = -1; 
     1467 
     1468 
    14111469 
    14121470     if (it == temporalDataFilters.end()) 
    … …  
    14211479       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, CContext::getCurrent()->getCalendar()->getInitDate(), 
    14221480                                                                             freq_op, freq_offset, outFreq, 
    1423                                                                              detectMissingValues, buildWorkflowGraph)); 
     1481                                                                             detectMissingValues)); 
    14241482 
    14251483       instantDataFilter->connectOutput(temporalFilter, 0); 
    1426        temporalFilter->output_field_id = this->getId(); 
    14271484       temporalFilter->tag = buildWorkflowGraph; 
    14281485        
    … …  
    14311488        
    14321489 
    1433        // std::cout<<"=====8============= output_field_id = "<<this->getId()<<" =========== tag="<<temporalFilter->tag<<std::endl; 
    1434        // std::cout<<"Temporal filter cout = "<<std::shared_ptr<COutputPin>(temporalFilter)<<" parent filter = "<<temporalFilter->parent_filters[0]<<std::endl; 
    14351490       if(temporalFilter->parent_filters[0]->tag) temporalFilter->tag=true; 
     1491 
     1492       temporalFilter->start_graph = filter_start; 
     1493       temporalFilter->end_graph = filter_end; 
     1494       temporalFilter->field = this; 
    14361495 
    14371496       it = temporalDataFilters.insert(std::make_pair(outFreq, temporalFilter)).first; 
    … …  
    14731532                                                                           CContext::getCurrent()->getCalendar()->getInitDate(), 
    14741533                                                                           freq_op, freq_offset, outFreq, 
    1475                                                                            detectMissingValues, buildWorkflowGraph)); 
     1534                                                                           detectMissingValues)); 
    14761535 
    14771536       selfReferenceFilter->connectOutput(temporalFilter, 0); 
    1478        temporalFilter->output_field_id = this->getId(); 
    14791537       temporalFilter->tag = buildWorkflowGraph; 
    1480        // std::cout<<"=====9============= output_field_id = "<<this->getId()<<" =========== tag="<<temporalFilter->tag<<std::endl; 
     1538       temporalFilter->field = this; 
    14811539 
    14821540       return temporalFilter ; 

  • XIOS/dev/dev_trunk_omp/src/test/test_omp.f90

    r1677 r1679  
    169169   PRINT*,"field field_A is active ? ",xios_field_is_active("field_A") 
    170170 
    171    DO ts=1,2 
     171   DO ts=1,4 
    172172    CALL xios_update_calendar(ts) 
    173173    CALL xios_send_field("field_A",field_A) 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/average_reduction.hpp

    r1260 r1679  
    3333  virtual ~CAverageReductionAlgorithm() {} 
    3434 
     35  virtual StdString getName() {return "Average reduction";} 
     36 
    3537protected: 
    3638  CArray<double,1> weights_; 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/extract.hpp

    r1260 r1679  
    3131  virtual ~CExtractReductionAlgorithm() {} 
    3232 
     33  virtual StdString getName() {return "Extract reduction";} 
     34 
    3335public: 
    3436  static bool registerTrans(); 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/max_reduction.hpp

    r1260 r1679  
    3131  virtual ~CMaxReductionAlgorithm() {} 
    3232 
     33  virtual StdString getName() {return "Max reduction";} 
     34 
    3335public: 
    3436  static bool registerTrans(); 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/min_reduction.hpp

    r1260 r1679  
    3131  virtual ~CMinReductionAlgorithm() {} 
    3232 
     33  virtual StdString getName() {return "Min reduction";} 
     34 
    3335public: 
    3436  static bool registerTrans(); 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/reduction.hpp

    r1601 r1679  
    5757  virtual ~CReductionAlgorithm() {} 
    5858 
     59  virtual StdString getName() {return "Reduction";} 
     60 
    5961protected: 
    6062  typedef CReductionAlgorithm* (*CreateOperationCallBack)(); 

  • XIOS/dev/dev_trunk_omp/src/transformation/Functions/sum_reduction.hpp

    r1260 r1679  
    3131  virtual ~CSumReductionAlgorithm() {} 
    3232 
     33  virtual StdString getName() {return "Sum reduction";} 
     34 
    3335public: 
    3436  static bool registerTrans(); 

  • XIOS/dev/dev_trunk_omp/src/transformation/generic_algorithm_transformation.cpp

    r1677 r1679  
    3636TRY 
    3737{ 
    38   // std::cout<<"================================ CGenericAlgorithmTransformation::apply"<<std::endl; 
     38  std::cout<<"================================ CGenericAlgorithmTransformation::apply"<<std::endl; 
    3939 
    4040  int nbLocalIndex = localIndex.size();    

  • XIOS/dev/dev_trunk_omp/src/transformation/generic_algorithm_transformation.hpp

    r1646 r1679  
    7373                     std::vector<bool>& flagInitial,                      
    7474                     bool ignoreMissingValue, bool firstPass); 
     75 
     76  virtual StdString getName() {return "Generic algorithm transformation";} 
    7577 
    7678  /*! 

  • XIOS/dev/dev_trunk_omp/src/workflow_graph.cpp

    r1677 r1679  
    44{ 
    55 
    6   std::unordered_map <StdString, vector <int > > *CWorkflowGraph::mapFieldToFilters_ptr = 0; 
    7   #pragma omp threadprivate(CWorkflowGraph::mapFieldToFilters_ptr) 
     6  std::unordered_map <int, graph_info_box_node> *CWorkflowGraph::mapFilters_ptr_with_info = 0; 
     7  #pragma omp threadprivate(CWorkflowGraph::mapFilters_ptr_with_info) 
    88 
    9   std::unordered_map <int, StdString> *CWorkflowGraph::mapFilters_ptr = 0; 
    10   #pragma omp threadprivate(CWorkflowGraph::mapFilters_ptr) 
     9  std::unordered_map <int, graph_info_box_edge > *CWorkflowGraph::mapFieldToFilters_ptr_with_info = 0; 
     10  #pragma omp threadprivate(CWorkflowGraph::mapFieldToFilters_ptr_with_info) 
    1111 
    12   std::unordered_map <int,vector<Time> > *CWorkflowGraph::mapFilterTimestamps_ptr = 0; 
    13   #pragma omp threadprivate(CWorkflowGraph::mapFilterTimestamps_ptr) 
    14  
    15   set<Time>  *CWorkflowGraph::timestamps_ptr = 0; 
    16   #pragma omp threadprivate(CWorkflowGraph::timestamps_ptr) 
    1712 
    1813  vector <StdString> CWorkflowGraph::filters; 
    1914  vector <StdString> CWorkflowGraph::fields; 
    2015  vector <pair<int, int> > CWorkflowGraph::fieldsToFilters; 
     16 
     17  bool CWorkflowGraph::build_begin = false; 
     18  #pragma omp threadprivate(CWorkflowGraph::build_begin) 
    2119 
    2220  CWorkflowGraph::CWorkflowGraph() 
    … …  
    3028  { 
    3129     
    32     if(mapFilters_ptr==0 || mapFieldToFilters_ptr==0)  
     30    if(mapFilters_ptr_with_info==0 || mapFieldToFilters_ptr_with_info==0)  
    3331      std::cout<<"No graph information provided"<<std::endl; 
    3432 
    … …  
    3634    { 
    3735      size_t filterIdx = 0; 
    38       filters.resize(mapFilters_ptr->size()); 
     36      filters.resize(mapFilters_ptr_with_info->size()); 
    3937      fieldsToFilters.clear(); 
    4038      fields.clear(); 
    41       for (auto it=mapFilters_ptr->begin(); it != mapFilters_ptr->end(); it++) 
     39      for (auto it=mapFilters_ptr_with_info->begin(); it != mapFilters_ptr_with_info->end(); it++) 
    4240      { 
    43         filters[it->first]=it->second; 
     41        filters[it->first]=it->second.filter_name; 
    4442      } 
    4543 
    4644      // Create a list of fields and their filter connectivity (graph edges and edge-to-node connectivity) 
    47       for (auto it=mapFieldToFilters_ptr->begin(); it != mapFieldToFilters_ptr->end(); it++) 
     45      for (auto it=mapFieldToFilters_ptr_with_info->begin(); it != mapFieldToFilters_ptr_with_info->end(); it++) 
    4846      { 
    49         for (size_t i = 0; i < (it->second.size() - 1); i+=2) 
    50         { 
    51           fieldsToFilters.push_back(make_pair(it->second[i],it->second[i+1])); 
    52           fields.push_back(it->first); 
    53         } 
     47        fieldsToFilters.push_back(make_pair(it->second.from,it->second.to)); 
     48        fields.push_back(it->second.field_id + " "+it->second.date.toString()); 
    5449      } 
    5550    } 
    … …  
    5853 
    5954 
     55 
     56 
     57/*! 
     58   * Reorganize information collected by XIOS for visualization. 
     59   */ 
     60  void CWorkflowGraph::buildStaticWorkflow_with_info() 
     61  TRY 
     62  { 
     63     
     64    if(mapFilters_ptr_with_info==0 || mapFieldToFilters_ptr_with_info==0)  
     65      std::cout<<"No graph information provided"<<std::endl; 
     66 
     67    else // Create a list of filters (graph nodes) 
     68    { 
     69      size_t filterIdx = 0; 
     70      filters.resize(mapFilters_ptr_with_info->size()); 
     71      fieldsToFilters.clear(); 
     72      fields.clear(); 
     73      for (auto it=mapFilters_ptr_with_info->begin(); it != mapFilters_ptr_with_info->end(); it++) 
     74      { 
     75        filters[it->first]=it->second.filter_name; 
     76      } 
     77 
     78      // Create a list of fields and their filter connectivity (graph edges and edge-to-node connectivity) 
     79      for (auto it=mapFieldToFilters_ptr_with_info->begin(); it != mapFieldToFilters_ptr_with_info->end(); it++) 
     80      { 
     81        fieldsToFilters.push_back(make_pair(it->second.from,it->second.to)); 
     82        fields.push_back(it->second.field_id + " "+it->second.date.toString()); 
     83      } 
     84    } 
     85  } 
     86  CATCH 
     87 
     88 
     89 
    6090  void CWorkflowGraph::showStaticWorkflow() 
    6191  TRY 
    6292  { 
    63     if(mapFilters_ptr!=0 && !mapFilters_ptr->empty()) 
    64     for (auto it=mapFilters_ptr->begin(); it != mapFilters_ptr->end(); it++) 
     93    if(mapFilters_ptr_with_info!=0 && !mapFilters_ptr_with_info->empty()) 
     94    for (auto it=mapFilters_ptr_with_info->begin(); it != mapFilters_ptr_with_info->end(); it++) 
    6595    { 
    66       std::cout<<"mapFilters_ptr["<<it->first<<"]="<<it->second<<std::endl; 
     96      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].filter_name="<<it->second.filter_name<<std::endl; 
     97      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].filter_class="<<it->second.filter_class<<std::endl; 
     98      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].filter_fillled="<<it->second.filter_filled<<std::endl; 
     99      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].expected_entry_nb="<<it->second.expected_entry_nb<<std::endl; 
     100      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].date="<<it->second.date<<std::endl; 
     101      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].timestamp="<<it->second.timestamp<<std::endl; 
     102      std::cout<<"mapFilters_ptr_with_info["<<it->first<<"].transform_type="<<it->second.transform_type<<std::endl; 
    67103    } 
    68     else std::cout<<"mapFilters_ptr empty"<<std::endl; 
     104    else std::cout<<"mapFilters_ptr_with_info empty"<<std::endl; 
    69105 
    70     if(mapFieldToFilters_ptr!=0 && !mapFieldToFilters_ptr->empty()) 
    71     for (auto it=mapFieldToFilters_ptr->begin(); it != mapFieldToFilters_ptr->end(); it++) 
     106    if(mapFieldToFilters_ptr_with_info!=0 && !mapFieldToFilters_ptr_with_info->empty()) 
     107    for (auto it=mapFieldToFilters_ptr_with_info->begin(); it != mapFieldToFilters_ptr_with_info->end(); it++) 
    72108    { 
    73       for (size_t i = 0; i < it->second.size(); i++) 
    74       { 
    75         std::cout<<"mapFieldToFilters_ptr["<<it->first<<"]["<<i<<"] = "<<it->second[i]<<std::endl; 
    76       } 
     109      std::cout<<"mapFieldToFilters_ptr_with_info["<<it->first<<"].from = "<<it->second.from<<std::endl; 
     110      std::cout<<"mapFieldToFilters_ptr_with_info["<<it->first<<"].to = "<<it->second.to<<std::endl; 
     111      std::cout<<"mapFieldToFilters_ptr_with_info["<<it->first<<"].field_id = "<<it->second.field_id<<std::endl; 
     112      std::cout<<"mapFieldToFilters_ptr_with_info["<<it->first<<"].field_name = "<<it->second.field_name<<std::endl; 
     113      std::cout<<"mapFieldToFilters_ptr_with_info["<<it->first<<"].date = "<<it->second.date<<std::endl; 
     114       
    77115    } 
    78     else std::cout<<"mapFieldToFilters_ptr empty"<<mapFieldToFilters_ptr<<std::endl; 
     116    else std::cout<<"mapFieldToFilters_ptr_with_info empty"<<std::endl; 
    79117 
    80     /*if(mapFilterTimestamps_ptr!=0 && !mapFilterTimestamps_ptr->empty()) 
    81     for (auto it=mapFilterTimestamps_ptr->begin(); it != mapFilterTimestamps_ptr->end(); it++) 
    82     { 
    83       for (size_t i = 0; i < it->second.size(); i++) 
    84       { 
    85         std::cout<<"mapFilterTimestamps_ptr["<<it->first<<"]["<<i<<"] = "<<it->second[i]<<std::endl; 
    86       } 
    87     } 
    88     else std::cout<<"mapFilterTimestamps_ptr empty"<<std::endl; 
    89118 
    90     if(timestamps_ptr!=0 && !timestamps_ptr->empty()) 
    91     for (auto it=timestamps_ptr->begin(); it != timestamps_ptr->end(); it++) 
    92     { 
    93       std::cout<<"timestamps_ptr = "<<*it<<std::endl; 
    94     } 
    95     else std::cout<<"timestamps_ptr empty"<<std::endl; 
    96 */ 
     119  } 
     120  CATCH 
     121 
     122 
     123  void CWorkflowGraph::addEdge(int edgeID, int toID, CDataPacketPtr packet) 
     124  TRY 
     125  { 
     126    (*mapFieldToFilters_ptr_with_info)[edgeID].from = packet->src_filterID; 
     127    (*mapFieldToFilters_ptr_with_info)[edgeID].to = toID; 
     128    (*mapFieldToFilters_ptr_with_info)[edgeID].field_id = packet->field->getId(); 
     129    (*mapFieldToFilters_ptr_with_info)[edgeID].field_name = packet->field->name; 
     130    (*mapFieldToFilters_ptr_with_info)[edgeID].grid_id = packet->field->grid->getId(); 
     131    (*mapFieldToFilters_ptr_with_info)[edgeID].date = packet->date; 
     132    (*mapFieldToFilters_ptr_with_info)[edgeID].timestamp = packet->timestamp; 
    97133  } 
    98134  CATCH 

  • XIOS/dev/dev_trunk_omp/src/workflow_graph.hpp

    r1671 r1679  
    44#include "xios_spl.hpp" 
    55#include "field.hpp" 
     6#include "grid.hpp" 
    67#include "garbage_collector.hpp" 
     8#include "date.hpp" 
     9#include "duration.hpp" 
     10 
    711 
    812namespace xios 
    913{ 
     14 
     15  struct graph_info_box_node 
     16  { 
     17 
     18    StdString filter_name; 
     19    int filter_class; 
     20    bool filter_filled; 
     21    int expected_entry_nb; 
     22    CDate date; 
     23    Time timestamp; 
     24    StdString transform_type; 
     25  }; 
     26 
     27  struct graph_info_box_edge 
     28  { 
     29    int from; 
     30    int to; 
     31    StdString field_id; 
     32    StdString field_name; 
     33    StdString grid_id; 
     34    CDate date; 
     35    Time timestamp; 
     36     
     37  }; 
    1038 
    1139  class CWorkflowGraph 
    … …  
    2149       * It is filled up during reconstruction of a workflow (in function CField::buildFilterGraph()). 
    2250      */ 
    23       static std::unordered_map <StdString, vector <int> > *mapFieldToFilters_ptr; 
    24       #pragma omp threadprivate(mapFieldToFilters_ptr) 
     51      // static std::unordered_map <StdString, vector <int> > *mapFieldToFilters_ptr; 
     52      // #pragma omp threadprivate(mapFieldToFilters_ptr) 
    2553 
    26       /*! Map between filter ids and filter types. 
    27        * It is filled up during reconstruction of a workflow (in function CField::buildFilterGraph()). 
    28        */ 
    29       static std::unordered_map <int, StdString> *mapFilters_ptr; 
    30       #pragma omp threadprivate(mapFilters_ptr) 
    3154 
    32       /*! Map between filters and timestamps. 
    33        * Timestamps are added into the map at the exit of a filter (in function COutputPin::onOutputReady) 
    34        */ 
    35       static std::unordered_map <int, vector<Time> > *mapFilterTimestamps_ptr; 
    36       #pragma omp threadprivate(mapFilterTimestamps_ptr) 
    3755 
    38       /*! List of timestamps. 
    39        * Timestamps are added at the exit of a filter (in function COutputPin::onOutputReady) 
    40        */ 
    41       static set<Time> *timestamps_ptr; 
    42       #pragma omp threadprivate(timestamps_ptr) 
     56      static std::unordered_map <int, graph_info_box_node> *mapFilters_ptr_with_info; 
     57      #pragma omp threadprivate(mapFilters_ptr_with_info) 
     58 
     59      static std::unordered_map <int, graph_info_box_edge> *mapFieldToFilters_ptr_with_info; 
     60      #pragma omp threadprivate(mapFieldToFilters_ptr_with_info) 
     61 
     62 
     63      static bool build_begin; 
     64      #pragma omp threadprivate(build_begin) 
     65 
     66      static void addEdge(int edgeID, int toID, CDataPacketPtr packet); 
    4367 
    4468    private: 
    … …  
    5478 
    5579      static void buildStaticWorkflow(); 
     80      static void buildStaticWorkflow_with_info(); 
    5681      static void showStaticWorkflow(); 
     82 
     83       
    5784 
    5885 
Note: See TracChangeset for help on using the changeset viewer.