dunedaq::trigger::TCProcessor Class Reference

#include <TCProcessor.hpp>

Inheritance diagram for dunedaq::trigger::TCProcessor:

Collaboration diagram for dunedaq::trigger::TCProcessor:

Classes
struct	PendingTD
struct	roi_group

Public Types
using	inherited = datahandlinglibs::TaskRawDataProcessorModel<TCWrapper>
using	tcptr = TCWrapper*
using	consttcptr = const TCWrapper*
using	TCType = triggeralgs::TriggerCandidate::Type
using	TDBitset = std::bitset<64>
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
	TCProcessor (std::unique_ptr< datahandlinglibs::FrameErrorRegistry > &error_registry, bool post_processing_enabled)
	~TCProcessor ()
void	start (const nlohmann::json &args) override
	Start operation.
void	stop (const nlohmann::json &args) override
	Stop operation.
void	conf (const appmodel::DataHandlerModule *conf) override
	Set the emulator mode, if active, timestamps of processed packets are overwritten with new ones.
void	scrap (const nlohmann::json &args) override
	Unconfigure.
void	generate_opmon_data () override
Public Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >
	TaskRawDataProcessorModel (std::unique_ptr< FrameErrorRegistry > &error_registry, bool post_processing_enabled)
	~TaskRawDataProcessorModel ()
void	reset_last_daq_time ()
std::uint64_t	get_last_daq_time () override
	Get newest timestamp of last seen packet.
void	preprocess_item (TCWrapper *item) override
	Preprocess one element.
void	postprocess_item (const TCWrapper *item) override
	Postprocess one element.
