triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm Class Reference

#include <TAMakerProtoDUNEBSMWindowAlgorithm.hpp>

Inheritance diagram for triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm:

Collaboration diagram for triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm:

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)
	~TAMakerProtoDUNEBSMWindowAlgorithm () override=default
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
bool	compute_treelite_classification ()
TriggerActivity	construct_ta () const

Private Attributes
ProtoDUNEBSMWindow	m_current_window
timestamp_t	m_last_pred_time = 0
uint64_t	m_primitive_count = 0
const int	nbatch = 1
std::vector< float >	flat_batched_inputs
std::vector< Entry >	flat_batched_Entries
uint32_t	m_adc_threshold_induction = 12000000
float	m_bdt_threshold = 0.999
std::string	m_channel_map_name = "PD2VDTPCChannelMap"
const uint32_t	m_adc_threshold_collection = 200000
const timestamp_t	m_window_length = 20000
timestamp_t	m_bin_length = 2000
const int	m_num_timebins = 10
const int	m_num_chanbins = 10
std::shared_ptr< dunedaq::detchannelmaps::TPCChannelMap >	channelMap
DetectorPlaneMap	m_det_plane_map
std::unique_ptr< PDVDEffectiveChannelMap >	m_pdvd_eff_channel_mapper = nullptr
bool	m_pdvd_map = true
bool	m_collection_plane = false
channel_t	m_first_channel
channel_t	m_n_channels_on_plane
std::unique_ptr< CompiledModelInterface >	m_compiled_model_interface

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 24 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

Constructor & Destructor Documentation

~TAMakerProtoDUNEBSMWindowAlgorithm()

triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::~TAMakerProtoDUNEBSMWindowAlgorithm ( )

overridedefault

Member Function Documentation

compute_treelite_classification()

bool TAMakerProtoDUNEBSMWindowAlgorithm::compute_treelite_classification ( )

private

Definition at line 178 of file TAMakerProtoDUNEBSMWindowAlgorithm.cpp.

                                                                         {
  
  m_last_pred_time = m_current_window.time_start;
  
  m_current_window.bin_window(
      flat_batched_inputs, 
      m_num_timebins, m_bin_length,
      m_num_chanbins, m_n_channels_on_plane, m_first_channel,
      m_pdvd_eff_channel_mapper, m_pdvd_map
      );
  
  m_current_window.fill_entry_window(flat_batched_Entries, flat_batched_inputs); 
    
  std::vector<float> result(nbatch, 0.0f);
  
  m_compiled_model_interface->Predict(flat_batched_Entries.data(), result.data());
  
  return m_compiled_model_interface->Classify(result.data(), m_bdt_threshold);
 
}

configure()

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

virtual

Reimplemented from triggeralgs::TriggerActivityMaker.

Definition at line 112 of file TAMakerProtoDUNEBSMWindowAlgorithm.cpp.

{
  if (config.is_object()){
    if (config.contains("channel_map_name")) m_channel_map_name = config["channel_map_name"];
    if (config.contains("adc_threshold_induction")) m_adc_threshold_induction = config["adc_threshold_induction"];
    if (config.contains("bdt_threshold")) m_bdt_threshold = config["bdt_threshold"];
  }
  else{
    TLOG_DEBUG(TLVL_IMPORTANT) << "[TAM:BSMW] Use DEFAULT values of channel_map_name, adc_threshold_induction and bdt_threshold.";
  }
  
  TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TAM:BSMW] Channel map name is " << m_channel_map_name <<
    ". ADC threshold for the induction planes set to " << m_adc_threshold_induction << 
    ". BDT threshold for collection plane set to " << m_bdt_threshold;
  
  channelMap = dunedaq::detchannelmaps::make_tpc_map(m_channel_map_name);
 
  // If we are in PD-VD, set boolean to true to enable effective channel mapping
  if (m_channel_map_name == "PD2VDTPCChannelMap" || m_channel_map_name == "PD2VDBottomTPCChannelMap" ||
      m_channel_map_name == "PD2VDTopTPCChannelMap") {
    m_pdvd_map = true;
  } else { // else we are in PD-HD and we use true channel mapping
    m_pdvd_map = false;
  }
 
  m_bin_length = static_cast<timestamp_t>(m_window_length / m_num_timebins);
 
  m_compiled_model_interface = std::make_unique<CompiledModelInterface>(nbatch, m_pdvd_map);
 
  const size_t num_feature = m_compiled_model_interface->GetNumFeatures();
 
  flat_batched_inputs.resize(num_feature);
 
  flat_batched_Entries.clear();
  for (size_t i = 0; i < num_feature; ++i) {
    union Entry zero;
    zero.fvalue = 0.0;
    flat_batched_Entries.emplace_back(zero);
  }
}

