triggeralgs::TAMakerPlaneCoincidenceAlgorithm Class Reference

#include <TAMakerPlaneCoincidenceAlgorithm.hpp>

Inheritance diagram for triggeralgs::TAMakerPlaneCoincidenceAlgorithm:

Collaboration diagram for triggeralgs::TAMakerPlaneCoincidenceAlgorithm:

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 (TPWindow m_current_window) const
uint16_t	check_adjacency (TPWindow window) const
int	check_sot (TPWindow m_current_window) const
void	add_window_to_record (TPWindow window)
void	dump_window_record ()
void	dump_tp (TriggerPrimitive const &input_tp)

Private Attributes
TPWindow	m_current_window
uint64_t	m_primitive_count = 0
TPWindow	m_collection_window
TPWindow	m_induction1_window
TPWindow	m_induction2_window
std::string	m_channel_map_name = "VDColdboxTPCChannelMap"
uint16_t	m_adjacency_threshold = 15
int	m_max_adjacency = 0
uint32_t	m_sot_threshold = 2000
uint32_t	m_adc_threshold = 300000
uint16_t	m_adj_tolerance = 5
int	index = 0
uint16_t	ta_adc = 0
uint16_t	ta_channels = 0
timestamp_t	m_window_length = 3000
std::shared_ptr< dunedaq::detchannelmaps::TPCChannelMap >	channelMap = dunedaq::detchannelmaps::make_tpc_map(m_channel_map_name)
std::vector< TPWindow >	m_window_record

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 26 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

Member Function Documentation

add_window_to_record()

void TAMakerPlaneCoincidenceAlgorithm::add_window_to_record ( TPWindow window )

private

Definition at line 204 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  m_window_record.push_back(window);
  return;
}

check_adjacency()

uint16_t TAMakerPlaneCoincidenceAlgorithm::check_adjacency ( TPWindow window ) const

private

Definition at line 142 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  /* This function returns the adjacency value for the current window, where adjacency
  *  is defined as the maximum number of consecutive wires containing hits. It accepts
  *  a configurable tolerance paramter, which allows up to adj_tolerance missing hits
  *  on adjacent wires before restarting the adjacency count. */
 
  uint16_t adj = 1;              // Initialise adjacency, 1 for the first wire.
  uint16_t max = 0;              // Maximum adjacency of window, which this function returns
  unsigned int channel = 0;      // Current channel ID
  unsigned int next_channel = 0; // Next channel ID
  unsigned int next = 0;         // The next position in the hit channels vector
  unsigned int tol_count = 0;    // Tolerance count, should not pass adj_tolerance
 
  /* Generate a channelID ordered list of hit channels for this window */
  std::vector<int> chanList;
  for (auto tp : window.inputs) {
    chanList.push_back(tp.channel);
  }
  std::sort(chanList.begin(), chanList.end());
 
  /* ADAJACENCY LOGIC ====================================================================
  *  Adjcancency Tolerance = Number of times prepared to skip missed hits before resetting 
  *  the adjacency count. This accounts for things like dead channels / missed TPs. */
  for (size_t i = 0; i < chanList.size(); ++i) {
 
    next = (i + 1) % chanList.size(); // Loops back when outside of channel list range
    channel = chanList.at(i);
    next_channel = chanList.at(next); // Next channel with a hit
 
    // End of vector condition.
    if (next_channel == 0) { next_channel = channel - 1; }
 
    // Skip same channel hits.
    if (next_channel == channel) { continue; }
 
    // If next hit is on next channel, increment the adjacency count.
    else if (next_channel == channel + 1){ ++adj; }
 
    // If next channel is not on the next hit, but the 'second next', increase adjacency 
    // but also tally up with the tolerance counter.
    else if ((next_channel == channel + 2 || next_channel == channel + 3) && (tol_count < m_adj_tolerance)) { 
    ++adj;
        for (size_t i = 0 ; i < next_channel-channel ; ++i) ++tol_count;
    }
 
    // If next hit isn't within reach, end the adjacency count and check for a new max.
    // Reset variables for next iteration.
    else {
      if (adj > max) { max = adj; } 
      adj = 1;
      tol_count = 0;
    }
  }
 
  return max;
}

check_sot()

int TAMakerPlaneCoincidenceAlgorithm::check_sot ( TPWindow m_current_window ) const

private

Definition at line 259 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  // Here, we just want to sum up all the sot values for each TP within window,
  // and return this sot of the window.
  int window_sot = 0; 
  for (auto tp : m_current_window.inputs) {
    window_sot += tp.samples_over_threshold;
  }
 
  return window_sot;
}

configure()

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

virtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 100 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  TriggerActivityMaker::configure(config);
 
  if (config.is_object()) {
    if (config.contains("adc_threshold"))
      m_adc_threshold = config["adc_threshold"];
    if (config.contains("window_length"))
      m_window_length = config["window_length"];
    if (config.contains("adjacency_tolerance"))
      m_adj_tolerance = config["adjacency_tolerance"];
    if (config.contains("adjacency_threshold"))
      m_adjacency_threshold = config["adjacency_threshold"];
  }
 
}

construct_ta()

TriggerActivity TAMakerPlaneCoincidenceAlgorithm::construct_ta ( TPWindow m_current_window ) const

private

Definition at line 118 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
 
  TriggerPrimitive latest_tp_in_window = m_current_window.inputs.back();
 
  TriggerActivity ta;
  ta.time_start = m_current_window.time_start;
  ta.time_end = latest_tp_in_window.time_start + latest_tp_in_window.samples_over_threshold * 32;  // FIXME: Replace the hard-coded SOT to TOT scaling.
  ta.time_peak = latest_tp_in_window.samples_to_peak * 32 + latest_tp_in_window.time_start;  // FIXME: Replace hard-coded STP to `time_peak` conversion.
  ta.time_activity = ta.time_peak;
  ta.channel_start = latest_tp_in_window.channel;
  ta.channel_end = latest_tp_in_window.channel;
  ta.channel_peak = latest_tp_in_window.channel;
  ta.adc_integral = m_current_window.adc_integral;
  ta.adc_peak = latest_tp_in_window.adc_peak;
  ta.detid = latest_tp_in_window.detid;
  ta.type = TriggerActivity::Type::kTPC;
  ta.algorithm = TriggerActivity::Algorithm::kPlaneCoincidence;
  ta.inputs = m_current_window.inputs;
 
  return ta;
}

dump_tp()

void TAMakerPlaneCoincidenceAlgorithm::dump_tp ( TriggerPrimitive const & input_tp )

private

Definition at line 240 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  std::ofstream outfile;
  outfile.open("triggered_coldbox_tps.txt", std::ios_base::app);
 
  // Output relevant TP information to file
  outfile << input_tp.time_start << " ";          
  outfile << input_tp.samples_over_threshold << " "; // 50MHz ticks
  outfile << input_tp.samples_to_peak << " ";           
  outfile << input_tp.channel << " ";             // Offline channel ID
  outfile << input_tp.adc_integral << " ";        
  outfile << input_tp.adc_peak << " ";            
  outfile << input_tp.detid << " ";               // Det ID - Identifies detector element
  outfile.close();
 
  return;
}

dump_window_record()

void TAMakerPlaneCoincidenceAlgorithm::dump_window_record ( )

private

Definition at line 212 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
  std::ofstream outfile;
  outfile.open("window_record_tam.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() << ",";             // Number of unique channels with hits
    outfile << window.inputs.size() << ",";                // Number of TPs in TPWindow
    outfile << window.inputs.back().channel << ",";        // Last TP Channel ID
    outfile << window.inputs.back().time_start << ",";     // Last TP start time
    outfile << window.inputs.front().channel << ",";       // First TP Channel ID
    outfile << window.inputs.front().time_start << ",";    // First TP start time 
    outfile << check_adjacency(window) << ",";             // New adjacency value for the window
    outfile << check_sot(window) << std::endl;             // Summed window SOT
  }
 
  outfile.close();
  m_window_record.clear();
 
  return;
}

process()

void TAMakerPlaneCoincidenceAlgorithm::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 19 of file TAMakerPlaneCoincidenceAlgorithm.cpp.

