triggeralgs::TCMakerHorizontalMuonAlgorithm Class Reference

#include <TCMakerHorizontalMuonAlgorithm.hpp>

Inheritance diagram for triggeralgs::TCMakerHorizontalMuonAlgorithm:

Collaboration diagram for triggeralgs::TCMakerHorizontalMuonAlgorithm:

Public Member Functions
void	process (const TriggerActivity &, std::vector< TriggerCandidate > &)
	TA processing function that creates & fills TCs.
void	configure (const nlohmann::json &config)
Public Member Functions inherited from triggeralgs::TriggerCandidateMaker
virtual	~TriggerCandidateMaker ()=default
void	operator() (const TriggerActivity &input_ta, std::vector< TriggerCandidate > &output_tc)
virtual bool	preprocess (const TriggerActivity &)
	TA pre-processing/filtering.
virtual void	postprocess (std::vector< TriggerCandidate > &output_tc)
	Post-processing/filtering of the TCs, e.g. prescale.
virtual void	flush (timestamp_t, std::vector< TriggerCandidate > &)

Private Member Functions
TriggerCandidate	construct_tc () const
bool	check_adjacency () const
void	add_window_to_record (TAWindow window)
void	dump_window_record ()

Private Attributes
TAWindow	m_current_window
uint64_t	m_activity_count = 0
bool	m_trigger_on_adc = false
bool	m_trigger_on_n_channels = false
uint32_t	m_adc_threshold = 1200000
uint16_t	m_n_channels_threshold = 600
timestamp_t	m_window_length = 80000
int	tc_number = 0
std::vector< TAWindow >	m_window_record

Additional Inherited Members
Public Attributes inherited from triggeralgs::TriggerCandidateMaker
std::atomic< uint64_t >	m_data_vs_system_time = 0
std::atomic< uint64_t >	m_initial_offset = 0
uint64_t	m_prescale = 1
	Configurable prescale factor.
uint64_t	m_tc_count = 0
	TC made count for prescaling.
TriggerCandidate::Type	m_tc_type_out = TriggerCandidate::Type::kUnknown
	Configurable TC type output.

Detailed Description

Definition at line 19 of file TCMakerHorizontalMuonAlgorithm.hpp.

Member Function Documentation

add_window_to_record()

void TCMakerHorizontalMuonAlgorithm::add_window_to_record ( TAWindow window )

private

Definition at line 166 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
  m_window_record.push_back(window);
  return;
}

check_adjacency()

bool TCMakerHorizontalMuonAlgorithm::check_adjacency ( ) const

private

Definition at line 158 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
  // FIX ME: An adjacency check on the channels which have hits.
  return true;
}

configure()

void TCMakerHorizontalMuonAlgorithm::configure ( const nlohmann::json & config )

virtual

Reimplemented from triggeralgs::TriggerCandidateMaker.

Definition at line 103 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
  TriggerCandidateMaker::configure(config);
 
  if (config.is_object()) {
    if (config.contains("trigger_on_adc"))
      m_trigger_on_adc = config["trigger_on_adc"];
    if (config.contains("trigger_on_n_channels"))
      m_trigger_on_n_channels = config["trigger_on_n_channels"];
    if (config.contains("adc_threshold"))
      m_adc_threshold = config["adc_threshold"];
    if (config.contains("n_channels_threshold"))
      m_n_channels_threshold = config["n_channels_threshold"];
    if (config.contains("window_length"))
      m_window_length = config["window_length"];
  }
  if (m_trigger_on_adc && m_trigger_on_n_channels) {
    TLOG_DEBUG(TLVL_VERY_IMPORTANT) << "[TCM:HM] Triggering on ADC count and number of channels is not supported.";
    throw BadConfiguration(ERS_HERE, TRACE_NAME);
  }
  if (!m_trigger_on_adc && !m_trigger_on_n_channels) {
    TLOG_DEBUG(TLVL_VERY_IMPORTANT) << "[TCM:HM] Not triggering! All trigger flags are false!";
    throw BadConfiguration(ERS_HERE, TRACE_NAME);
  }
 
  return;
}

construct_tc()

TriggerCandidate TCMakerHorizontalMuonAlgorithm::construct_tc ( ) const

private

Definition at line 132 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
  TriggerActivity latest_ta_in_window = m_current_window.inputs.back();
 
  TriggerCandidate tc;
  tc.time_start = m_current_window.time_start;
  tc.time_end = latest_ta_in_window.inputs.back().time_start;
  tc.time_candidate = m_current_window.time_start;
  tc.detid = latest_ta_in_window.detid;
  tc.type = m_tc_type_out;
  tc.algorithm = TriggerCandidate::Algorithm::kHorizontalMuon;
 
  // Take the list of triggeralgs::TriggerActivity in the current
  // window and convert them (implicitly) to detdataformats'
  // TriggerActivityData, which is the base class of TriggerActivity
  for (auto& ta : m_current_window.inputs) {
    tc.inputs.push_back(ta);
    if (ta.time_end > tc.time_end) {
      tc.time_end = ta.time_end;
    }
  }
 
  return tc;
}

dump_window_record()

void TCMakerHorizontalMuonAlgorithm::dump_window_record ( )

private

Definition at line 173 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
  // FIX ME: Need to index this outfile in the name by detid or something similar.
  std::ofstream outfile;
  outfile.open("window_record_tcm.csv", std::ios_base::app);
 
  for (auto window : m_window_record) {
    outfile << window.time_start << ",";
    outfile << window.inputs.back().time_start << ",";
    outfile << window.inputs.back().time_start - window.time_start << ",";
    outfile << window.adc_integral << ",";
    outfile << window.n_channels_hit() << ",";
    outfile << window.inputs.size() << std::endl;
  }
 
  outfile.close();
 
  m_window_record.clear();
 
  return;
}

