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 ADC and add it to
      15              :   // the TP list. Also keep running sum of all the samples over threshold
      16              :   // and the peak ADC. These are used for samples/peak ratio cut
      17            0 :   adc_integral += input_tp.adc_integral;
      18            0 :   adc_peak_sum += input_tp.adc_peak;
      19            0 :   tot_sum += input_tp.samples_over_threshold;
      20            0 :   tp_list.push_back(input_tp);
      21            0 : };
      22              : 
      23            0 : void ProtoDUNEBSMWindow::clear(){
      24            0 :   tp_list.clear();
      25            0 : };
      26              :       
      27            0 : void ProtoDUNEBSMWindow::move(TriggerPrimitive const &input_tp, timestamp_t const &window_length){
      28              :   // Find all of the TPs in the window that need to be removed
      29              :   // if the input_tp is to be added and the size of the window
      30              :   // is to be conserved.
      31              :   // Substract those TPs' contribution from the total window ADC.
      32            0 :   uint32_t n_tps_to_erase = 0;
      33            0 :   for(auto tp : tp_list){
      34            0 :     if(!(input_tp.time_start-tp.time_start < window_length)){
      35            0 :       n_tps_to_erase++;
      36            0 :       adc_integral -= tp.adc_integral;
      37            0 :       adc_peak_sum -= tp.adc_peak;
      38            0 :       tot_sum -= tp.samples_over_threshold;
      39              :     }
      40              :     else break;
      41              :   }
      42              :   // Erase the TPs from the window.
      43            0 :   tp_list.erase(tp_list.begin(), tp_list.begin()+n_tps_to_erase);
      44              :   // Make the window start time the start time of what is now the
      45              :   // first TP.
      46            0 :   if(tp_list.size()!=0){
      47            0 :     time_start = tp_list.front().time_start;
      48            0 :     add(input_tp);
      49              :   }
      50            0 :   else reset(input_tp);
      51            0 : };
      52              : 
      53            0 : void ProtoDUNEBSMWindow::reset(TriggerPrimitive const &input_tp){
      54              :   // Empty the TP list.
      55            0 :   tp_list.clear();
      56              :   // Set the start time of the window to be the start time of the 
      57              :   // input_tp.
      58            0 :   time_start = input_tp.time_start;
      59              :   // Start the total ADC integral.
      60            0 :   adc_integral = input_tp.adc_integral;
      61              :   // Add the input TP to the TP list.
      62            0 :   tp_list.push_back(input_tp);
      63            0 : };
      64              : 
      65            0 : void ProtoDUNEBSMWindow::bin_window(
      66              :     std::vector<float> &input, timestamp_t time_bin_width, 
      67              :     channel_t chan_bin_width, int num_time_bins, 
      68              :     int num_chan_bins, channel_t first_channel,
      69              :     std::unique_ptr<PDVDEffectiveChannelMap> const &effective_channel_mapper, 
      70              :     bool use_pdvd_map) {
      71            0 :   std::fill(input.begin(), input.end(), 0.0f);
      72              : 
      73            0 :   const float inv_time_bin_width = 1.0f / time_bin_width;
      74            0 :   const float inv_chan_bin_width = 1.0f / chan_bin_width;
      75              : 
      76            0 :   for (const TriggerPrimitive& tp : tp_list) {
      77            0 :     channel_t temp_tp_channel = tp.channel;
      78              :     // If in PD-VD convert to effective channel here
      79            0 :     if (effective_channel_mapper && use_pdvd_map) {
      80            0 :       temp_tp_channel = effective_channel_mapper->remapCollectionPlaneChannel(temp_tp_channel);
      81              :     }
      82            0 :     size_t time_bin = static_cast<size_t>((tp.time_start - time_start) * inv_time_bin_width);
      83            0 :     size_t channel_bin = static_cast<size_t>((temp_tp_channel - first_channel) * inv_chan_bin_width);
      84            0 :     if (time_bin < num_time_bins && channel_bin < num_chan_bins) {
      85            0 :       size_t index = channel_bin * num_time_bins + time_bin;
      86            0 :       input[index] += tp.adc_integral;
      87              :     }
      88              :   }
      89            0 :   input[num_time_bins * num_chan_bins] = adc_integral;
      90            0 : };
      91              : 
      92            0 : void ProtoDUNEBSMWindow::fill_entry_window(std::vector<Entry> &entry_input, std::vector<float> &input) {
      93            0 :   for (size_t i = 0; i < input.size(); i++) {
      94            0 :     entry_input[i].fvalue = input[i];
      95              :   }
      96            0 : }
      97              : 
      98            0 : float ProtoDUNEBSMWindow::mean_sadc() {
      99            0 :   return static_cast<float>(adc_integral / tp_list.size());;
     100              : }
     101            0 : float ProtoDUNEBSMWindow::mean_adc_peak() {
     102            0 :   return static_cast<float>(adc_peak_sum / tp_list.size());
     103              : }
     104            0 : float ProtoDUNEBSMWindow::mean_tot() {
     105            0 :   return static_cast<float>(tot_sum / tp_list.size());
     106              : }
     107              : 
     108            0 : std::ostream& operator<<(std::ostream& os, const ProtoDUNEBSMWindow& window){
     109            0 :   if(window.is_empty()) os << "Window is empty!\n";
     110              :   else{
     111            0 :     os << "Window start: " << window.time_start << ", end: " << window.tp_list.back().time_start;
     112            0 :     os << ". Total of: " << window.adc_integral << " ADC counts with " << window.tp_list.size() << " TPs.\n"; 
     113              :   }
     114            0 :   return os;
     115              : };
     116              : 
     117              : }