#include <TAMakerSWIFTAlgorithm.hpp>

Inheritance diagram for triggeralgs::TriggerActivityMakerSWIFT:

Collaboration diagram for triggeralgs::TriggerActivityMakerSWIFT:

Public Member Functions
void	process (const TriggerPrimitive &input_tp, std::vector< TriggerActivity > &output_tas) override
	TP processing function that creates & fills TAs.
void	configure (const nlohmann::json &config)
void	set_ta_attributes ()
void	flush (timestamp_t until, std::vector< TriggerActivity > &output_tas) override
bool	preprocess (const TriggerPrimitive &input_tp)
	TP pre-processing/filtering.
Public Member Functions inherited from triggeralgs::TriggerActivityMaker
virtual	~TriggerActivityMaker ()=default
void	operator() (const TriggerPrimitive &input_tp, std::vector< TriggerActivity > &output_ta)
virtual void	postprocess (std::vector< TriggerActivity > &output_ta)
	Post-processing/filtering of the TAs, e.g. prescale.

Private Types
enum class	WindowDecision { kReject , kInspect , kAccept }

Private Member Functions
void	close_window (std::vector< TriggerActivity > &output_tas)
void	reset_window_state (uint64_t new_window_start)
uint64_t	extract_dominant_cluster_energy (const std::vector< TriggerPrimitive > &tps, float eps, int min_samples)

Private Attributes
TriggerActivity	m_current_ta
uint64_t	m_window_length
uint64_t	m_inspect_energy_threshold_sadc
uint64_t	m_accept_energy_threshold_sadc
uint16_t	m_min_adc_peak
uint16_t	m_min_samples_over_threshold
float	m_cm_per_tick
float	m_wire_pitch
int	m_db_min_samples
float	m_db_eps
uint64_t	m_cluster_energy_cut_sadc
bool	m_initialised = false
uint64_t	m_window_start = 0
uint64_t	m_window_energy_sadc = 0
uint16_t	m_tp_count = 0

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 17 of file TAMakerSWIFTAlgorithm.hpp.

Member Enumeration Documentation

◆ WindowDecision

enum class triggeralgs::TriggerActivityMakerSWIFT::WindowDecision

strongprivate

Enumerator
kReject
kInspect
kAccept

Definition at line 58 of file TAMakerSWIFTAlgorithm.hpp.

58{ kReject, kInspect, kAccept };

Member Function Documentation

◆ close_window()

void triggeralgs::TriggerActivityMakerSWIFT::close_window ( std::vector< TriggerActivity > & output_tas )

private

Definition at line 95 of file TAMakerSWIFTAlgorithm.cpp.

                                                                                     {
 
    if (m_current_ta.inputs.empty()) return;
 
    //Prompt window categorisatoin : immidiate accept, inspect, reject based on local energy in window
    WindowDecision decision;
    if (m_window_energy_sadc >= m_accept_energy_threshold_sadc) decision = WindowDecision::kAccept;
    else if (m_window_energy_sadc >= m_inspect_energy_threshold_sadc) decision = WindowDecision::kInspect;
    else  return; // Reject
 
    // cluster inspect cases
    if (decision == WindowDecision::kInspect) {
      const uint64_t max_cluster_energy =  extract_dominant_cluster_energy(m_current_ta.inputs, m_db_eps, m_db_min_samples);
      if (max_cluster_energy <= m_cluster_energy_cut_sadc) return; // reject window if it didn't pass inspection
    }
 
    // Emit TA: should only reach this step if dealing with  Accept, or Inspect windows that passed clustering
    set_ta_attributes();
    output_tas.push_back(m_current_ta);
  }

◆ configure()

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

virtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 13 of file TAMakerSWIFTAlgorithm.cpp.

  {
    //window settings
    m_window_length                 = config.value("window_length", 32000); // in DTS ticks (32 * 1000 readout ticks @ 500ns/tick)
    m_inspect_energy_threshold_sadc = config.value("inspect_energy_threshold_sadc", 15000);
    m_accept_energy_threshold_sadc  = config.value("accept_energy_threshold_sadc", 55000);
 
    //tp filtering settings
    m_min_adc_peak               = config.value("min_adc_peak", 80); //ADC
    m_min_samples_over_threshold = config.value("min_samples_over_threshold", 256); // 8 * 32 DTS ticks while still using TPv1 FIXME
 
    //clustering
    //these depend on detector properties. default values for HD
    m_cm_per_tick              = config.value("cm_per_tick", 0.016 * 0.16); // sampling rate [us/tick] * drift velocity [cm/us]
    m_wire_pitch               = config.value("wire_pitch", 0.48); // cm
    m_db_min_samples           = config.value("min_samples", 2); //min. number of TPs for valid cluster
    m_db_eps                   = config.value("epsilon", 2); //dbscan search radius in cm
    m_cluster_energy_cut_sadc  = config.value("cluster_energy_cut_sadc", 22000); // min energy of dominant cluster eng. in window for acceptance
 
    assert(m_window_length > 0);
  }

◆ extract_dominant_cluster_energy()

