#include <TAMakerSupernovaAlgorithm.hpp>

Inheritance diagram for triggeralgs::TAMakerSupernovaAlgorithm:

Collaboration diagram for triggeralgs::TAMakerSupernovaAlgorithm:

Public Member Functions
void	process (const TriggerPrimitive &input_tp, std::vector< TriggerActivity > &output_ta) override
	TP processing function that creates & fills TAs.

void	flush (timestamp_t, std::vector< TriggerActivity > &tas) override

Public Member Functions inherited from triggeralgs::TriggerActivityMaker
virtual	~TriggerActivityMaker ()=default

void	operator() (const TriggerPrimitive &input_tp, std::vector< TriggerActivity > &output_ta)

virtual bool	preprocess (const TriggerPrimitive &input_tp)
	TP pre-processing/filtering.

virtual void	postprocess (std::vector< TriggerActivity > &output_ta)
	Post-processing/filtering of the TAs, e.g. prescale.

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

Protected Attributes
timestamp_diff_t	m_time_tolerance

channel_t	m_channel_tolerance
	Maximum tolerated time difference between two primitives to form an activity (in 50 MHz clock ticks)

Private Member Functions
bool	is_time_consistent (const TriggerPrimitive &input_tp) const
	This activity maker makes an activity with all the trigger primitives.

bool	is_channel_consistent (const TriggerPrimitive &input_tp) const

TriggerActivity	MakeTriggerActivity () const
	Maximum tolerated channel number difference between two primitives to form an activity.

Private Attributes
timestamp_t	m_time_start = 0

timestamp_t	m_time_end = 0

timestamp_t	m_time_peak = 0

timestamp_t	m_time_activity = 0

channel_diff_t	m_channel_start = 0

channel_diff_t	m_channel_end = 0

channel_diff_t	m_channel_peak = 0

uint64_t	m_adc_integral = 0

uint16_t	m_adc_peak = 0

detid_t	m_detid = 0

TriggerActivity::Type	m_type = TriggerActivity::Type::kTPC

TriggerActivity::Algorithm	m_algorithm = TriggerActivity::Algorithm::kSupernova

std::vector< TriggerPrimitive >	m_tp_list

Additional Inherited Members
Public Attributes inherited from triggeralgs::TriggerActivityMaker
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_ta_count = 0
	TA made count for prescaling.

uint32_t	m_max_samples_over_threshold = std::numeric_limits<uint32_t>::max()
	Time-over-threshold TP filtering.

Detailed Description

Definition at line 19 of file TAMakerSupernovaAlgorithm.hpp.

Member Function Documentation

◆ flush()

void triggeralgs::TAMakerSupernovaAlgorithm::flush	(	timestamp_t	,
		std::vector< TriggerActivity > &	tas )

inlineoverridevirtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 52 of file TAMakerSupernovaAlgorithm.hpp.

52{ tas.push_back(MakeTriggerActivity()); }

triggeralgs::TAMakerSupernovaAlgorithm::MakeTriggerActivity

TriggerActivity MakeTriggerActivity() const

Maximum tolerated channel number difference between two primitives to form an activity.

Definition TAMakerSupernovaAlgorithm.hpp:61

◆ is_channel_consistent()

bool triggeralgs::TAMakerSupernovaAlgorithm::is_channel_consistent ( const TriggerPrimitive & input_tp ) const

inlineprivate

Definition at line 38 of file TAMakerSupernovaAlgorithm.hpp.

  {
 
    bool is_close_to_edge = (m_channel_tolerance > abs(channel_diff_t(input_tp.channel) - m_channel_end) ||
                             m_channel_tolerance > abs(channel_diff_t(input_tp.channel) - m_channel_start));
 
    bool is_in_between_edge = (input_tp.channel > m_channel_start && input_tp.channel < m_channel_end);
 
    return is_in_between_edge || is_close_to_edge;
  }

◆ is_time_consistent()

bool triggeralgs::TAMakerSupernovaAlgorithm::is_time_consistent ( const TriggerPrimitive & input_tp ) const

inlineprivate

This activity maker makes an activity with all the trigger primitives.