void	add_preprocess_task (Task &&task)
void	add_postprocess_task (Task &&task)
void	invoke_all_preprocess_functions (TCWrapper *item)
void	launch_all_preprocess_functions (TCWrapper *item)
Public Member Functions inherited from dunedaq::datahandlinglibs::RawDataProcessorConcept< TCWrapper >
	RawDataProcessorConcept ()
	RawDataProcessorConcept (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-constructible.
	RawDataProcessorConcept (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept is not move-constructible.
virtual	~RawDataProcessorConcept ()
RawDataProcessorConcept &	operator= (const RawDataProcessorConcept &)=delete
	RawDataProcessorConcept is not copy-assginable.
RawDataProcessorConcept &	operator= (RawDataProcessorConcept &&)=delete
	RawDataProcessorConcept 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

Protected Member Functions
void	make_td (const TCWrapper *tc)
Protected Member Functions inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >
void	run_post_processing_thread (std::function< void(const TCWrapper *)> &function, folly::ProducerConsumerQueue< const TCWrapper * > &queue)
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

Private Types
using	metric_counter_type = uint64_t

Private Member Functions
void	send_trigger_decisions ()
void	parse_group_links (const nlohmann::json &data)
void	print_group_links ()
dfmessages::ComponentRequest	create_request_for_link (daqdataformats::SourceID link, triggeralgs::timestamp_t start, triggeralgs::timestamp_t end)
std::vector< dfmessages::ComponentRequest >	create_all_decision_requests (std::vector< daqdataformats::SourceID > links, triggeralgs::timestamp_t start, triggeralgs::timestamp_t end)
void	add_requests_to_decision (dfmessages::TriggerDecision &decision, std::vector< dfmessages::ComponentRequest > requests)
void	parse_roi_conf (const std::vector< const appmodel::ROIGroupConf * > &data)
void	print_roi_conf (std::map< int, roi_group > roi_conf)
float	get_random_num_float (float limit)
int	get_random_num_int ()
int	pick_roi_group_conf ()
void	roi_readout_make_requests (dfmessages::TriggerDecision &decision)
void	add_tc (const triggeralgs::TriggerCandidate tc)
void	add_tc_ignored (const triggeralgs::TriggerCandidate tc)
void	call_tc_decision (const PendingTD &pending_td)
bool	check_overlap (const triggeralgs::TriggerCandidate &tc, const PendingTD &pending_td)
bool	check_td_readout_length (const PendingTD &)
void	clear_td_vectors ()
std::vector< PendingTD >	get_ready_tds (std::vector< PendingTD > &pending_tds)
int	get_earliest_tc_index (const PendingTD &pending_td)
TDBitset	get_TD_bitword (const PendingTD &ready_td) const
void	print_trigger_bitwords ()
bool	check_trigger_bitwords (const TDBitset &td_bitword) const
void	set_trigger_bitwords (const std::vector< const appmodel::TriggerBitword * > &_bitwords)
void	parse_readout_map (const std::vector< const appmodel::TCReadoutMap * > &data)
void	print_readout_map (std::map< TCType, std::pair< triggeralgs::timestamp_t, triggeralgs::timestamp_t > > map)
dfmessages::TriggerDecision	create_decision (const PendingTD &pending_td)
bool	check_trigger_type_ignore (unsigned int tc_type)
void	print_opmon_stats ()

Private Attributes
std::thread	m_send_trigger_decisions_thread
std::vector< daqdataformats::SourceID >	m_mandatory_links
std::map< int, std::vector< daqdataformats::SourceID > >	m_group_links
nlohmann::json	m_group_links_data
int	m_total_group_links
bool	m_use_roi_readout
std::map< int, roi_group >	m_roi_conf
std::vector< const appmodel::ROIGroupConf * >	m_roi_conf_data
std::vector< int >	m_roi_conf_ids
std::vector< float >	m_roi_conf_probs
std::vector< float >	m_roi_conf_probs_c
int	m_repeat_trigger_count { 1 }
std::atomic< bool >	m_tc_merging
bool	m_ignore_tc_pileup
	Ignore TCs that overlap with already made TD.
dfmessages::trigger_number_t	m_last_trigger_number
dfmessages::run_number_t	m_run_number
std::atomic< bool >	m_running_flag { false }
std::vector< PendingTD >	m_pending_tds
std::mutex	m_td_vector_mutex
std::condition_variable	m_cv
int64_t	m_buffer_timeout
int64_t	m_td_readout_limit
std::atomic< bool >	m_send_timed_out_tds
int	m_earliest_tc_index
bool	m_use_bitwords
std::vector< TDBitset >	m_trigger_bitwords
bool	m_use_readout_map
std::vector< const appmodel::TCReadoutMap * >	m_readout_window_map_data
std::map< TCType, std::pair< triggeralgs::timestamp_t, triggeralgs::timestamp_t > >	m_readout_window_map
dfmessages::trigger_type_t	m_trigger_type_shifted
std::vector< unsigned int >	m_ignored_tc_types
bool	m_ignoring_tc_types
std::shared_ptr< iomanager::SenderConcept< dfmessages::TriggerDecision > >	m_td_sink
std::atomic< metric_counter_type >	m_tds_created_count { 0 }
std::atomic< metric_counter_type >	m_tds_sent_count { 0 }
std::atomic< metric_counter_type >	m_tds_dropped_count { 0 }
std::atomic< metric_counter_type >	m_tds_failed_bitword_count { 0 }
std::atomic< metric_counter_type >	m_tds_cleared_count { 0 }
std::atomic< metric_counter_type >	m_tc_received_count { 0 }
std::atomic< metric_counter_type >	m_tds_created_tc_count { 0 }
std::atomic< metric_counter_type >	m_tds_sent_tc_count { 0 }
std::atomic< metric_counter_type >	m_tds_dropped_tc_count { 0 }
std::atomic< metric_counter_type >	m_tds_failed_bitword_tc_count { 0 }
std::atomic< metric_counter_type >	m_tds_cleared_tc_count { 0 }
std::atomic< metric_counter_type >	m_tc_ignored_count { 0 }
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 Attributes inherited from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >
std::vector< std::function< void(TCWrapper *)> >	m_preprocess_functions
std::unique_ptr< FrameErrorRegistry > &	m_error_registry
bool	m_post_processing_enabled
std::atomic< bool >	m_run_marker
std::vector< std::function< void(const TCWrapper *)> >	m_post_process_functions
std::vector< std::unique_ptr< folly::ProducerConsumerQueue< const TCWrapper * > > >	m_items_to_postprocess_queues
std::vector< std::unique_ptr< utilities::ReusableThread > >	m_post_process_threads
size_t	m_postprocess_queue_sizes
daqdataformats::SourceID	m_sourceid
std::atomic< uint64_t >	m_last_processed_daq_ts

Detailed Description

Definition at line 40 of file TCProcessor.hpp.

Member Typedef Documentation

consttcptr

using dunedaq::trigger::TCProcessor::consttcptr = const TCWrapper*

Definition at line 46 of file TCProcessor.hpp.

inherited

using dunedaq::trigger::TCProcessor::inherited = datahandlinglibs::TaskRawDataProcessorModel<TCWrapper>

Definition at line 44 of file TCProcessor.hpp.

metric_counter_type

using dunedaq::trigger::TCProcessor::metric_counter_type = uint64_t

private

Definition at line 179 of file TCProcessor.hpp.

tcptr

using dunedaq::trigger::TCProcessor::tcptr = TCWrapper*

Definition at line 45 of file TCProcessor.hpp.

TCType

using dunedaq::trigger::TCProcessor::TCType = triggeralgs::TriggerCandidate::Type

Definition at line 47 of file TCProcessor.hpp.

TDBitset

using dunedaq::trigger::TCProcessor::TDBitset = std::bitset<64>

Definition at line 48 of file TCProcessor.hpp.

Constructor & Destructor Documentation

TCProcessor()

dunedaq::trigger::TCProcessor::TCProcessor ( std::unique_ptr< datahandlinglibs::FrameErrorRegistry > & error_registry, bool post_processing_enabled )

explicit

Definition at line 32 of file TCProcessor.cpp.

  : datahandlinglibs::TaskRawDataProcessorModel<TCWrapper>(error_registry, post_processing_enabled)
{
}

~TCProcessor()

dunedaq::trigger::TCProcessor::~TCProcessor

(

)

Definition at line 37 of file TCProcessor.cpp.

{}

Member Function Documentation

add_requests_to_decision()

void dunedaq::trigger::TCProcessor::add_requests_to_decision ( dfmessages::TriggerDecision & decision, std::vector< dfmessages::ComponentRequest > requests )

private

Definition at line 714 of file TCProcessor.cpp.

{
  for (auto request : requests) {
    decision.components.push_back(request);
  }
}

add_tc()

void dunedaq::trigger::TCProcessor::add_tc ( const triggeralgs::TriggerCandidate tc )

private

Definition at line 401 of file TCProcessor.cpp.

{
  bool tc_dealt = false;
  int64_t tc_wallclock_arrived =
    std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
 
  if (m_tc_merging || m_ignore_tc_pileup) {
 
    for (std::vector<PendingTD>::iterator it = m_pending_tds.begin(); it != m_pending_tds.end();) {
      // Don't deal with TC here if there's no overlap
      if (!check_overlap(tc, *it)) {
        it++;
        continue;
      }
 
      // If overlap and ignoring, we drop the TC and flag it as dealt with.
      if (m_ignore_tc_pileup) {
        m_tds_dropped_tc_count++;
        tc_dealt = true;
        TLOG_DEBUG(3) << "TC overlapping with a previous TD, dropping!";
        break;
      }
 
      // If we're here, TC merging must be on, in which case we're actually
      // going to merge the TC into the TD.    
      it->contributing_tcs.push_back(tc);
      if ( (m_use_readout_map) && (m_readout_window_map.count(tc.type)) ){
        TLOG_DEBUG(3) << "TC with start/end times " << tc.time_candidate - m_readout_window_map[tc.type].first << "/"
                      << tc.time_candidate + m_readout_window_map[tc.type].second
                      << " overlaps with pending TD with start/end times " << it->readout_start << "/"
                      << it->readout_end;
        it->readout_start = ((tc.time_candidate - m_readout_window_map[tc.type].first) >= it->readout_start)
                              ? it->readout_start
                              : (tc.time_candidate - m_readout_window_map[tc.type].first);
        it->readout_end = ((tc.time_candidate + m_readout_window_map[tc.type].second) >= it->readout_end)
                            ? (tc.time_candidate + m_readout_window_map[tc.type].second)
                            : it->readout_end;
      } else {
        TLOG_DEBUG(3) << "TC with start/end times " << tc.time_start << "/" << tc.time_end
                      << " overlaps with pending TD with start/end times " << it->readout_start << "/"
                      << it->readout_end;
        it->readout_start = (tc.time_start >= it->readout_start) ? it->readout_start : tc.time_start;
        it->readout_end = (tc.time_end >= it->readout_end) ? tc.time_end : it->readout_end;
      }
      it->walltime_expiration = tc_wallclock_arrived + m_buffer_timeout;
      tc_dealt = true;
      break;
    }
  }
 
  // Don't do anything else if we've already dealt with the TC
  if (tc_dealt) {
    return;
  }
 
  // Create a new TD out of the TC
  PendingTD td_candidate;
  td_candidate.contributing_tcs.push_back(tc);
  if ( (m_use_readout_map) && (m_readout_window_map.count(tc.type)) ){
    td_candidate.readout_start = tc.time_candidate - m_readout_window_map[tc.type].first;
    td_candidate.readout_end = tc.time_candidate + m_readout_window_map[tc.type].second;
  } else {
    td_candidate.readout_start = tc.time_start;
    td_candidate.readout_end = tc.time_end;
  }
  td_candidate.walltime_expiration = tc_wallclock_arrived + m_buffer_timeout;
  m_pending_tds.push_back(td_candidate);
}

add_tc_ignored()

void dunedaq::trigger::TCProcessor::add_tc_ignored ( const triggeralgs::TriggerCandidate tc )

private

Definition at line 471 of file TCProcessor.cpp.

{
  for (std::vector<PendingTD>::iterator it = m_pending_tds.begin(); it != m_pending_tds.end();) {
    if (check_overlap(tc, *it)) {
      if ( (m_use_readout_map) && (m_readout_window_map.count(tc.type)) ) {
        TLOG_DEBUG(3) << "!Ignored! TC with start/end times " << tc.time_candidate - m_readout_window_map[tc.type].first
                      << "/" << tc.time_candidate + m_readout_window_map[tc.type].second
                      << " overlaps with pending TD with start/end times " << it->readout_start << "/"
                      << it->readout_end;
      } else {
        TLOG_DEBUG(3) << "!Ignored! TC with start/end times " << tc.time_start << "/" << tc.time_end
                      << " overlaps with pending TD with start/end times " << it->readout_start << "/"
                      << it->readout_end;
      }
      it->contributing_tcs.push_back(tc);
      break;
    }
    ++it;
  }
  return;
}

call_tc_decision()

void dunedaq::trigger::TCProcessor::call_tc_decision ( const PendingTD & pending_td )

private

Definition at line 369 of file TCProcessor.cpp.

{
 
  if (m_use_bitwords) {
    // Check trigger bitwords
    TDBitset td_bitword = get_TD_bitword(pending_td);
    if (!check_trigger_bitwords(td_bitword)) {
      // Don't process further if the bitword check failed
      m_tds_failed_bitword_count++;
      m_tds_failed_bitword_tc_count += pending_td.contributing_tcs.size();
      return;
    }
  }
 
  dfmessages::TriggerDecision decision = create_decision(pending_td);
  auto tn = decision.trigger_number;
  auto td_ts = decision.trigger_timestamp;
 
  if (m_latency_monitoring.load()) m_latency_instance.update_latency_out( pending_td.contributing_tcs.front().time_start );
  if(!m_td_sink->try_send(std::move(decision), iomanager::Sender::s_no_block)) {
    ers::warning(TDDropped(ERS_HERE, tn, td_ts));
    m_tds_dropped_count++;
    m_tds_dropped_tc_count += pending_td.contributing_tcs.size();
  }
  else {
    m_tds_sent_count++;
    m_tds_sent_tc_count += pending_td.contributing_tcs.size();
  }
}

check_overlap()

bool dunedaq::trigger::TCProcessor::check_overlap ( const triggeralgs::TriggerCandidate & tc, const PendingTD & pending_td )

private

Definition at line 494 of file TCProcessor.cpp.

{
  if ( (m_use_readout_map) && (m_readout_window_map.count(tc.type)) ) {
    return !(((tc.time_candidate + m_readout_window_map[tc.type].second) < pending_td.readout_start) ||
             ((tc.time_candidate - m_readout_window_map[tc.type].first > pending_td.readout_end)));
  } else {
    return !((tc.time_end < pending_td.readout_start) || (tc.time_start > pending_td.readout_end));
  }
}

check_td_readout_length()

bool dunedaq::trigger::TCProcessor::check_td_readout_length ( const PendingTD & pending_td )

private

Definition at line 544 of file TCProcessor.cpp.

{
  bool td_too_long = false;
  if (static_cast<int64_t>(pending_td.readout_end - pending_td.readout_start) >= m_td_readout_limit) {
    td_too_long = true;
    TLOG_DEBUG(3) << "Too long readout window: " << (pending_td.readout_end - pending_td.readout_start)
                  << ", sending immediate TD!";
  }
  return td_too_long;
}

check_trigger_bitwords()

bool dunedaq::trigger::TCProcessor::check_trigger_bitwords ( const TDBitset & td_bitword ) const

private

Definition at line 594 of file TCProcessor.cpp.

{
  bool trigger_check = false;
  for (const auto& bitword : m_trigger_bitwords) {
    TLOG_DEBUG(15) << "TD word: " << td_bitword << ", bitword: " << bitword;
    trigger_check = ((td_bitword & bitword) == bitword);
    TLOG_DEBUG(15) << "&: " << (td_bitword & bitword);
    TLOG_DEBUG(15) << "trigger?: " << trigger_check;
    if (trigger_check == true)
      break;
  }
  return trigger_check;
}

check_trigger_type_ignore()

bool dunedaq::trigger::TCProcessor::check_trigger_type_ignore ( unsigned int tc_type )

private

Definition at line 571 of file TCProcessor.cpp.

{
  bool ignore = false;
  for (std::vector<unsigned int>::iterator it = m_ignored_tc_types.begin(); it != m_ignored_tc_types.end();) {
    if (tc_type == *it) {
      ignore = true;
      break;
    }
    ++it;
  }
  return ignore;
}

clear_td_vectors()

void dunedaq::trigger::TCProcessor::clear_td_vectors ( )

private

Definition at line 556 of file TCProcessor.cpp.

{
  std::lock_guard<std::mutex> lock(m_td_vector_mutex);
  m_tds_cleared_count += m_pending_tds.size();
  // Use std::accumulate to sum up the sizes of all contributing_tcs vectors
  size_t tds_cleared_tc_count = std::accumulate(
    m_pending_tds.begin(), m_pending_tds.end(), 0,
    [](size_t sum, const PendingTD& ptd) {
      return sum + ptd.contributing_tcs.size();
    }
  );
  m_tds_cleared_tc_count += tds_cleared_tc_count;
  m_pending_tds.clear();
}

conf()

void dunedaq::trigger::TCProcessor::conf ( const appmodel::DataHandlerModule * conf )

overridevirtual

Set the emulator mode, if active, timestamps of processed packets are overwritten with new ones.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >.

Definition at line 96 of file TCProcessor.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Entering conf() method";
 
  auto mtrg = cfg->cast<appmodel::TriggerDataHandlerModule>();  
  if (mtrg == nullptr) {
    throw(InvalidConfiguration(ERS_HERE, "Provided null TriggerDataHandlerModule configuration!"));
  }
  for (auto output : mtrg->get_outputs()) {
   try {
      if (output->get_data_type() == "TriggerDecision") {
         m_td_sink = get_iom_sender<dfmessages::TriggerDecision>(output->UID());
      }
    } catch (const ers::Issue& excpt) {
      ers::error(datahandlinglibs::ResourceQueueError(ERS_HERE, "td", "DefaultRequestHandlerModel", excpt));
    }
  }
 
  auto dp = mtrg->get_module_configuration()->get_data_processor();
  auto proc_conf = dp->cast<appmodel::TCDataProcessor>();
 
  // Add all Source IDs to mandatoy links for now...
  for(auto const& link : mtrg->get_mandatory_source_ids()){
    m_mandatory_links.push_back(
        dfmessages::SourceID{
        daqdataformats::SourceID::string_to_subsystem(link->get_subsystem()),
        link->get_sid()});
  }  
  for(auto const& link : mtrg->get_enabled_source_ids()){
    m_mandatory_links.push_back(
        dfmessages::SourceID{
        daqdataformats::SourceID::string_to_subsystem(link->get_subsystem()),
        link->get_sid()});
  }
 
  // TODO: Group links!
  //m_group_links_data = conf->get_groups_links();
  parse_group_links(m_group_links_data);
  print_group_links();
  m_total_group_links = m_group_links.size();
  TLOG_DEBUG(3) << "Total group links: " << m_total_group_links;
 
  m_tc_merging        = proc_conf->get_merge_overlapping_tcs();
  m_ignore_tc_pileup = proc_conf->get_ignore_overlapping_tcs();
  m_buffer_timeout    = proc_conf->get_buffer_timeout();
  m_send_timed_out_tds = (m_ignore_tc_pileup) ? false : proc_conf->get_td_out_of_timeout();
  m_td_readout_limit  = proc_conf->get_td_readout_limit();
  m_ignored_tc_types = proc_conf->get_ignore_tc();
  m_ignoring_tc_types = !m_ignored_tc_types.empty();
 
  // Trigger bitwords
  std::vector<const appmodel::TriggerBitword*> bitwords = proc_conf->get_trigger_bitwords();
  m_use_bitwords = !bitwords.empty();
  if(m_use_bitwords){
    set_trigger_bitwords(bitwords);
    print_trigger_bitwords();
  }
  TLOG_DEBUG(3) << "Use bitwords: " << m_use_bitwords;
  TLOG_DEBUG(3) << "Allow merging: " << m_tc_merging;
  TLOG_DEBUG(3) << "Ignore pileup: " << m_ignore_tc_pileup;
  TLOG_DEBUG(3) << "Buffer timeout: " << m_buffer_timeout;
  TLOG_DEBUG(3) << "Should send timed out TDs: " << m_send_timed_out_tds;
  TLOG_DEBUG(3) << "TD readout limit: " << m_td_readout_limit;
 
  // ROI map
  m_roi_conf_data = proc_conf->get_roi_group_conf();
  m_use_roi_readout = !m_roi_conf_data.empty();
  if (m_use_roi_readout) {
    parse_roi_conf(m_roi_conf_data);
    print_roi_conf(m_roi_conf);
  }
  TLOG_DEBUG(3) << "Use ROI readout?: " << m_use_roi_readout;
 
  // Custom readout map
  m_readout_window_map_data = proc_conf->get_tc_readout_map();
  m_use_readout_map = !m_readout_window_map_data.empty();
  if (m_use_readout_map) {
    parse_readout_map(m_readout_window_map_data);
    print_readout_map(m_readout_window_map);
  }
  TLOG_DEBUG(3) << "Use readout map: " << m_use_readout_map;
 
  // Ignoring TC types
  TLOG_DEBUG(3) << "Ignoring TC types: " << m_ignoring_tc_types;
  if(m_ignoring_tc_types){
    TLOG_DEBUG(3) << "TC types to ignore: ";
    for (std::vector<unsigned int>::iterator it = m_ignored_tc_types.begin(); it != m_ignored_tc_types.end();) {
      TLOG_DEBUG(3) << *it;
      ++it;
    }
  }
  m_latency_monitoring.store( dp->get_latency_monitoring() );
  inherited::add_postprocess_task(std::bind(&TCProcessor::make_td, this, std::placeholders::_1));
 
  inherited::conf(mtrg);
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Exiting conf() method";
}

create_all_decision_requests()

std::vector< dfmessages::ComponentRequest > dunedaq::trigger::TCProcessor::create_all_decision_requests ( std::vector< daqdataformats::SourceID > links, triggeralgs::timestamp_t start, triggeralgs::timestamp_t end )

private

Definition at line 702 of file TCProcessor.cpp.

{
  std::vector<dfmessages::ComponentRequest> requests;
  for (auto link : links) {
    requests.push_back(create_request_for_link(link, start, end));
  }
  return requests;
}

create_decision()

dfmessages::TriggerDecision dunedaq::trigger::TCProcessor::create_decision ( const PendingTD & pending_td )

private

Definition at line 297 of file TCProcessor.cpp.

{
  m_earliest_tc_index = get_earliest_tc_index(pending_td);
  TLOG_DEBUG(5) << "earliest TC index: " << m_earliest_tc_index;
 
  if (pending_td.contributing_tcs.size() > 1) {
    TLOG_DEBUG(5) << "!!! TD created from " << pending_td.contributing_tcs.size() << " TCs !!!";
  }
 
  dfmessages::TriggerDecision decision;
  decision.trigger_number = 0; // filled by MLT
  decision.run_number = 0; // filled by MLT
  decision.trigger_timestamp = pending_td.contributing_tcs[m_earliest_tc_index].time_candidate;
  decision.readout_type = dfmessages::ReadoutType::kLocalized;
 
  TDBitset td_bitword = get_TD_bitword(pending_td);
  TLOG_DEBUG(5) << "[MLT] TD has bitword: " << td_bitword << " "
                                     << static_cast<dfmessages::trigger_type_t>(td_bitword.to_ulong());
  decision.trigger_type = static_cast<dfmessages::trigger_type_t>(td_bitword.to_ulong()); // m_trigger_type;
 
    //decision.trigger_type = 1; // m_trigger_type;
 
  TLOG_DEBUG(3) << ", TC detid: " << pending_td.contributing_tcs[m_earliest_tc_index].detid
                << ", TC type: " << static_cast<int>(pending_td.contributing_tcs[m_earliest_tc_index].type)
                << ", TC cont number: " << pending_td.contributing_tcs.size()
                << ", DECISION trigger type: " << decision.trigger_type
                << ", DECISION timestamp: " << decision.trigger_timestamp
                << ", request window begin: " << pending_td.readout_start
                << ", request window end: " << pending_td.readout_end;
 
  std::vector<dfmessages::ComponentRequest> requests =
    create_all_decision_requests(m_mandatory_links, pending_td.readout_start, pending_td.readout_end);
  add_requests_to_decision(decision, requests);
 
  if (!m_use_roi_readout) {
    for (const auto& [key, value] : m_group_links) {
      std::vector<dfmessages::ComponentRequest> group_requests =
        create_all_decision_requests(value, pending_td.readout_start, pending_td.readout_end);
      add_requests_to_decision(decision, group_requests);
    }
  } else { // using ROI readout
    roi_readout_make_requests(decision);
  }
 
  m_tds_created_count++;
  m_tds_created_tc_count += pending_td.contributing_tcs.size();
 
  return decision;
}

create_request_for_link()

dfmessages::ComponentRequest dunedaq::trigger::TCProcessor::create_request_for_link ( daqdataformats::SourceID link, triggeralgs::timestamp_t start, triggeralgs::timestamp_t end )

private

Definition at line 686 of file TCProcessor.cpp.

{
  dfmessages::ComponentRequest request;
  request.component = link;
  request.window_begin = start;
  request.window_end = end;
 
  TLOG_DEBUG(10) << "setting request start: " << request.window_begin;
  TLOG_DEBUG(10) << "setting request end: " << request.window_end;
 
  return request;
}

generate_opmon_data()

void dunedaq::trigger::TCProcessor::generate_opmon_data ( )

overridevirtual

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

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >.

Definition at line 222 of file TCProcessor.cpp.

{
  opmon::TCProcessorInfo info;
 
  info.set_tds_created_count( m_tds_created_count.load() );  
  info.set_tds_sent_count( m_tds_sent_count.load() );
  info.set_tds_dropped_count( m_tds_dropped_count.load() );
  info.set_tds_failed_bitword_count( m_tds_failed_bitword_count.load() );
  info.set_tds_cleared_count( m_tds_cleared_count.load() );
  info.set_tc_received_count( m_tc_received_count.load() );
  info.set_tc_ignored_count( m_tc_ignored_count.load() );
  info.set_tds_created_tc_count( m_tds_created_tc_count.load() );
  info.set_tds_sent_tc_count( m_tds_sent_tc_count.load() );
  info.set_tds_dropped_tc_count( m_tds_dropped_tc_count.load() );
  info.set_tds_failed_bitword_tc_count( m_tds_failed_bitword_tc_count.load() );
  info.set_tds_cleared_tc_count( m_tds_cleared_tc_count.load() );
 
  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));
  }
}