uint64_t triggeralgs::TriggerActivityMakerSWIFT::extract_dominant_cluster_energy	(	const std::vector< TriggerPrimitive > &	tps,
		float	eps,
		int	min_samples )

private

Definition at line 121 of file TAMakerSWIFTAlgorithm.cpp.

                                                                                                                                       {
 
    struct Point {
      float z;
      float t;
      uint64_t adc;
    };
 
    //since time and channel are in different units, express TPs as points in unified coordinate system (z,t)
    std::vector<Point> points;
    points.reserve(tps.size());
    for (const auto& tp : tps) {
      points.push_back({tp.channel * m_wire_pitch, (tp.time_start - m_window_start) * m_cm_per_tick, tp.adc_integral});
    }
 
    const int N = points.size(); //number of elements to cluster
    int cluster_id = 0;
    std::vector<int> labels(N, -1); // initialise all labels to noise for now
    std::vector<uint8_t> visited(N, 0);
    float eps2 = eps * eps; //clustering radius
 
    for (int i = 0; i < N; ++i) {
      if (visited[i]) continue;
      visited[i] = 1;
 
      std::vector<int> neigh;
      const float zi = points[i].z;
      const float ti = points[i].t;
      for (int j = 0; j < N; ++j) {
    float dz = points[j].z - zi;
    float dt = points[j].t - ti;
    if (dz*dz + dt*dt <= eps2) neigh.push_back(j);
      }
 
      if (neigh.size() < static_cast<size_t>(min_samples)) {
    labels[i] = -1;
    continue;
      }
 
      labels[i] = cluster_id;
 
      size_t k = 0;
      while (k < neigh.size()) {
    int j = neigh[k];
 
    if (!visited[j]) {
      visited[j] = 1;
 
      std::vector<int> neigh2;
      const float zj = points[j].z;
      const float tj = points[j].t;
      for (int m = 0; m < N; ++m) {
        float dz = points[m].z - zj;
        float dt = points[m].t - tj;
        if (dz*dz + dt*dt <= eps2) neigh2.push_back(m);
      }
      if (neigh2.size() >= static_cast<size_t>(min_samples)) {
        for (int m : neigh2) {
          if (std::find(neigh.begin(), neigh.end(), m) == neigh.end())
        neigh.push_back(m);
        }
      }
    }
 
    if (labels[j] == -1) labels[j] = cluster_id;
    ++k;
      }
      ++cluster_id;
    }
 
    // once clusters are formed, calculate the energies
    std::vector<uint64_t> cluster_sums(cluster_id, 0);
    for (int i = 0; i < N; ++i) {
      if (labels[i] >= 0) cluster_sums[labels[i]] += points[i].adc;
    }
    //return dominant cluster energy in window
    if (cluster_sums.empty()) return 0;
    return *std::max_element(cluster_sums.begin(), cluster_sums.end());
  }

◆ flush()

void triggeralgs::TriggerActivityMakerSWIFT::flush	(	timestamp_t	until,
		std::vector< TriggerActivity > &	output_tas )

overridevirtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 238 of file TAMakerSWIFTAlgorithm.cpp.

  {
    if (!m_initialised) return;
    close_window(output_tas);
  }

◆ preprocess()

bool triggeralgs::TriggerActivityMakerSWIFT::preprocess ( const TriggerPrimitive & input_tp )

virtual

TP pre-processing/filtering.

Takes a TP and returns true or false depending whether we want to process that TP into a TA algorithm.

Todo

: Implement tp-filtering, e.g. SOT, plane, channel and whatnot

: Implement something smarter & more efficient if no filtering: vector of functions, or c-o-c

Parameters

[in] intput_tp input TP reference for filtering

Returns: bool true if we want to keep the TP

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 36 of file TAMakerSWIFTAlgorithm.cpp.

                                                                             {
    if ((input_tp.adc_peak < m_min_adc_peak) && (input_tp.samples_over_threshold < m_min_samples_over_threshold )) {
      return false;
    }
    return true;
  }

◆ process()

void triggeralgs::TriggerActivityMakerSWIFT::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 54 of file TAMakerSWIFTAlgorithm.cpp.

  {
 
    // Apply TP filtering
    if (!preprocess(input_tp)) {
      return;
    }
 
    // If TP is valid, determine which window this TP belongs to
    const uint64_t tp_window_start = (input_tp.time_start / m_window_length) * m_window_length;
 
    // Initialise on first TP
    if (!m_initialised) {
 
      //create TA instance once at run start
      m_current_ta = TriggerActivity();
 
      //reset window state
      reset_window_state(tp_window_start);
      m_initialised = true;
    }
 
    //if TP belongs to past window (already closed), reject it (not ideal)
    if (tp_window_start < m_window_start){
      return;
    }
 
    //if TP belongs to future window, close existing TA and start a new one at current time
    if (tp_window_start > m_window_start){
      close_window(output_tas);
      reset_window_state(tp_window_start);
    }
 
    //If we got here, the TP belongs to the current window
    m_current_ta.inputs.push_back(input_tp);
    m_window_energy_sadc += input_tp.adc_integral;
    ++m_tp_count;
  }

