Line data    Source code

       1              : /**
       2              :  * @file TriggerDataHandlerModule.cpp TriggerDataHandlerModule class implementation
       3              :  *
       4              :  * This is part of the DUNE DAQ , copyright 2020.
       5              :  * Licensing/copyright details are in the COPYING file that you should have
       6              :  * received with this code.
       7              :  */
       8              : #include "TriggerDataHandlerModule.hpp"
       9              : 
      10              : #include "logging/Logging.hpp"
      11              : #include "iomanager/IOManager.hpp"
      12              : 
      13              : #include "datahandlinglibs/DataHandlingIssues.hpp"
      14              : #include "datahandlinglibs/ReadoutLogging.hpp"
      15              : #include "datahandlinglibs/models/DataHandlingModel.hpp"
      16              : #include "datahandlinglibs/models/SkipListLatencyBufferModel.hpp"
      17              : #include "datahandlinglibs/models/DefaultSkipListRequestHandler.hpp"
      18              : #include "trigger/TPRequestHandler.hpp"
      19              : 
      20              : #include "trigger/TriggerDataHandlingModel.hpp"
      21              : #include "trigger/TriggerPrimitiveTypeAdapter.hpp"
      22              : #include "trigger/TPProcessor.hpp"
      23              : #include "trigger/TAProcessor.hpp"
      24              : #include "trigger/TCProcessor.hpp"
      25              : 
      26              : 
      27              : #include <memory>
      28              : #include <sstream>
      29              : #include <string>
      30              : #include <vector>
      31              : 
      32              : using namespace dunedaq::datahandlinglibs::logging;
      33              : 
      34              : namespace dunedaq {
      35              : 
      36            0 : DUNE_DAQ_TYPESTRING(dunedaq::trigger::TriggerPrimitiveTypeAdapter, "TriggerPrimitive")
      37            0 : DUNE_DAQ_TYPESTRING(std::vector<dunedaq::trigger::TriggerPrimitiveTypeAdapter>, "TriggerPrimitiveVector")
      38              : DUNE_DAQ_TYPESTRING(dunedaq::trigger::TAWrapper, "TriggerActivity")
      39              : DUNE_DAQ_TYPESTRING(dunedaq::trigger::TCWrapper, "TriggerCandidate")
      40              : 
      41              : namespace trigger {
      42              : 
      43            0 : TriggerDataHandlerModule::TriggerDataHandlerModule(const std::string& name)
      44              :   : DAQModule(name)
      45            0 :   , RawDataHandlerBase(name)
      46              : { 
      47              :   //inherited_dlh::m_readout_creator = make_readout_creator("fd");
      48              : 
      49            0 :   inherited_mod::register_command("conf", &inherited_dlh::do_conf);
      50            0 :   inherited_mod::register_command("scrap", &inherited_dlh::do_scrap);
      51            0 :   inherited_mod::register_command("start", &inherited_dlh::do_start);
      52            0 :   inherited_mod::register_command("stop_trigger_sources", &inherited_dlh::do_stop);
      53            0 :   inherited_mod::register_command("record", &inherited_dlh::do_record);
      54            0 : }
      55              : 
      56              : void
      57            0 : TriggerDataHandlerModule::init(std::shared_ptr<appfwk::ConfigurationManager> cfg)
      58              : {
      59              : 
      60            0 :   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Entering init() method";
      61            0 :   inherited_dlh::init(cfg);
      62            0 :   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting init() method";
      63            0 : }
      64              : 
      65              : std::shared_ptr<datahandlinglibs::DataHandlingConcept>
      66            0 : TriggerDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf, std::atomic<bool>& run_marker)
      67              : {
      68            0 :   namespace rol = dunedaq::datahandlinglibs;
      69              : 
      70              :   // Acquire DataType  
      71            0 :   std::string raw_dt = modconf->get_module_configuration()->get_input_data_type();
      72            0 :   TLOG() << "Choosing specializations for DataHandlingModel with data_type:" << raw_dt << ']';
      73              : 
      74              :   // IF TriggerPrimitiveVector (TP vector)
      75            0 :   if (raw_dt.find("TriggerPrimitiveVector") != std::string::npos) {
      76            0 :     TLOG(TLVL_WORK_STEPS) << "Creating readout for TriggerPrimitiveVector";
      77            0 :     auto readout_model = std::make_shared<TriggerDataHandlingModel<
      78              :       TriggerPrimitiveTypeAdapter,
      79              :       TPRequestHandler,
      80              :       rol::SkipListLatencyBufferModel<TriggerPrimitiveTypeAdapter>,
      81              :       TPProcessor,
      82            0 :       std::vector<TriggerPrimitiveTypeAdapter>>>(run_marker);
      83            0 :     register_node("TPProcessor", readout_model); 
      84            0 :     readout_model->init(modconf);
      85            0 :     return readout_model;
      86            0 :   }  
      87              : 
      88              :   // IF TriggerPrimitive (TP)
      89            0 :   if (raw_dt.find("TriggerPrimitive") != std::string::npos) {
      90            0 :     TLOG(TLVL_WORK_STEPS) << "Creating readout for TriggerPrimitive";
      91            0 :     auto readout_model = std::make_shared<TriggerDataHandlingModel<
      92              :       TriggerPrimitiveTypeAdapter,
      93              :       TPRequestHandler,
      94              :       rol::SkipListLatencyBufferModel<TriggerPrimitiveTypeAdapter>,
      95            0 :       TPProcessor>>(run_marker);
      96            0 :     register_node("TPProcessor", readout_model); 
      97            0 :     readout_model->init(modconf);
      98            0 :     return readout_model;
      99            0 :   }
     100              : 
     101              :  // IF TriggerActivity (TA)
     102            0 :   if (raw_dt.find("TriggerActivity") != std::string::npos) {
     103            0 :     TLOG(TLVL_WORK_STEPS) << "Creating readout for TriggerActivity";
     104            0 :     auto readout_model = std::make_shared<TriggerDataHandlingModel<
     105              :       TAWrapper,
     106              :       rol::DefaultSkipListRequestHandler<trigger::TAWrapper>,
     107              :       rol::SkipListLatencyBufferModel<trigger::TAWrapper>,
     108              :       TAProcessor,
     109            0 :       triggeralgs::TriggerActivity>>(run_marker);
     110            0 :     register_node("TAProcessor", readout_model); 
     111              :     
     112            0 :     readout_model->init(modconf);
     113            0 :     return readout_model;
     114            0 :   }
     115              : 
     116              :  // No processing, only buffering to respond to data requests
     117            0 :   if (raw_dt.find("TriggerCandidate") != std::string::npos) {
     118            0 :     TLOG(TLVL_WORK_STEPS) << "Creating readout for TriggerCandidate";
     119            0 :     auto readout_model = std::make_shared<TriggerDataHandlingModel<
     120              :       TCWrapper,
     121              :       rol::DefaultSkipListRequestHandler<trigger::TCWrapper>,
     122              :       rol::SkipListLatencyBufferModel<trigger::TCWrapper>,
     123              :       TCProcessor,
     124            0 :       triggeralgs::TriggerCandidate>>(run_marker);
     125            0 :     register_node("TCProcessor", readout_model); 
     126              :     
     127            0 :     readout_model->init(modconf);
     128            0 :     return readout_model;
     129            0 :   }
     130              : 
     131            0 :   return nullptr;
     132            0 : }
     133              : 
     134              : } // namespace trigger
     135              : } // namespace dunedaq
     136              : 
     137            0 : DEFINE_DUNE_DAQ_MODULE(dunedaq::trigger::TriggerDataHandlerModule)