get_earliest_tc_index()

int dunedaq::trigger::TCProcessor::get_earliest_tc_index ( const PendingTD & pending_td )

private

Definition at line 526 of file TCProcessor.cpp.

{
  int earliest_tc_index = -1;
  triggeralgs::timestamp_t earliest_tc_time;
  for (int i = 0; i < static_cast<int>(pending_td.contributing_tcs.size()); i++) {
    if (earliest_tc_index == -1) {
      earliest_tc_time = pending_td.contributing_tcs[i].time_candidate;
      earliest_tc_index = i;
    } else {
      if (pending_td.contributing_tcs[i].time_candidate < earliest_tc_time) {
        earliest_tc_time = pending_td.contributing_tcs[i].time_candidate;
        earliest_tc_index = i;
      }
    }
  }
  return earliest_tc_index;
}

get_random_num_float()

float dunedaq::trigger::TCProcessor::get_random_num_float ( float limit )

private

Definition at line 759 of file TCProcessor.cpp.

{
  float rnd = (double)rand() / RAND_MAX;
  return rnd * (limit);
}

get_random_num_int()

int dunedaq::trigger::TCProcessor::get_random_num_int ( )

private

Definition at line 778 of file TCProcessor.cpp.

{
  int range = m_total_group_links;
  int rnd = rand() % range;
  return rnd;
}

