Line data    Source code

       1              : #include "triggeralgs/ProtoDUNEBSMWindow/ProtoDUNEBSMWindow.hpp"
       2              : 
       3              : #include <ostream>
       4              : #include <vector>
       5              : #include <numeric>
       6              : 
       7              : namespace triggeralgs {
       8              :       
       9            0 : bool ProtoDUNEBSMWindow::is_empty() const{
      10            0 :   return tp_list.empty();
      11              : };
      12              : 
      13            0 : void ProtoDUNEBSMWindow::add(TriggerPrimitive const &input_tp){
      14              :   // Add the input TP's contribution to the total 
      15              :   // ADC and add it to the TP list.
      16            0 :   adc_integral += input_tp.adc_integral;
      17            0 :   tp_list.push_back(input_tp);
      18            0 : };
      19              : 
      20            0 : void ProtoDUNEBSMWindow::clear(){
      21            0 :   tp_list.clear();
      22            0 : };
      23              :       
      24            0 : void ProtoDUNEBSMWindow::move(TriggerPrimitive const &input_tp, timestamp_t const &window_length){
      25              :   // Find all of the TPs in the window that need to be removed
      26              :   // if the input_tp is to be added and the size of the window
      27              :   // is to be conserved.
      28              :   // Substract those TPs' contribution from the total window ADC.
      29            0 :   uint32_t n_tps_to_erase = 0;
      30            0 :   for(auto tp : tp_list){
      31            0 :     if(!(input_tp.time_start-tp.time_start < window_length)){
      32            0 :       n_tps_to_erase++;
      33            0 :       adc_integral -= tp.adc_integral;
      34              :     }
      35              :     else break;
      36              :   }
      37              :   // Erase the TPs from the window.
      38            0 :   tp_list.erase(tp_list.begin(), tp_list.begin()+n_tps_to_erase);
      39              :   // Make the window start time the start time of what is now the
      40              :   // first TP.
      41            0 :   if(!tp_list.empty()){
      42            0 :     time_start = tp_list.front().time_start;
      43            0 :     add(input_tp);
      44              :   }
      45            0 :   else reset(input_tp);
      46            0 : };
      47              : 
      48            0 : void ProtoDUNEBSMWindow::reset(TriggerPrimitive const &input_tp){
      49              :   // Empty the TP list.
      50            0 :   tp_list.clear();
      51              :   // Set the start time of the window to be the start time of the 
      52              :   // input_tp.
      53            0 :   time_start = input_tp.time_start;
      54              :   // Start the total ADC integral.
      55            0 :   adc_integral = input_tp.adc_integral;
      56              :   // Add the input TP to the TP list.
      57            0 :   tp_list.push_back(input_tp);
      58            0 : };
      59              : 
      60            0 : void ProtoDUNEBSMWindow::bin_window(
      61              :     std::vector<float> &input, 
      62              :     int num_time_bins, timestamp_t time_bin_width,
      63              :     int num_chan_bins, channel_t n_channels_on_plane, channel_t first_channel,
      64              :     std::unique_ptr<PDVDEffectiveChannelMap> const &effective_channel_mapper,
      65              :     bool use_pdvd_map) {
      66              : 
      67            0 :   std::fill(input.begin(), input.end(), 0.0f);
      68              : 
      69            0 :   const float inv_time_bin_width = 1.0f / time_bin_width;
      70              : 
      71            0 :   for (const TriggerPrimitive& tp : tp_list) {
      72            0 :     channel_t temp_tp_channel = tp.channel;
      73              :     // If in PD-VD convert to effective channel here
      74            0 :     if (effective_channel_mapper && use_pdvd_map) {
      75            0 :       temp_tp_channel = effective_channel_mapper->remapCollectionPlaneChannel(temp_tp_channel);
      76              :     }
      77            0 :     size_t time_bin = static_cast<size_t>((tp.time_start - time_start) * inv_time_bin_width);
      78              :     // Channel bin calculation matches model training - remainder channels are appended to 10th channel bin 
      79            0 :     size_t channel_bin = static_cast<size_t>(((temp_tp_channel - first_channel) * num_chan_bins) / n_channels_on_plane);
      80              : 
      81            0 :     if (time_bin < num_time_bins && channel_bin < num_chan_bins) {
      82            0 :       size_t index = channel_bin * num_time_bins + time_bin;
      83            0 :       input[index] += tp.adc_integral;
      84              :     }
      85              :   }
      86            0 :   input[num_time_bins * num_chan_bins] = adc_integral;
      87            0 : };
      88              : 
      89            0 : void ProtoDUNEBSMWindow::fill_entry_window(std::vector<Entry> &entry_input, std::vector<float> &input) {
      90            0 :   for (size_t i = 0; i < input.size(); i++) {
      91            0 :     entry_input[i].fvalue = input[i];
      92              :   }
      93            0 : }
      94              : 
      95            0 : std::ostream& operator<<(std::ostream& os, const ProtoDUNEBSMWindow& window){
      96            0 :   if(window.is_empty()) os << "Window is empty!\n";
      97              :   else{
      98            0 :     os << "Window start: " << window.time_start << ", end: " << window.tp_list.back().time_start;
      99            0 :     os << ". Total of: " << window.adc_integral << " ADC counts with " << window.tp_list.size() << " TPs.\n"; 
     100              :   }
     101            0 :   return os;
     102              : };
     103              : 
     104              : }