dunedaq::trigger::HSISourceModel Class Reference

#include <HSISourceModel.hpp>

Inheritance diagram for dunedaq::trigger::HSISourceModel:

Collaboration diagram for dunedaq::trigger::HSISourceModel:

Public Types
using	inherited = datahandlinglibs::SourceConcept
Public Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string

Public Member Functions
	HSISourceModel ()
	SourceModel Constructor.
	~HSISourceModel () override
void	init (const confmodel::DaqModule *cfg) override
void	start ()
void	stop ()
bool	handle_payload (dfmessages::HSIEvent &data)
void	generate_opmon_data () override
void	print_opmon_stats ()
Public Member Functions inherited from dunedaq::datahandlinglibs::SourceConcept
	SourceConcept ()
virtual	~SourceConcept ()
	SourceConcept (const SourceConcept &)=delete
	SourceConcept is not copy-constructible.
SourceConcept &	operator= (const SourceConcept &)=delete
	SourceConcept is not copy-assginable.
	SourceConcept (SourceConcept &&)=delete
	SourceConcept is not move-constructible.
SourceConcept &	operator= (SourceConcept &&)=delete
	SourceConcept is not move-assignable.
Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject (const MonitorableObject &)=delete
MonitorableObject &	operator= (const MonitorableObject &)=delete
	MonitorableObject (MonitorableObject &&)=delete
MonitorableObject &	operator= (MonitorableObject &&)=delete
virtual	~MonitorableObject ()=default
auto	get_opmon_id () const noexcept
auto	get_opmon_level () const noexcept

Private Types
using	source_t = dunedaq::iomanager::ReceiverConcept<dfmessages::HSIEvent>
using	sink_t = dunedaq::iomanager::SenderConcept<triggeralgs::TriggerCandidate>
using	metric_counter_type = uint64_t

Private Attributes
std::shared_ptr< source_t >	m_data_receiver
std::shared_ptr< sink_t >	m_data_sender
std::map< uint32_t, HSISignal >	m_signals
	map of HSI signal ID bits to TC output configurations