get_ready_tds()

std::vector< TCProcessor::PendingTD > dunedaq::trigger::TCProcessor::get_ready_tds ( std::vector< PendingTD > & pending_tds )

private

Definition at line 505 of file TCProcessor.cpp.

{
  std::vector<PendingTD> return_tds;
  for (std::vector<PendingTD>::iterator it = pending_tds.begin(); it != pending_tds.end();) {
    auto timestamp_now =
      std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch())
        .count();
    if (timestamp_now >= it->walltime_expiration) {
      return_tds.push_back(*it);
      it = pending_tds.erase(it);
    } else if (check_td_readout_length(*it)) { // Also pass on TDs with (too) long readout window
      return_tds.push_back(*it);
      it = pending_tds.erase(it);
    } else {
      ++it;
    }
  }
  return return_tds;
}

get_TD_bitword()

TCProcessor::TDBitset dunedaq::trigger::TCProcessor::get_TD_bitword ( const PendingTD & ready_td ) const

private

Definition at line 827 of file TCProcessor.cpp.

{
  // get only unique types
  std::vector<int> tc_types;
  for (auto tc : ready_td.contributing_tcs) {
    tc_types.push_back(static_cast<int>(tc.type));
  }
  tc_types.erase(std::unique(tc_types.begin(), tc_types.end()), tc_types.end());
 
  // form TD bitword
  TDBitset td_bitword;
  for (auto tc_type : tc_types) {
    td_bitword.set(tc_type);
  }
  return td_bitword;
}