Definition at line 23 of file TAMakerSupernovaAlgorithm.hpp.

  {
    timestamp_t tend = input_tp.time_start + input_tp.samples_over_threshold * 32; // FIXME: Replace the hard-coded SOT to TOT scaling.
 
    bool is_close_to_edge = (m_time_tolerance > abs(timestamp_diff_t(input_tp.time_start) - timestamp_diff_t(m_time_end))) ||
      m_time_tolerance > abs(timestamp_diff_t(input_tp.time_start) - timestamp_diff_t(m_time_start)) ||
      m_time_tolerance > abs(timestamp_diff_t(tend) - timestamp_diff_t(m_time_end)) ||
      m_time_tolerance > abs(timestamp_diff_t(tend) - timestamp_diff_t(m_time_start));
 
    bool is_in_between_edge = ((tend > m_time_start && tend < m_time_end) ||
                               (input_tp.time_start > m_time_start && input_tp.time_start < m_time_end));
 
    return is_in_between_edge || is_close_to_edge;
  }

◆ MakeTriggerActivity()

TriggerActivity triggeralgs::TAMakerSupernovaAlgorithm::MakeTriggerActivity ( ) const

inlineprivate

Maximum tolerated channel number difference between two primitives to form an activity.

Definition at line 61 of file TAMakerSupernovaAlgorithm.hpp.

  {
    TriggerActivity ta;
    ta.time_start = m_time_start;
    ta.time_end = m_time_end;
    ta.time_peak = m_time_peak;
    ta.time_activity = m_time_activity;
    ta.channel_start = m_channel_start;
 
    ta.channel_end = m_channel_end;
    ta.channel_peak = m_channel_peak;
    ta.adc_integral = m_adc_integral;
    ta.adc_peak = m_adc_peak;
    ta.detid = m_detid;
 
    ta.type = m_type;
    ta.algorithm = m_algorithm;
    ta.inputs = m_tp_list;
    return ta;
  }

◆ process()

void TAMakerSupernovaAlgorithm::process	(	const TriggerPrimitive &	input_tp,
		std::vector< TriggerActivity > &	output_ta )

overridevirtual

TP processing function that creates & fills TAs.

Parameters

input_tp[in]	Input TP for the triggering algorithm
output_ta[out]	Output vector of TAs to fill by the algorithm

Implements triggeralgs::TriggerActivityMaker.

Definition at line 21 of file TAMakerSupernovaAlgorithm.cpp.

{
  // Time measurement
  // auto now = std::chrono::steady_clock::now();
  // m_algorithm = (uint32_t)pd_clock(now.time_since_epoch()).count();
 
  timestamp_t tend = input_tp.time_start + input_tp.samples_over_threshold * 32;  // FIXME: Replace the hard-coded SOT to TOT scaling.
 
  if (m_time_start == 0) {
    m_tp_list.erase(m_tp_list.begin(), m_tp_list.end());
    m_tp_list.push_back(input_tp);
    m_time_start = input_tp.time_start;
    m_time_end = tend;
    m_time_peak = input_tp.samples_to_peak * 32 + input_tp.time_start;  // FIXME: Replace STP to `time_peak` conversion.
    m_channel_start = input_tp.channel;
    m_channel_end = input_tp.channel;
    m_channel_peak = input_tp.channel;
    m_adc_integral = input_tp.adc_integral;
    m_adc_peak = input_tp.adc_peak;
    m_detid = input_tp.detid;
    return;
  }
 
  bool time_ok = is_time_consistent(input_tp);
  bool channel_ok = is_channel_consistent(input_tp);
 
  if (!time_ok && !channel_ok) {
    output_ta.push_back(MakeTriggerActivity());
    m_tp_list.erase(m_tp_list.begin(), m_tp_list.end());
    m_tp_list.push_back(input_tp);
    m_time_start = input_tp.time_start;
    m_time_end = tend;
    m_time_peak = input_tp.samples_to_peak * 32 + input_tp.time_start;  // FIXME: Replace STP to `time_peak` conversion.
    m_channel_start = input_tp.channel;
    m_channel_end = input_tp.channel;
    m_channel_peak = input_tp.channel;
    m_adc_integral = input_tp.adc_integral;
    m_adc_peak = input_tp.adc_peak;
    m_detid = input_tp.detid;
    return;
  }
 
  if (input_tp.time_start < m_time_start)
    m_time_start = input_tp.time_start;
 
  if (tend > m_time_end)
    m_time_end = tend;
 
  if (input_tp.adc_peak > m_adc_peak) {
    m_time_peak = input_tp.samples_to_peak * 32 + input_tp.time_start;  // FIXME: Replace STP to `time_peak` conversion.
    m_adc_peak = input_tp.adc_peak;
    m_channel_peak = input_tp.channel;
  }
 
  if (input_tp.channel > m_channel_end)
    m_channel_end = input_tp.channel;
 
  if (input_tp.channel < m_channel_start)
    m_channel_start = input_tp.channel;
 
  m_tp_list.push_back(input_tp);
  m_adc_integral += input_tp.adc_integral;
  m_detid |= input_tp.detid;
}

