triggeralgs::TAMakerADCSimpleWindowAlgorithm Class Reference

#include <TAMakerADCSimpleWindowAlgorithm.hpp>

Inheritance diagram for triggeralgs::TAMakerADCSimpleWindowAlgorithm:

Collaboration diagram for triggeralgs::TAMakerADCSimpleWindowAlgorithm:

Classes
class	Window

Public Member Functions
void	process (const TriggerPrimitive &input_tp, std::vector< TriggerActivity > &output_ta)
	TP processing function that creates & fills TAs.
void	configure (const nlohmann::json &config)
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	flush (timestamp_t, std::vector< TriggerActivity > &)

Private Member Functions
TriggerActivity	construct_ta () const

Private Attributes
Window	m_current_window
uint64_t	m_primitive_count = 0
uint32_t	m_adc_threshold = 1200000
timestamp_t	m_window_length = 100000
const uint16_t	k_sample_to_dts_ticks = 32

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 18 of file TAMakerADCSimpleWindowAlgorithm.hpp.

Member Function Documentation

configure()

void triggeralgs::TAMakerADCSimpleWindowAlgorithm::configure ( const nlohmann::json & config )

virtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 136 of file TAMakerADCSimpleWindowAlgorithm.cpp.

{
  TriggerActivityMaker::configure(config);
 
  //FIXME use some schema here
  if (config.is_object()){
    if (config.contains("window_length")) m_window_length = config["window_length"];
    if (config.contains("adc_threshold")) m_adc_threshold = config["adc_threshold"];
  }
  else{
    TLOG_DEBUG(TLVL_IMPORTANT) << "[TAM:ADCSW] The DEFAULT values of window_length and adc_threshold are being used.";
  }
  TLOG_DEBUG(TLVL_IMPORTANT) << "[TAM:ADCSW] If the total ADC of trigger primitives with times within a "
                         << m_window_length << " tick time window is above " << m_adc_threshold << " counts, a trigger will be issued.";
}

construct_ta()

TriggerActivity triggeralgs::TAMakerADCSimpleWindowAlgorithm::construct_ta ( ) const

private

Definition at line 153 of file TAMakerADCSimpleWindowAlgorithm.cpp.

{
  TLOG_DEBUG(TLVL_DEBUG_LOW) << "[TAM:ADCSW] I am constructing a trigger activity!";
  //TLOG_DEBUG(TRACE_NAME) << m_current_window;
 
  const TriggerPrimitive& last_tp = m_current_window.tp_list.back();
  uint64_t ch_min{last_tp.channel}, ch_max{last_tp.channel};
  uint64_t time_min{last_tp.time_start}, time_max{last_tp.time_start + last_tp.samples_over_threshold * k_sample_to_dts_ticks};
 
  uint64_t adc_peak{last_tp.adc_peak};
  uint64_t ch_peak{last_tp.channel};
  timestamp_t time_peak{last_tp.time_start + last_tp.samples_to_peak * k_sample_to_dts_ticks};
 
 
  std::vector<TriggerPrimitive> tp_list;
  tp_list.reserve(m_current_window.tp_list.size());
 
 
  // Copy the queue into the vector
  // And compute TA parameters
  for( const auto& tp : m_current_window.tp_list ) {
    
    ch_min = std::min(ch_min, tp.channel);
    ch_max = std::max(ch_max, tp.channel);
    time_min = std::min(time_min, tp.time_start);
    time_max = std::max(time_max, tp.time_start + tp.samples_over_threshold * k_sample_to_dts_ticks); // FIXME: Replace the hard-coded SOT to TOT scaling.
    if (tp.adc_peak > adc_peak) {
      adc_peak = tp.adc_peak;
      ch_peak = tp.channel;
      time_peak = tp.time_start + tp.samples_to_peak * k_sample_to_dts_ticks; // FIXME: Replace the hard-coded STP to `time_peak` conversion.
    }
 
    tp_list.push_back(tp);
  }
 
  TriggerActivity ta;
 
  ta.time_start = time_min;
  ta.time_end = time_max; 
  ta.time_peak = time_peak;
  ta.time_activity = time_peak;
  ta.channel_start = ch_min;
  ta.channel_end = ch_max;
  ta.channel_peak = ch_peak;
  ta.adc_integral = m_current_window.adc_integral;
  ta.adc_peak = adc_peak;
  ta.detid = last_tp.detid;
  ta.type = TriggerActivity::Type::kTPC;
  ta.algorithm = TriggerActivity::Algorithm::kADCSimpleWindow;
  ta.inputs.swap(tp_list);
  return ta;
}

process()

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

virtual

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 95 of file TAMakerADCSimpleWindowAlgorithm.cpp.

{
  
  // The first time operator is called, reset
  // window object.
  if(m_current_window.is_empty()){
    m_current_window.reset(input_tp);
    m_primitive_count++;
    return;
  } 
 
  // If the difference between the current TP's start time and the start of the window
  // is less than the specified window size, add the TP to the window.
  if((input_tp.time_start - m_current_window.time_start) < m_window_length){
    TLOG_DEBUG(TLVL_DEBUG_HIGH) << "[TAM:ADCSW] Window not yet complete, adding the input_tp to the window.";
    m_current_window.add(input_tp);
  }
  // If the addition of the current TP 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, make a TA and start 
  // a fresh window with the current TP.
  else if(m_current_window.adc_integral > m_adc_threshold){
    TLOG_DEBUG(TLVL_DEBUG_LOW) << "[TAM:ADCSW] ADC integral in window is greater than specified threshold.";
    output_ta.push_back(construct_ta());
    TLOG_DEBUG(TLVL_DEBUG_HIGH) << "[TAM:ADCSW] Resetting window with input_tp.";
    m_current_window.reset(input_tp);
  }
  // If it is not, move the window along.
  else{
    TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TAM:ADCSW] Window is at required length but adc threshold not met, shifting window along.";
    m_current_window.move(input_tp, m_window_length);
  }
  
  TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TAM:ADCSW] " << m_current_window;
 
  m_primitive_count++;
 
  return;
}

Member Data Documentation

k_sample_to_dts_ticks

const uint16_t triggeralgs::TAMakerADCSimpleWindowAlgorithm::k_sample_to_dts_ticks = 32

private

Definition at line 62 of file TAMakerADCSimpleWindowAlgorithm.hpp.

m_adc_threshold

uint32_t triggeralgs::TAMakerADCSimpleWindowAlgorithm::m_adc_threshold = 1200000

private

Definition at line 57 of file TAMakerADCSimpleWindowAlgorithm.hpp.

m_current_window

Window triggeralgs::TAMakerADCSimpleWindowAlgorithm::m_current_window

private

Definition at line 53 of file TAMakerADCSimpleWindowAlgorithm.hpp.

m_primitive_count

uint64_t triggeralgs::TAMakerADCSimpleWindowAlgorithm::m_primitive_count = 0

private

Definition at line 54 of file TAMakerADCSimpleWindowAlgorithm.hpp.

m_window_length

timestamp_t triggeralgs::TAMakerADCSimpleWindowAlgorithm::m_window_length = 100000

private

Definition at line 58 of file TAMakerADCSimpleWindowAlgorithm.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/ADCSimpleWindow/TAMakerADCSimpleWindowAlgorithm.hpp
• /github/workspace/dunedaq/sourcecode/triggeralgs/src/TAMakerADCSimpleWindowAlgorithm.cpp