make_td()

void dunedaq::trigger::TCProcessor::make_td ( const TCWrapper * tcw )

protected

Pipeline Stage 2.: put valid TCs in a vector for grouping and forming of TDs

Definition at line 255 of file TCProcessor.cpp.

{
    
  auto tc = tcw->candidate;
  if (m_latency_monitoring.load()) m_latency_instance.update_latency_in( tc.time_start );
  m_tc_received_count++;
 
  if ( (m_use_readout_map) && (m_readout_window_map.count(tc.type)) ) {
    TLOG_DEBUG(3) << "Got TC of type " << static_cast<int>(tc.type) << ", timestamp " << tc.time_candidate
          << ", start/end " << tc.time_start << "/" << tc.time_end << ", readout start/end "
          << tc.time_candidate - m_readout_window_map[tc.type].first << "/"
          << tc.time_candidate + m_readout_window_map[tc.type].second;
  } else {
    TLOG_DEBUG(3) << "Got TC of type " << static_cast<int>(tc.type) << ", timestamp " << tc.time_candidate
          << ", start/end " << tc.time_start << "/" << tc.time_end;
  }
 
  // Option to ignore TC types (if given by config)
  if (m_ignoring_tc_types == true && check_trigger_type_ignore(static_cast<unsigned int>(tc.type)) == true) {
    TLOG_DEBUG(3) << " Ignore TC type: " << static_cast<unsigned int>(tc.type);
    m_tc_ignored_count++;
 
    /*FIXME: comment out this block: if a TC is to be ignored it shall just be ignored! 
      if (m_tc_merging) {
        // Still need to check for overlap with existing TD, if overlaps, include in the TD, but don't extend
        // readout
        std::lock_guard<std::mutex> lock(m_td_vector_mutex);
        add_tc_ignored(*tc);
      }
      */
  }
  else {
    std::lock_guard<std::mutex> lock(m_td_vector_mutex);
    add_tc(tc);
    m_cv.notify_one();
    TLOG_DEBUG(10) << "pending tds size: " << m_pending_tds.size();
  }
  m_last_processed_daq_ts = tc.time_start;
  return;
}

parse_group_links()

void dunedaq::trigger::TCProcessor::parse_group_links ( const nlohmann::json & data )