construct_ta()

TriggerActivity TAMakerProtoDUNEBSMWindowAlgorithm::construct_ta ( ) const

private

Definition at line 154 of file TAMakerProtoDUNEBSMWindowAlgorithm.cpp.

{
  TLOG_DEBUG(TLVL_DEBUG_LOW) << "[TAM:BSMW] I am constructing a trigger activity!";
 
  TriggerPrimitive latest_tp_in_window = m_current_window.tp_list.back();
  // The time_peak, time_activity, channel_* and adc_peak fields of this TA are irrelevent
  // for the purpose of this trigger alg.
  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;
  ta.time_peak = latest_tp_in_window.samples_to_peak * 32 + latest_tp_in_window.time_start;
  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::kProtoDUNEBSMWindow;
  ta.inputs = m_current_window.tp_list;
  return ta;
}

process()

void TAMakerProtoDUNEBSMWindowAlgorithm::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 24 of file TAMakerProtoDUNEBSMWindowAlgorithm.cpp.

{
  
  if(m_current_window.is_empty()){
    // Reset window with new TP
    m_current_window.reset(input_tp);
    // Initialise last time an XGBoost prediction was made
    m_last_pred_time = input_tp.time_start;
    // Iterate number of TPs in the window
    m_primitive_count++;
    // First time operator is called set ROP first and last channel
    unsigned int detelement = channelMap->get_element_id_from_offline_channel(input_tp.channel);
    unsigned int plane = channelMap->get_plane_from_offline_channel(input_tp.channel);
 
    // Are we on the collection plane? Use XGBoost model for collection plane TPs
    // evaluate the sum of the TP charge if on induction planes
    // Induction plane IDs = 0, 1
    // Collection plane ID = 2
    if (plane > 1) m_collection_plane = true;
 
    // Use PlaneInfo object to get the first and last channels on plane
    PlaneInfo plane_info = m_det_plane_map.get_plane_info(m_channel_map_name, detelement, plane);
    m_first_channel = static_cast<channel_t>(plane_info.min_channel);
    m_n_channels_on_plane = static_cast<channel_t>(plane_info.n_channels);
 
    // If we are in PD-VD use 'effective' channel mapping for CRPs
    // (but only for collection plane)
    if (m_pdvd_map && m_collection_plane) {
      m_pdvd_eff_channel_mapper = std::make_unique<PDVDEffectiveChannelMap>(plane_info.min_channel, plane_info.n_channels);
      // Get the first effective channel and number of effective channels on the plane
      m_first_channel = m_pdvd_eff_channel_mapper->remapCollectionPlaneChannel(m_first_channel);
      m_n_channels_on_plane = m_pdvd_eff_channel_mapper->getNEffectiveChannels();
    }
 
    TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TAM:BSMW] 1st Chan = " << m_first_channel << ", N channels on plane = " << m_n_channels_on_plane << std::endl
      << "Number of channel bins = " << m_num_chanbins;
    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:BSMW] 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
  // First, if these are not collection plane TPs, just evaluate the total charge
  // If the total charge on the induction plane crosses a threshold, create a TA
  else if(!m_collection_plane && m_current_window.adc_integral > m_adc_threshold_induction){
    TLOG_DEBUG(TLVL_DEBUG_LOW) << "[TAM:BSMW] ADC integral in window is greater than specified threshold.";
    output_ta.push_back(construct_ta());
    TLOG_DEBUG(TLVL_DEBUG_HIGH) << "[TAM:BSMW] Resetting window with input_tp.";                           
    m_current_window.reset(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
  // Check the TPs are on the collection plane - if they are we can use XGBoost
  // Instead check whether it has been long enough since the last XGBoost prediction 
  // then run the model to determine whether to create a TA
  else if (m_collection_plane &&
           (m_current_window.time_start - m_last_pred_time) > m_bin_length && // check enough time has passed since last window
           m_current_window.adc_integral > m_adc_threshold_collection && // set a low minimum threshold for the ADC integral sum
           compute_treelite_classification() // XGBoost classifier 
          )
  {
    TLOG_DEBUG(TLVL_DEBUG_LOW) << "[TAM:BSMW] XGBoost neutrino prob. is greater than specified threshold.";
    output_ta.push_back(construct_ta());
    TLOG_DEBUG(TLVL_DEBUG_HIGH) << "[TAM:BSMW] 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:BSMW] Window is at required length but adc/bdt threshold not met, shifting window along.";
    m_current_window.move(input_tp, m_window_length);
  }
  
  TLOG_DEBUG(TLVL_DEBUG_ALL) << "[TAM:BSMW] " << m_current_window;
 
  m_primitive_count++;
 
  return;
 
}

Member Data Documentation

channelMap

std::shared_ptr<dunedaq::detchannelmaps::TPCChannelMap> triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::channelMap

private

Definition at line 75 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

flat_batched_Entries

std::vector<Entry> triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::flat_batched_Entries

private

Definition at line 52 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

flat_batched_inputs

std::vector<float> triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::flat_batched_inputs

private

Definition at line 50 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_adc_threshold_collection

const uint32_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_adc_threshold_collection = 200000

private

Definition at line 63 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_adc_threshold_induction

uint32_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_adc_threshold_induction = 12000000

private

Definition at line 55 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_bdt_threshold

float triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_bdt_threshold = 0.999

private

Definition at line 56 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_bin_length

timestamp_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_bin_length = 2000

private

Definition at line 68 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_channel_map_name

std::string triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_channel_map_name = "PD2VDTPCChannelMap"

private

Definition at line 57 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_collection_plane

bool triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_collection_plane = false

private

Definition at line 87 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_compiled_model_interface

std::unique_ptr<CompiledModelInterface> triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_compiled_model_interface

private

Definition at line 94 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_current_window

ProtoDUNEBSMWindow triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_current_window

private

Definition at line 41 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_det_plane_map

DetectorPlaneMap triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_det_plane_map

private

Definition at line 79 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_first_channel

channel_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_first_channel

private

Definition at line 89 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_last_pred_time

timestamp_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_last_pred_time = 0

private

Definition at line 43 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_n_channels_on_plane

channel_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_n_channels_on_plane

private

Definition at line 91 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_num_chanbins

const int triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_num_chanbins = 10

private

Definition at line 72 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_num_timebins

const int triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_num_timebins = 10

private

Definition at line 70 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_pdvd_eff_channel_mapper

std::unique_ptr<PDVDEffectiveChannelMap> triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_pdvd_eff_channel_mapper = nullptr

private

Definition at line 83 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_pdvd_map

bool triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_pdvd_map = true

private

Definition at line 85 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_primitive_count

uint64_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_primitive_count = 0

private

Definition at line 44 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

m_window_length

const timestamp_t triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::m_window_length = 20000

private

Definition at line 64 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

nbatch

const int triggeralgs::TAMakerProtoDUNEBSMWindowAlgorithm::nbatch = 1

private

Definition at line 48 of file TAMakerProtoDUNEBSMWindowAlgorithm.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/triggeralgs/include/triggeralgs/ProtoDUNEBSMWindow/TAMakerProtoDUNEBSMWindowAlgorithm.hpp
• /github/workspace/dunedaq/sourcecode/triggeralgs/src/TAMakerProtoDUNEBSMWindowAlgorithm.cpp