◆ reset_window_state()

void triggeralgs::TriggerActivityMakerSWIFT::reset_window_state ( uint64_t new_window_start )

private

Definition at line 44 of file TAMakerSWIFTAlgorithm.cpp.

                                                                              {
    m_window_start          = new_window_start;
    m_window_energy_sadc    = 0;
    m_tp_count              = 0;
    m_current_ta            = TriggerActivity(); 
    m_current_ta.time_start = m_window_start;
  }

◆ set_ta_attributes()

void triggeralgs::TriggerActivityMakerSWIFT::set_ta_attributes ( )

Definition at line 203 of file TAMakerSWIFTAlgorithm.cpp.

  {
    m_current_ta.time_start = m_window_start;
    m_current_ta.time_end   = m_window_start + m_window_length;
    m_current_ta.adc_integral = m_window_energy_sadc;
 
    const TriggerPrimitive& first_tp = m_current_ta.inputs.front();
    m_current_ta.detid = first_tp.detid;
    m_current_ta.type = TriggerActivity::Type::kTPC;
    m_current_ta.algorithm = TriggerActivity::Algorithm::kSWIFT; 
 
 
    dunedaq::trgdataformats::channel_t min_ch = first_tp.channel;
    dunedaq::trgdataformats::channel_t max_ch = first_tp.channel;
 
    // Peak quantities
    m_current_ta.adc_peak = 0;
    for (const auto& tp : m_current_ta.inputs) {
      if (tp.channel < min_ch) min_ch = tp.channel;
      if (tp.channel > max_ch) max_ch = tp.channel;
 
      if (tp.adc_peak > m_current_ta.adc_peak) {
    m_current_ta.adc_peak = tp.adc_peak;
    m_current_ta.channel_peak = tp.channel;
    m_current_ta.time_peak = tp.time_start;
      }
    }
 
    m_current_ta.channel_start = min_ch;
    m_current_ta.channel_end   = max_ch;
    m_current_ta.time_activity = m_current_ta.time_peak;
 
  }

Member Data Documentation

◆ m_accept_energy_threshold_sadc

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_accept_energy_threshold_sadc

private

Definition at line 35 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_cluster_energy_cut_sadc

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_cluster_energy_cut_sadc

private

Definition at line 46 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_cm_per_tick

float triggeralgs::TriggerActivityMakerSWIFT::m_cm_per_tick

private

Definition at line 42 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_current_ta

TriggerActivity triggeralgs::TriggerActivityMakerSWIFT::m_current_ta

private

Definition at line 27 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_db_eps

float triggeralgs::TriggerActivityMakerSWIFT::m_db_eps

private

Definition at line 45 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_db_min_samples

int triggeralgs::TriggerActivityMakerSWIFT::m_db_min_samples

private

Definition at line 44 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_initialised

bool triggeralgs::TriggerActivityMakerSWIFT::m_initialised = false

private

Definition at line 52 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_inspect_energy_threshold_sadc

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_inspect_energy_threshold_sadc

private

Definition at line 34 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_min_adc_peak

uint16_t triggeralgs::TriggerActivityMakerSWIFT::m_min_adc_peak

private

Definition at line 38 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_min_samples_over_threshold

uint16_t triggeralgs::TriggerActivityMakerSWIFT::m_min_samples_over_threshold

private

Definition at line 39 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_tp_count

uint16_t triggeralgs::TriggerActivityMakerSWIFT::m_tp_count = 0

private

Definition at line 55 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_window_energy_sadc

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_window_energy_sadc = 0

private

Definition at line 54 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_window_length

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_window_length

private

Definition at line 33 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_window_start

uint64_t triggeralgs::TriggerActivityMakerSWIFT::m_window_start = 0

private

Definition at line 53 of file TAMakerSWIFTAlgorithm.hpp.

◆ m_wire_pitch

float triggeralgs::TriggerActivityMakerSWIFT::m_wire_pitch

private

Definition at line 43 of file TAMakerSWIFTAlgorithm.hpp.

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

/github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/SWIFT/TAMakerSWIFTAlgorithm.hpp
/github/workspace/dunedaq/sourcecode/triggeralgs/src/TAMakerSWIFTAlgorithm.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ WindowDecision

Member Function Documentation

◆ close_window()

◆ configure()

◆ extract_dominant_cluster_energy()

◆ flush()

◆ preprocess()

◆ process()

◆ reset_window_state()

◆ set_ta_attributes()

Member Data Documentation

◆ m_accept_energy_threshold_sadc

◆ m_cluster_energy_cut_sadc

◆ m_cm_per_tick

◆ m_current_ta

◆ m_db_eps

◆ m_db_min_samples

◆ m_initialised

◆ m_inspect_energy_threshold_sadc

◆ m_min_adc_peak

◆ m_min_samples_over_threshold

◆ m_tp_count

◆ m_window_energy_sadc

◆ m_window_length

◆ m_window_start

◆ m_wire_pitch