std::atomic< metric_counter_type >	m_received_events_count { 0 }
std::atomic< metric_counter_type >	m_tcs_made_count { 0 }
std::atomic< metric_counter_type >	m_tcs_sent_count { 0 }
std::atomic< metric_counter_type >	m_tcs_dropped_count { 0 }
uint64_t	m_prescale
	{rescale for the input HSIEvents, default 1
std::atomic< bool >	m_running_flag { false }
std::atomic< bool >	m_latency_monitoring { false }
dunedaq::trigger::Latency	m_latency_instance
std::atomic< metric_counter_type >	m_latency_in { 0 }
std::atomic< metric_counter_type >	m_latency_out { 0 }

Additional Inherited Members
Static Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept
Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject ()=default
void	register_node (ElementId name, NewNodePtr)
void	publish (google::protobuf::Message &&, CustomOrigin &&co={}, OpMonLevel l=to_level(EntryOpMonLevel::kDefault)) const noexcept

Detailed Description

Definition at line 44 of file HSISourceModel.hpp.

Member Typedef Documentation

inherited

using dunedaq::trigger::HSISourceModel::inherited = datahandlinglibs::SourceConcept

Definition at line 47 of file HSISourceModel.hpp.

metric_counter_type

using dunedaq::trigger::HSISourceModel::metric_counter_type = uint64_t

private

Definition at line 228 of file HSISourceModel.hpp.

sink_t

using dunedaq::trigger::HSISourceModel::sink_t = dunedaq::iomanager::SenderConcept<triggeralgs::TriggerCandidate>

private

Definition at line 221 of file HSISourceModel.hpp.

source_t

using dunedaq::trigger::HSISourceModel::source_t = dunedaq::iomanager::ReceiverConcept<dfmessages::HSIEvent>

private

Definition at line 218 of file HSISourceModel.hpp.

Constructor & Destructor Documentation

HSISourceModel()

dunedaq::trigger::HSISourceModel::HSISourceModel ( )

inline

SourceModel Constructor.

Parameters

name	Instance name for this SourceModel instance

Definition at line 53 of file HSISourceModel.hpp.

    : datahandlinglibs::SourceConcept()
  {
  }

~HSISourceModel()

dunedaq::trigger::HSISourceModel::~HSISourceModel ( )

inlineoverride

Definition at line 57 of file HSISourceModel.hpp.

  {
    m_data_receiver.reset();
    m_data_sender.reset();
    m_signals.clear();
  }

Member Function Documentation

generate_opmon_data()

void dunedaq::trigger::HSISourceModel::generate_opmon_data ( )

inlineoverridevirtual

Hook for customisable pubblication. The function can throw, exception will be caught by the monitoring thread

Reimplemented from dunedaq::opmonlib::MonitorableObject.

Definition at line 185 of file HSISourceModel.hpp.

  {
    opmon::HSISourceModelInfo info;
 
    info.set_received_events_count(m_received_events_count);
    info.set_tcs_made_count(m_tcs_made_count);
    info.set_tcs_sent_count(m_tcs_sent_count);
    info.set_tcs_dropped_count(m_tcs_dropped_count);
 
    this->publish(std::move(info));
 
    if (m_latency_monitoring.load() && m_running_flag.load()) {
      opmon::TriggerLatency lat_info;
 
      lat_info.set_latency_in(m_latency_instance.get_latency_in());
      lat_info.set_latency_out(m_latency_instance.get_latency_out());
 
      this->publish(std::move(lat_info));
    }
  }

handle_payload()

bool dunedaq::trigger::HSISourceModel::handle_payload ( dfmessages::HSIEvent & data )

inline

Definition at line 132 of file HSISourceModel.hpp.

  {
    m_received_events_count++;
    if (m_latency_monitoring.load())
      m_latency_instance.update_latency_in(data.timestamp);
 
    // Prescale after n-hsi received
    if (m_received_events_count % m_prescale != 0) {
      return true;
    }
 
    TLOG_DEBUG(1) << "Received HSIEvent with signal map " << data.signal_map << " and timestamp " << data.timestamp;
 
    // Iterate over all the signals
    uint32_t signal_map = data.signal_map;
    while (signal_map) {
      // Get the index of the least significant bit
      int bit_index = __builtin_ctzll(signal_map);
      uint32_t signal = 1 << bit_index;
 
      // Throw an error if we don't have this signal bit configured
      if (!m_signals.count(signal)) {
        throw dunedaq::trigger::SignalTypeError(ERS_HERE, "HSI subscriber", data.signal_map);
      }
 
      // Create the trigger candidate
      triggeralgs::TriggerCandidate candidate;
      candidate.time_start = data.timestamp - m_signals[signal].time_before;
      candidate.time_end = data.timestamp + m_signals[signal].time_after;
      candidate.time_candidate = data.timestamp;
      // throw away bits 31-16 of header, that's OK for now
      candidate.detid = (uint)detdataformats::DetID::Subdetector::kDAQ; // NOLINT(build/unsigned)
      candidate.type = m_signals[signal].type;
      candidate.algorithm = triggeralgs::TriggerCandidate::Algorithm::kHSIEventToTriggerCandidate;
      candidate.inputs = {};
      m_tcs_made_count++;
 
      if (m_latency_monitoring.load())
        m_latency_instance.update_latency_out(candidate.time_candidate);
      // Send the TC
      if (!m_data_sender->try_send(std::move(candidate), iomanager::Sender::s_no_block)) {
        m_tcs_dropped_count++;
      } else {
        m_tcs_sent_count++;
      }
 
      // Clear the least significant bit
      signal_map &= signal_map - 1;
    }
 
    return true;
  }

init()

void dunedaq::trigger::HSISourceModel::init ( const confmodel::DaqModule * cfg )

inlineoverridevirtual

Implements dunedaq::datahandlinglibs::SourceConcept.

Definition at line 64 of file HSISourceModel.hpp.

  {
    if (cfg->get_outputs().size() != 1) {
      throw datahandlinglibs::InitializationError(ERS_HERE, "Only 1 output supported for subscribers");
    }
    m_data_sender = get_iom_sender<triggeralgs::TriggerCandidate>(cfg->get_outputs()[0]->UID());
 
    if (cfg->get_inputs().size() != 1) {
      throw datahandlinglibs::InitializationError(ERS_HERE, "Only 1 input supported for subscribers");
    }
    m_data_receiver = get_iom_receiver<dfmessages::HSIEvent>(cfg->get_inputs()[0]->UID());
    auto data_reader = cfg->cast<appmodel::DataSubscriberModule>();
    if (data_reader == nullptr) {
      throw datahandlinglibs::InitializationError(ERS_HERE, "DAQ module is not a DataReader");
    }
    auto hsi_conf = data_reader->get_configuration()->cast<appmodel::HSI2TCTranslatorConf>();
    if (hsi_conf == nullptr) {
      throw datahandlinglibs::InitializationError(ERS_HERE, "Missing HSI2TCTranslatorConf");
    }
 
    // Get the HSI-signal to TC-output map
    for (auto win : hsi_conf->get_signals()) {
      triggeralgs::TriggerCandidate::Type tc_type;
      tc_type = static_cast<triggeralgs::TriggerCandidate::Type>(
        dunedaq::trgdataformats::string_to_trigger_candidate_type(win->get_tc_type_name()));
 
      // Throw error if unknown TC type
      if (tc_type == triggeralgs::TriggerCandidate::Type::kUnknown) {
        throw datahandlinglibs::InitializationError(ERS_HERE, "Provided an unknown TC type output to HSISourceModel");
      }
 
      // Throw error if already exists
      uint32_t signal = win->get_signal_type();
      if (m_signals.count(signal)) {
        throw datahandlinglibs::InitializationError(
          ERS_HERE, "Provided more than one of the same HSI signal ID input to HSISourceModel");
      }
 
      // Fill the signal-tctype map
      m_signals[signal] = { tc_type, win->get_time_before(), win->get_time_after() };
 
      TLOG() << "Will cover HSI signal id: " << signal << " to TC type: " << win->get_tc_type_name()
             << " window before: " << win->get_time_before() << " window after: " << win->get_time_after();
    }
 
    m_prescale = hsi_conf->get_prescale();
    m_latency_monitoring.store(hsi_conf->get_latency_monitoring());
  }

print_opmon_stats()

void dunedaq::trigger::HSISourceModel::print_opmon_stats ( )

inline

Definition at line 206 of file HSISourceModel.hpp.

  {
    TLOG() << "HSI Source Model opmon counters summary:";
    TLOG() << "------------------------------";
    TLOG() << "Signals received: \t" << m_received_events_count;
    TLOG() << "TCs made: \t\t" << m_tcs_made_count;
    TLOG() << "TCs sent: \t\t" << m_tcs_sent_count;
    TLOG() << "TCs dropped: \t\t" << m_tcs_dropped_count;
    TLOG();
  }

start()

void dunedaq::trigger::HSISourceModel::start ( )

inlinevirtual

Implements dunedaq::datahandlinglibs::SourceConcept.

Definition at line 113 of file HSISourceModel.hpp.

  {
    m_data_receiver->add_callback(std::bind(&HSISourceModel::handle_payload, this, std::placeholders::_1));
 
    m_running_flag.store(true);
 
    m_received_events_count.store(0);
    m_tcs_made_count.store(0);
    m_tcs_sent_count.store(0);
    m_tcs_dropped_count.store(0);
  }

stop()

void dunedaq::trigger::HSISourceModel::stop ( )

inlinevirtual

Implements dunedaq::datahandlinglibs::SourceConcept.

Definition at line 125 of file HSISourceModel.hpp.

  {
    m_data_receiver->remove_callback();
    m_running_flag.store(false);
    print_opmon_stats();
  }

Member Data Documentation

m_data_receiver

std::shared_ptr<source_t> dunedaq::trigger::HSISourceModel::m_data_receiver

private

Definition at line 219 of file HSISourceModel.hpp.

m_data_sender

std::shared_ptr<sink_t> dunedaq::trigger::HSISourceModel::m_data_sender

private

Definition at line 222 of file HSISourceModel.hpp.

m_latency_in

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_latency_in { 0 }

private

Definition at line 241 of file HSISourceModel.hpp.

m_latency_instance

dunedaq::trigger::Latency dunedaq::trigger::HSISourceModel::m_latency_instance

private

Definition at line 240 of file HSISourceModel.hpp.

m_latency_monitoring

std::atomic<bool> dunedaq::trigger::HSISourceModel::m_latency_monitoring { false }

private

Definition at line 239 of file HSISourceModel.hpp.

m_latency_out

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_latency_out { 0 }

private

Definition at line 242 of file HSISourceModel.hpp.

m_prescale

uint64_t dunedaq::trigger::HSISourceModel::m_prescale

private

{rescale for the input HSIEvents, default 1

Definition at line 235 of file HSISourceModel.hpp.

m_received_events_count

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_received_events_count { 0 }

private

Definition at line 229 of file HSISourceModel.hpp.

m_running_flag

std::atomic<bool> dunedaq::trigger::HSISourceModel::m_running_flag { false }

private

Definition at line 238 of file HSISourceModel.hpp.

m_signals

std::map<uint32_t, HSISignal> dunedaq::trigger::HSISourceModel::m_signals

private

map of HSI signal ID bits to TC output configurations

Definition at line 225 of file HSISourceModel.hpp.

m_tcs_dropped_count

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_tcs_dropped_count { 0 }

private

Definition at line 232 of file HSISourceModel.hpp.

m_tcs_made_count

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_tcs_made_count { 0 }

private

Definition at line 230 of file HSISourceModel.hpp.

m_tcs_sent_count

std::atomic<metric_counter_type> dunedaq::trigger::HSISourceModel::m_tcs_sent_count { 0 }

private

Definition at line 231 of file HSISourceModel.hpp.

---

The documentation for this class was generated from the following file:

• /github/workspace/dunedaq/sourcecode/trigger/src/trigger/HSISourceModel.hpp