private

Definition at line 658 of file TCProcessor.cpp.

{
  for (auto group : data) {
    const nlohmann::json& temp_links_data = group["links"];
    std::vector<dfmessages::SourceID> temp_links;
    for (auto link : temp_links_data) {
      temp_links.push_back(
        dfmessages::SourceID{ daqdataformats::SourceID::string_to_subsystem(link["subsystem"]), link["element"] });
    }
    m_group_links.insert({ group["group"], temp_links });
  }
  return;
}

parse_readout_map()

void dunedaq::trigger::TCProcessor::parse_readout_map ( const std::vector< const appmodel::TCReadoutMap * > & data )

private

Definition at line 629 of file TCProcessor.cpp.

{
  for (auto readout_type : data) {
    TCType tc_type = static_cast<TCType>(
      dunedaq::trgdataformats::string_to_trigger_candidate_type(readout_type->get_tc_type_name()));
 
      // Throw error if unknown TC type
      if (tc_type == TCType::kUnknown) {
        throw(InvalidConfiguration(ERS_HERE, "Provided an unknown TC type in the TCReadoutMap for the TCProcessor"));
      }
 
    m_readout_window_map[tc_type] = {
      readout_type->get_time_before(), readout_type->get_time_after()
    };
  }
  return;
}

parse_roi_conf()

void dunedaq::trigger::TCProcessor::parse_roi_conf ( const std::vector< const appmodel::ROIGroupConf * > & data )

private

Definition at line 723 of file TCProcessor.cpp.

{
  int counter = 0;
  float run_sum = 0;
  for (auto group : data) {
    roi_group temp_roi_group;
    temp_roi_group.n_links = group->get_number_of_link_groups();
    temp_roi_group.prob         = group->get_probability();
    temp_roi_group.time_window  = group->get_time_window();
    temp_roi_group.mode         = group->get_groups_selection_mode();
    m_roi_conf.insert({ counter, temp_roi_group });
    m_roi_conf_ids.push_back(counter);
    m_roi_conf_probs.push_back(group->get_probability());
    run_sum += static_cast<float>(group->get_probability());
    m_roi_conf_probs_c.push_back(run_sum);
    counter++;
  }
  return;
}

pick_roi_group_conf()

int dunedaq::trigger::TCProcessor::pick_roi_group_conf ( )

private

Definition at line 766 of file TCProcessor.cpp.

{
  float rnd_num = get_random_num_float(m_roi_conf_probs_c.back());
  for (int i = 0; i < static_cast<int>(m_roi_conf_probs_c.size()); i++) {
    if (rnd_num < m_roi_conf_probs_c[i]) {
      return i;
    }
  }
  return -1;
}

print_group_links()

void dunedaq::trigger::TCProcessor::print_group_links ( )

private

Definition at line 673 of file TCProcessor.cpp.

{
  TLOG_DEBUG(3) << "MLT Group Links:";
  for (auto const& [key, val] : m_group_links) {
    TLOG_DEBUG(3) << "Group: " << key;
    for (auto const& link : val) {
      TLOG_DEBUG(3) << link;
    }
  }
  TLOG_DEBUG(3) << " ";
  return;
}

print_opmon_stats()

void dunedaq::trigger::TCProcessor::print_opmon_stats ( )

private

Definition at line 845 of file TCProcessor.cpp.

{
  TLOG() << "TCProcessor opmon counters summary:";
  TLOG() << "------------------------------";
  TLOG() << "TDs created: \t\t\t" << m_tds_created_count << " \t(" << m_tds_created_tc_count << " TCs)";
  TLOG() << "TDs sent: \t\t\t" << m_tds_sent_count << " \t(" << m_tds_sent_tc_count << " TCs)";
  TLOG() << "TDs dropped: \t\t\t" << m_tds_dropped_count << " \t(" << m_tds_dropped_tc_count << " TCs)";
  TLOG() << "TDs failed bitword check: \t" << m_tds_failed_bitword_count << " \t(" << m_tds_failed_bitword_tc_count << " TCs)";
  TLOG() << "TDs cleared: \t\t\t" << m_tds_cleared_count << " \t(" << m_tds_cleared_tc_count << " TCs)";
  TLOG() << "------------------------------";
  TLOG() << "TCs received: \t" << m_tc_received_count;
  TLOG() << "TCs ignored: \t" << m_tc_ignored_count;
  TLOG();
}

print_readout_map()

void dunedaq::trigger::TCProcessor::print_readout_map ( std::map< TCType, std::pair< triggeralgs::timestamp_t, triggeralgs::timestamp_t > > map )

private

Definition at line 647 of file TCProcessor.cpp.

{
  TLOG_DEBUG(3) << "MLT TD Readout map:";
  for (auto const& [key, val] : map) {
    TLOG_DEBUG(3) << "Type: " << static_cast<int>(key) << ", before: " << val.first << ", after: " << val.second;
  }
  return;
}

print_roi_conf()

void dunedaq::trigger::TCProcessor::print_roi_conf ( std::map< int, roi_group > roi_conf )

private

Definition at line 744 of file TCProcessor.cpp.

{
  TLOG_DEBUG(3) << "ROI CONF";
  for (const auto& [key, value] : roi_conf) {
    TLOG_DEBUG(3) << "ID: " << key;
    TLOG_DEBUG(3) << "n links: " << value.n_links;
    TLOG_DEBUG(3) << "prob: " << value.prob;
    TLOG_DEBUG(3) << "time: " << value.time_window;
    TLOG_DEBUG(3) << "mode: " << value.mode;
  }
  TLOG_DEBUG(3) << " ";
  return;
}

print_trigger_bitwords()

void dunedaq::trigger::TCProcessor::print_trigger_bitwords ( )

private

Definition at line 585 of file TCProcessor.cpp.

{
  TLOG_DEBUG(3) << "Configured trigger words:";
  for (const auto& bitword : m_trigger_bitwords) {
    TLOG_DEBUG(3) << bitword;
  }
}

roi_readout_make_requests()

void dunedaq::trigger::TCProcessor::roi_readout_make_requests ( dfmessages::TriggerDecision & decision )

private

Definition at line 785 of file TCProcessor.cpp.

