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