Member Data Documentation

◆ m_adc_integral

uint64_t triggeralgs::TAMakerSupernovaAlgorithm::m_adc_integral = 0

private

Definition at line 89 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_adc_peak

uint16_t triggeralgs::TAMakerSupernovaAlgorithm::m_adc_peak = 0

private

Definition at line 90 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_algorithm

TriggerActivity::Algorithm triggeralgs::TAMakerSupernovaAlgorithm::m_algorithm = TriggerActivity::Algorithm::kSupernova

private

Definition at line 93 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_channel_end

channel_diff_t triggeralgs::TAMakerSupernovaAlgorithm::m_channel_end = 0

private

Definition at line 87 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_channel_peak

channel_diff_t triggeralgs::TAMakerSupernovaAlgorithm::m_channel_peak = 0

private

Definition at line 88 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_channel_start

channel_diff_t triggeralgs::TAMakerSupernovaAlgorithm::m_channel_start = 0

private

Definition at line 86 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_channel_tolerance

channel_t triggeralgs::TAMakerSupernovaAlgorithm::m_channel_tolerance

protected

Initial value:

=

2

Maximum tolerated time difference between two primitives to form an activity (in 50 MHz clock ticks)

Definition at line 57 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_detid

detid_t triggeralgs::TAMakerSupernovaAlgorithm::m_detid = 0

private

Definition at line 91 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_time_activity

timestamp_t triggeralgs::TAMakerSupernovaAlgorithm::m_time_activity = 0

private

Definition at line 85 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_time_end

timestamp_t triggeralgs::TAMakerSupernovaAlgorithm::m_time_end = 0

private

Definition at line 83 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_time_peak

timestamp_t triggeralgs::TAMakerSupernovaAlgorithm::m_time_peak = 0

private

Definition at line 84 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_time_start

timestamp_t triggeralgs::TAMakerSupernovaAlgorithm::m_time_start = 0

private

Definition at line 82 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_time_tolerance

timestamp_diff_t triggeralgs::TAMakerSupernovaAlgorithm::m_time_tolerance

protected

Initial value:

=

250

Definition at line 55 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_tp_list

std::vector<TriggerPrimitive> triggeralgs::TAMakerSupernovaAlgorithm::m_tp_list

private

Definition at line 95 of file TAMakerSupernovaAlgorithm.hpp.

◆ m_type

TriggerActivity::Type triggeralgs::TAMakerSupernovaAlgorithm::m_type = TriggerActivity::Type::kTPC

private

Definition at line 92 of file TAMakerSupernovaAlgorithm.hpp.

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

/github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/Supernova/TAMakerSupernovaAlgorithm.hpp
/github/workspace/dunedaq/sourcecode/triggeralgs/src/TAMakerSupernovaAlgorithm.cpp

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ flush()

◆ is_channel_consistent()

◆ is_time_consistent()

◆ MakeTriggerActivity()

◆ process()

Member Data Documentation

◆ m_adc_integral

◆ m_adc_peak

◆ m_algorithm

◆ m_channel_end

◆ m_channel_peak

◆ m_channel_start

◆ m_channel_tolerance

◆ m_detid

◆ m_time_activity

◆ m_time_end

◆ m_time_peak

◆ m_time_start

◆ m_time_tolerance

◆ m_tp_list

◆ m_type