{
  // Get configuration at random (weighted)
  int group_pick = pick_roi_group_conf();
  if (group_pick != -1) {
    roi_group this_group = m_roi_conf[m_roi_conf_ids[group_pick]];
    std::vector<dfmessages::SourceID> links;
 
    // If mode is random, pick groups to request at random
    if (this_group.mode == "kRandom") {
      TLOG_DEBUG(10) << "RAND";
      std::set<int> groups;
      while (static_cast<int>(groups.size()) < this_group.n_links) {
        groups.insert(get_random_num_int());
      }
      for (auto r_id : groups) {
        links.insert(links.end(), m_group_links[r_id].begin(), m_group_links[r_id].end());
      }
      // Otherwise, read sequntially by IDs, starting at 0
    } else {
      TLOG_DEBUG(10) << "SEQ";
      int r_id = 0;
      while (r_id < this_group.n_links) {
        links.insert(links.end(), m_group_links[r_id].begin(), m_group_links[r_id].end());
        r_id++;
      }
    }
 
    TLOG_DEBUG(10) << "TD timestamp: " << decision.trigger_timestamp;
    TLOG_DEBUG(10) << "group window: " << this_group.time_window;
 
    // Once the components are prepared, create requests and append them to decision
    std::vector<dfmessages::ComponentRequest> requests =
      create_all_decision_requests(links, decision.trigger_timestamp - this_group.time_window,
                                   decision.trigger_timestamp + this_group.time_window);
    add_requests_to_decision(decision, requests);
    links.clear();
  }
  return;
}

scrap()

void dunedaq::trigger::TCProcessor::scrap ( const nlohmann::json & )

overridevirtual

Unconfigure.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >.

Definition at line 196 of file TCProcessor.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Entering scrap() method";
 
  m_mandatory_links.clear();
  m_group_links.clear();
  m_roi_conf.clear();
  m_roi_conf_data.clear();
  m_roi_conf_ids.clear();
  m_roi_conf_probs.clear();
  m_roi_conf_probs_c.clear();
  m_pending_tds.clear();
  m_readout_window_map_data.clear();
  m_readout_window_map.clear();
  m_ignored_tc_types.clear();
  
  m_td_sink.reset();
  
  m_group_links_data.clear();
  
  inherited::scrap(args);
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Exiting scrap() method";
}

send_trigger_decisions()

void dunedaq::trigger::TCProcessor::send_trigger_decisions ( )

private

Definition at line 349 of file TCProcessor.cpp.

                                    {
 // A unique lock that can be locked and unlocked
 std::unique_lock<std::mutex> lock(m_td_vector_mutex);
 
 while (m_running_flag) {
    // Either there are pending TDs, or wait for a bit
    m_cv.wait(lock, [this] {
        return !m_pending_tds.empty() || !m_running_flag;
    });
    auto ready_tds = get_ready_tds(m_pending_tds);
    TLOG_DEBUG(10) << "ready tds: " << ready_tds.size() << ", updated pending tds: " << m_pending_tds.size();
 
    for (std::vector<PendingTD>::iterator it = ready_tds.begin(); it != ready_tds.end();) {
        call_tc_decision(*it);
        ++it;
    }
 }
}

set_trigger_bitwords()

void dunedaq::trigger::TCProcessor::set_trigger_bitwords ( const std::vector< const appmodel::TriggerBitword * > & _bitwords )

private

Definition at line 609 of file TCProcessor.cpp.

{
  for (const appmodel::TriggerBitword* bitword : _bitwords) {
    TDBitset temp_bitword;
 
    for (const std::string& tctype_str: bitword->get_bitword()) {
      TCType tc_type = static_cast<TCType>(dunedaq::trgdataformats::string_to_trigger_candidate_type(tctype_str));
 
      if (tc_type == TCType::kUnknown) {
        throw(InvalidConfiguration(ERS_HERE, "Provided an unknown/non-existent TC type as a trigger bitword!"));
      }
 
      temp_bitword.set(static_cast<uint64_t>(tc_type));
    }
 
    m_trigger_bitwords.push_back(temp_bitword);
  }
}

start()

void dunedaq::trigger::TCProcessor::start ( const nlohmann::json & )

overridevirtual

Start operation.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >.

Definition at line 41 of file TCProcessor.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Entering start() method";
 
  m_running_flag.store(true);
  m_send_trigger_decisions_thread = std::thread(&TCProcessor::send_trigger_decisions, this);
  pthread_setname_np(m_send_trigger_decisions_thread.native_handle(), "mlt-dec"); // TODO: originally mlt-trig-dec
 
  // Reset stats
  m_tds_created_count.store(0);
  m_tds_sent_count.store(0);
  m_tds_dropped_count.store(0);
  m_tds_failed_bitword_count.store(0);
  m_tds_cleared_count.store(0);
  // per TC
  m_tc_received_count.store(0);
  m_tds_created_tc_count.store(0);
  m_tds_sent_tc_count.store(0);
  m_tds_dropped_tc_count.store(0);
  m_tds_failed_bitword_tc_count.store(0);
  m_tds_cleared_tc_count.store(0);
  m_tc_ignored_count.store(0);
  inherited::start(args);
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Exiting start() method";
}

stop()

void dunedaq::trigger::TCProcessor::stop ( const nlohmann::json & )

overridevirtual

Stop operation.

Reimplemented from dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >.

Definition at line 69 of file TCProcessor.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Entering stop() method";
 
  inherited::stop(args);
  m_running_flag.store(false);
 
  // Make sure condition_variable knows we flipped running flag
  {
    std::lock_guard<std::mutex> lock(m_td_vector_mutex);
    m_cv.notify_all();
  }
 
  // Wait for the TD-sending thread to stop
  m_send_trigger_decisions_thread.join();
 
  // Drop all TDs in vectors at run stage change. Have to do this
  // after joining m_send_trigger_decisions_thread so we don't
  // concurrently access the vectors
  clear_td_vectors();
 
  print_opmon_stats();
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "TCProcessor: Exiting stop() method";
}

Member Data Documentation

m_buffer_timeout

int64_t dunedaq::trigger::TCProcessor::m_buffer_timeout

private

Definition at line 142 of file TCProcessor.hpp.

m_cv

std::condition_variable dunedaq::trigger::TCProcessor::m_cv

private

Definition at line 132 of file TCProcessor.hpp.

m_earliest_tc_index

int dunedaq::trigger::TCProcessor::m_earliest_tc_index

private

Definition at line 145 of file TCProcessor.hpp.

m_group_links

std::map<int, std::vector<daqdataformats::SourceID> > dunedaq::trigger::TCProcessor::m_group_links

private

Definition at line 74 of file TCProcessor.hpp.

m_group_links_data

nlohmann::json dunedaq::trigger::TCProcessor::m_group_links_data

private

Definition at line 75 of file TCProcessor.hpp.

m_ignore_tc_pileup

bool dunedaq::trigger::TCProcessor::m_ignore_tc_pileup

private

Ignore TCs that overlap with already made TD.

Definition at line 114 of file TCProcessor.hpp.

m_ignored_tc_types

std::vector<unsigned int> dunedaq::trigger::TCProcessor::m_ignored_tc_types

private

Definition at line 170 of file TCProcessor.hpp.

m_ignoring_tc_types

bool dunedaq::trigger::TCProcessor::m_ignoring_tc_types

private

Definition at line 171 of file TCProcessor.hpp.

m_last_trigger_number