process()

void TCMakerHorizontalMuonAlgorithm::process ( const TriggerActivity & input_ta, std::vector< TriggerCandidate > & output_tc )

virtual

TA processing function that creates & fills TCs.

Parameters

input_ta[in]	Input TA for the triggering algorithm
output_tc[out]	Output vector of TCs to fill by the algorithm

Implements triggeralgs::TriggerCandidateMaker.

Definition at line 24 of file TCMakerHorizontalMuonAlgorithm.cpp.

{
 
  std::vector<TriggerActivity::TriggerActivityData> ta_list = { static_cast<TriggerActivity::TriggerActivityData>(
    activity) };
 
  // The first time operator is called, reset window object.
  if (m_current_window.is_empty()) {
    m_current_window.reset(activity);
    m_activity_count++;
 
    // TriggerCandidate tc = construct_tc();
    // output_tc.push_back(tc);
 
    // m_current_window.clear();
    // return;
  }
 
  // If the difference between the current TA's start time and the start of the window
  // is less than the specified window size, add the TA to the window.
  else if ((activity.time_start - m_current_window.time_start) < m_window_length) {
    TLOG_DEBUG(TLVL_DEBUG_HIGH) << "[TCM:HM] Window not yet complete, adding the activity to the window.";
    m_current_window.add(activity);
  }
  // If it is not, move the window along.
  else {
    TLOG_DEBUG(TLVL_DEBUG_ALL)
      << "[TCM:HM] TAWindow is at required length but specified threshold not met, shifting window along.";
    m_current_window.move(activity, m_window_length);
  }
 
  // If the addition of the current TA to the window would make it longer
  // than the specified window length, don't add it but check whether the sum of all adc in
  // the existing window is above the specified threshold. If it is, and we are triggering on ADC,
  // make a TA and start a fresh window with the current TP.
  if (m_current_window.adc_integral > m_adc_threshold && m_trigger_on_adc) {
    // TLOG_DEBUG(TRACE_NAME) << "ADC integral in window is greater than specified threshold.";
    TLOG_DEBUG(TLVL_DEBUG_MEDIUM) << "[TCM:HM] m_current_window.adc_integral " << m_current_window.adc_integral
                                  << " - m_adc_threshold " << m_adc_threshold;
    tc_number++;
    TriggerCandidate tc = construct_tc();
    TLOG_DEBUG(TLVL_DEBUG_MEDIUM) << "[TCM:HM] tc.time_start=" << tc.time_start << " tc.time_end=" << tc.time_end
                                  << " len(tc.inputs) " << tc.inputs.size();
 
    for (const auto& ta : tc.inputs) {
      TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TCM:HM] [TA] ta.time_start=" << ta.time_start << " ta.time_end=" << ta.time_end
                                 << " ta.adc_integral=" << ta.adc_integral;
    }
 
    output_tc.push_back(tc);
    // m_current_window.reset(activity);
    m_current_window.clear();
  }
 
  // If the addition of the current TA to the window would make it longer
  // than the specified window length, don't add it but check whether the number of hit channels in
  // the existing window is above the specified threshold. If it is, and we are triggering on channels,
  // make a TC and start a fresh window with the current TA.
  else if (m_current_window.n_channels_hit() > m_n_channels_threshold && m_trigger_on_n_channels) {
    tc_number++;
    output_tc.push_back(construct_tc());
 
    // m_current_window.reset(activity);
    m_current_window.clear();
  }
 
  // // If it is not, move the window along.
  // else {
  //   // TLOG_DEBUG(TRACE_NAME) << "TAWindow is at required length but specified threshold not met."
  //   //                        << "shifting window along.";
  //   m_current_window.move(activity, m_window_length);
  // }
 
  m_activity_count++;
  return;
}

Member Data Documentation

m_activity_count

uint64_t triggeralgs::TCMakerHorizontalMuonAlgorithm::m_activity_count = 0

private

Definition at line 33 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_adc_threshold

uint32_t triggeralgs::TCMakerHorizontalMuonAlgorithm::m_adc_threshold = 1200000

private

Definition at line 38 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_current_window

TAWindow triggeralgs::TCMakerHorizontalMuonAlgorithm::m_current_window

private

Definition at line 32 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_n_channels_threshold

uint16_t triggeralgs::TCMakerHorizontalMuonAlgorithm::m_n_channels_threshold = 600

private

Definition at line 39 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_trigger_on_adc

bool triggeralgs::TCMakerHorizontalMuonAlgorithm::m_trigger_on_adc = false

private

Definition at line 36 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_trigger_on_n_channels

bool triggeralgs::TCMakerHorizontalMuonAlgorithm::m_trigger_on_n_channels = false

private

Definition at line 37 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_window_length

timestamp_t triggeralgs::TCMakerHorizontalMuonAlgorithm::m_window_length = 80000

private

Definition at line 40 of file TCMakerHorizontalMuonAlgorithm.hpp.

m_window_record

std::vector<TAWindow> triggeralgs::TCMakerHorizontalMuonAlgorithm::m_window_record

private

Definition at line 46 of file TCMakerHorizontalMuonAlgorithm.hpp.

tc_number

int triggeralgs::TCMakerHorizontalMuonAlgorithm::tc_number = 0

private

Definition at line 41 of file TCMakerHorizontalMuonAlgorithm.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/HorizontalMuon/TCMakerHorizontalMuonAlgorithm.hpp
• /github/workspace/dunedaq/sourcecode/triggeralgs/src/TCMakerHorizontalMuonAlgorithm.cpp