{
 
  // Get the plane from which this hit arrived: 
  // U (induction) = 0, Y (induction) = 1, Z (collection) = 2, unconnected channel = 9999  
  uint plane = channelMap->get_plane_from_offline_channel(input_tp.channel);
  bool isU = plane == 0;  // Induction1 = U
  bool isY = plane == 1;  // Induction2 = Y
  bool isZ = plane == 2;  // Collection = Z
 
  // The first time operator() is called, reset the window object(s).
  if (m_induction1_window.is_empty() && isU) { m_induction1_window.reset(input_tp); m_primitive_count++; return; }
  if (m_induction2_window.is_empty() && isY) { m_induction2_window.reset(input_tp); m_primitive_count++; return; }
  if (m_collection_window.is_empty() && isZ) { m_collection_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 corresponding window.
  if (isU && (input_tp.time_start - m_induction1_window.time_start) < m_window_length) m_induction1_window.add(input_tp);
  if (isY && (input_tp.time_start - m_induction2_window.time_start) < m_window_length) m_induction2_window.add(input_tp);
  if (isZ && (input_tp.time_start - m_collection_window.time_start) < m_window_length) m_collection_window.add(input_tp); 
 
  // ISSUE - We are checking the collection plane window too early: Every time we are NOT receiving a collection plane
  // TP, we're checking the trigger conditions. Fix this immediately and rerun trigger runs to test.
 
  // ===================================================================================
  // Below this line, we begin our hierarchy of checks for a low energy event,
  // taking advantage of the newly gained induction hits window.
  // ===================================================================================
 
  // Our windows have ADC Sum, Time Over Threshold, Multiplicity & Adjacency properties.
  // Take advantage of these to screen the activities passed to more involved checks.
 
  // 1) REQUIRE ADC SPIKE FROM INDUCTION AND CHECK ADJACENCY ===========================
  // We're looking for a localised spike of ADC (short time window) and then a short
  // adjacency corresponding to an electron track/shower.
  
  // ISSUE - We are checking the collection plane window too early and too frequently probably:
  // Every time we are NOT receiving a collection plane TP, we're checking the trigger conditions. 
  // Fix this immediately and rerun trigger runs to test.
  // Introduce bool to check for collection window completeness:
  bool collectionComplete = (input_tp.time_start - m_collection_window.time_start) > m_window_length;
  // Then require that the collection window be complete in the adjacency checks
  if (!collectionComplete) { } // Do nothing
  else if (collectionComplete && (m_induction1_window.adc_integral + m_induction2_window.adc_integral + m_collection_window.adc_integral)
            > m_adc_threshold && check_adjacency(m_collection_window) >= m_adjacency_threshold){
 
          TLOG_DEBUG(TLVL_DEBUG_MEDIUM) << "[TAM:PC] Emitting low energy trigger with " << m_induction1_window.adc_integral << " U "
                  << m_induction2_window.adc_integral << " Y induction ADC sums and "
                  << check_adjacency(m_collection_window) << " adjacent collection hits.";
   
          // Initial studies - output the TPs of the collection plane window that caused this trigger
          add_window_to_record(m_collection_window);
          dump_window_record();
          m_window_record.clear();     
 
          // Initial studies - Also dump the TPs that have contributed to this TA decision
          for(auto tp : m_collection_window.inputs) dump_tp(tp);
 
          // We have fulfilled our trigger condition, construct a TA and reset/flush the windows
          // to ensure they're all in the same "time zone"!
          output_ta.push_back(construct_ta(m_collection_window));
          if (isZ) m_collection_window.reset(input_tp);
          else m_collection_window.clear();
          if (isU) m_induction1_window.reset(input_tp); 
          else m_induction1_window.clear();
          if (isY) m_induction2_window.reset(input_tp);   
          else m_induction2_window.clear();
  }
 
  // Otherwise, slide the relevant window along using the current TP.
  else {
    if (isU) m_induction1_window.move(input_tp, m_window_length);
    else if (isY) m_induction2_window.move(input_tp, m_window_length);
    else if (isZ) m_collection_window.move(input_tp, m_window_length);
  }
  m_primitive_count++;
 
  return;
}

Member Data Documentation

channelMap

std::shared_ptr<dunedaq::detchannelmaps::TPCChannelMap> triggeralgs::TAMakerPlaneCoincidenceAlgorithm::channelMap = dunedaq::detchannelmaps::make_tpc_map(m_channel_map_name)

private

Definition at line 59 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

index

int triggeralgs::TAMakerPlaneCoincidenceAlgorithm::index = 0

private

Definition at line 53 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_adc_threshold

uint32_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_adc_threshold = 300000

private

Definition at line 51 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_adj_tolerance

uint16_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_adj_tolerance = 5

private

Definition at line 52 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_adjacency_threshold

uint16_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_adjacency_threshold = 15

private

Definition at line 48 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_channel_map_name

std::string triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_channel_map_name = "VDColdboxTPCChannelMap"

private

Definition at line 47 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_collection_window

TPWindow triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_collection_window

private

Definition at line 42 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_current_window

TPWindow triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_current_window

private

Definition at line 36 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_induction1_window

TPWindow triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_induction1_window

private

Definition at line 43 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_induction2_window

TPWindow triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_induction2_window

private

Definition at line 44 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_max_adjacency

int triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_max_adjacency = 0

private

Definition at line 49 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_primitive_count

uint64_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_primitive_count = 0

private

Definition at line 37 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_sot_threshold

uint32_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_sot_threshold = 2000

private

Definition at line 50 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_window_length

timestamp_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_window_length = 3000

private

Definition at line 56 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

m_window_record

std::vector<TPWindow> triggeralgs::TAMakerPlaneCoincidenceAlgorithm::m_window_record

private

Definition at line 65 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

ta_adc

uint16_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::ta_adc = 0

private

Definition at line 54 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

ta_channels

uint16_t triggeralgs::TAMakerPlaneCoincidenceAlgorithm::ta_channels = 0

private

Definition at line 55 of file TAMakerPlaneCoincidenceAlgorithm.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/PlaneCoincidence/TAMakerPlaneCoincidenceAlgorithm.hpp
• /github/workspace/dunedaq/sourcecode/triggeralgs/src/TAMakerPlaneCoincidenceAlgorithm.cpp