dfmessages::trigger_number_t dunedaq::trigger::TCProcessor::m_last_trigger_number

private

Definition at line 116 of file TCProcessor.hpp.

m_latency_in

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

private

Definition at line 198 of file TCProcessor.hpp.

{ 0 };

m_latency_instance

dunedaq::trigger::Latency dunedaq::trigger::TCProcessor::m_latency_instance

private

Definition at line 197 of file TCProcessor.hpp.

m_latency_monitoring

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

private

Definition at line 196 of file TCProcessor.hpp.

{ false };

m_latency_out

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

private

Definition at line 199 of file TCProcessor.hpp.

{ 0 };

m_mandatory_links

std::vector<daqdataformats::SourceID> dunedaq::trigger::TCProcessor::m_mandatory_links

private

Definition at line 73 of file TCProcessor.hpp.

m_pending_tds

std::vector<PendingTD> dunedaq::trigger::TCProcessor::m_pending_tds

private

Definition at line 130 of file TCProcessor.hpp.

m_readout_window_map

std::map<TCType, std::pair<triggeralgs::timestamp_t, triggeralgs::timestamp_t> > dunedaq::trigger::TCProcessor::m_readout_window_map

private

Definition at line 160 of file TCProcessor.hpp.

m_readout_window_map_data

std::vector<const appmodel::TCReadoutMap*> dunedaq::trigger::TCProcessor::m_readout_window_map_data

private

Definition at line 158 of file TCProcessor.hpp.

m_repeat_trigger_count

int dunedaq::trigger::TCProcessor::m_repeat_trigger_count { 1 }

private

Definition at line 110 of file TCProcessor.hpp.

{ 1 };

m_roi_conf

std::map<int, roi_group> dunedaq::trigger::TCProcessor::m_roi_conf

private

Definition at line 98 of file TCProcessor.hpp.

m_roi_conf_data

std::vector<const appmodel::ROIGroupConf*> dunedaq::trigger::TCProcessor::m_roi_conf_data

private

Definition at line 99 of file TCProcessor.hpp.

m_roi_conf_ids

std::vector<int> dunedaq::trigger::TCProcessor::m_roi_conf_ids

private

Definition at line 102 of file TCProcessor.hpp.

m_roi_conf_probs

std::vector<float> dunedaq::trigger::TCProcessor::m_roi_conf_probs

private

Definition at line 103 of file TCProcessor.hpp.

m_roi_conf_probs_c

std::vector<float> dunedaq::trigger::TCProcessor::m_roi_conf_probs_c

private

Definition at line 104 of file TCProcessor.hpp.

m_run_number

dfmessages::run_number_t dunedaq::trigger::TCProcessor::m_run_number

private

Definition at line 118 of file TCProcessor.hpp.

m_running_flag

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

private

Definition at line 120 of file TCProcessor.hpp.

{ false };

m_send_timed_out_tds

std::atomic<bool> dunedaq::trigger::TCProcessor::m_send_timed_out_tds

private

Definition at line 144 of file TCProcessor.hpp.

m_send_trigger_decisions_thread

std::thread dunedaq::trigger::TCProcessor::m_send_trigger_decisions_thread

private

Definition at line 70 of file TCProcessor.hpp.

m_tc_ignored_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tc_ignored_count { 0 }

private

Definition at line 193 of file TCProcessor.hpp.

{ 0 };

m_tc_merging

std::atomic<bool> dunedaq::trigger::TCProcessor::m_tc_merging

private

Definition at line 111 of file TCProcessor.hpp.

m_tc_received_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tc_received_count { 0 }

private

Definition at line 187 of file TCProcessor.hpp.

{ 0 };

m_td_readout_limit

int64_t dunedaq::trigger::TCProcessor::m_td_readout_limit

private

Definition at line 143 of file TCProcessor.hpp.

m_td_sink

std::shared_ptr<iomanager::SenderConcept<dfmessages::TriggerDecision> > dunedaq::trigger::TCProcessor::m_td_sink

private

Definition at line 176 of file TCProcessor.hpp.

m_td_vector_mutex

std::mutex dunedaq::trigger::TCProcessor::m_td_vector_mutex

private

Definition at line 131 of file TCProcessor.hpp.

m_tds_cleared_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_cleared_count { 0 }

private

Definition at line 184 of file TCProcessor.hpp.

{ 0 };

m_tds_cleared_tc_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_cleared_tc_count { 0 }

private

Definition at line 192 of file TCProcessor.hpp.

{ 0 };

m_tds_created_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_created_count { 0 }

private

Definition at line 180 of file TCProcessor.hpp.

{ 0 };  // NOLINT(build/unsigned)

m_tds_created_tc_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_created_tc_count { 0 }

private

Definition at line 188 of file TCProcessor.hpp.

{ 0 };

m_tds_dropped_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_dropped_count { 0 }

private

Definition at line 182 of file TCProcessor.hpp.

{ 0 };

m_tds_dropped_tc_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_dropped_tc_count { 0 }

private

Definition at line 190 of file TCProcessor.hpp.

{ 0 };

m_tds_failed_bitword_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_failed_bitword_count { 0 }

private

Definition at line 183 of file TCProcessor.hpp.

{ 0 };

m_tds_failed_bitword_tc_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_failed_bitword_tc_count { 0 }

private

Definition at line 191 of file TCProcessor.hpp.

{ 0 };

m_tds_sent_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_sent_count { 0 }

private

Definition at line 181 of file TCProcessor.hpp.

{ 0 };

m_tds_sent_tc_count

std::atomic<metric_counter_type> dunedaq::trigger::TCProcessor::m_tds_sent_tc_count { 0 }

private

Definition at line 189 of file TCProcessor.hpp.

{ 0 };

m_total_group_links

int dunedaq::trigger::TCProcessor::m_total_group_links

private

Definition at line 76 of file TCProcessor.hpp.

m_trigger_bitwords

std::vector<TDBitset> dunedaq::trigger::TCProcessor::m_trigger_bitwords

private

Definition at line 150 of file TCProcessor.hpp.

m_trigger_type_shifted

dfmessages::trigger_type_t dunedaq::trigger::TCProcessor::m_trigger_type_shifted

private

Definition at line 167 of file TCProcessor.hpp.

m_use_bitwords

bool dunedaq::trigger::TCProcessor::m_use_bitwords

private

Definition at line 149 of file TCProcessor.hpp.

m_use_readout_map

bool dunedaq::trigger::TCProcessor::m_use_readout_map

private

Definition at line 157 of file TCProcessor.hpp.

m_use_roi_readout

bool dunedaq::trigger::TCProcessor::m_use_roi_readout

private

Definition at line 90 of file TCProcessor.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/trigger/src/trigger/TCProcessor.hpp
• /github/workspace/dunedaq/sourcecode/trigger/src/TCProcessor.cpp