pmtana::AlgoSlidingWindow Class Reference

#include <AlgoSlidingWindow.h>

Inheritance diagram for pmtana::AlgoSlidingWindow:

Public Member Functions
	AlgoSlidingWindow (const std::string name="SlidingWindow")
	Default constructor. More...
	AlgoSlidingWindow (const fhicl::ParameterSet &pset, std::unique_ptr< pmtana::RiseTimeCalculatorBase > risetimecalculator=nullptr, const std::string name="SlidingWindow")
	Alternative ctor. More...
void	Reset ()
	Implementation of AlgoSlidingWindow::reset() method. More...
Public Member Functions inherited from pmtana::PMTPulseRecoBase
	PMTPulseRecoBase (const std::string name="noname")
	Default constructor with fhicl parameters. More...
virtual	~PMTPulseRecoBase ()=default
	Default destructor. More...
const std::string &	Name () const
	Name getter. More...
bool	Status () const
	Status getter. More...
bool	Reconstruct (const pmtana::Waveform_t &, const pmtana::PedestalMean_t &, const pmtana::PedestalSigma_t &)
const pulse_param &	GetPulse (size_t index=0) const
const pulse_param_array &	GetPulses () const
	A getter for the whole array of pulse_param struct object. More...
size_t	GetNPulse () const
	A getter for the number of reconstructed pulses from the input waveform. More...

Protected Member Functions
bool	RecoPulse (const pmtana::Waveform_t &, const pmtana::PedestalMean_t &, const pmtana::PedestalSigma_t &)
	Implementation of AlgoSlidingWindow::reco() method. More...
Protected Member Functions inherited from pmtana::PMTPulseRecoBase
bool	Integral (const std::vector< short > &wf, double &result, size_t begin=0, size_t end=0) const
bool	Derivative (const std::vector< short > &wf, std::vector< int32_t > &diff, size_t begin=0, size_t end=0) const
size_t	Max (const std::vector< short > &wf, double &result, size_t begin=0, size_t end=0) const
size_t	Min (const std::vector< short > &wf, double &result, size_t begin=0, size_t end=0) const

Protected Attributes
bool	_positive
	A boolean to set waveform positive/negative polarity. More...
float	_adc_thres
	A variable holder for a user-defined absolute ADC threshold value. More...
float	_tail_adc_thres
float	_end_adc_thres
size_t	_min_width
	A variable holder to ensure the minimum pulse width. More...
float	_nsigma
	A variable holder for a multiplicative factor for the pedestal standard deviation to define the threshold. More...
float	_tail_nsigma
float	_end_nsigma
bool	_verbose
size_t	_num_presample
size_t	_num_postsample
Protected Attributes inherited from pmtana::PMTPulseRecoBase
pulse_param_array	_pulse_v
	A container array of pulse_param struct objects to store (possibly multiple) reconstructed pulse(s). More...
pulse_param	_pulse
	A subject pulse_param object to be filled with the last reconstructed pulse parameters. More...
std::unique_ptr < pmtana::RiseTimeCalculatorBase >	_risetime_calc_ptr = nullptr
	Tool for rise time calculation. More...

Detailed Description

This class implements threshold algorithm to AlgoSlidingWindow class.

Definition at line 32 of file AlgoSlidingWindow.h.

Constructor & Destructor Documentation

pmtana::AlgoSlidingWindow::AlgoSlidingWindow

(

const std::string

name = "SlidingWindow"

)

Default constructor.

Definition at line 14 of file AlgoSlidingWindow.cxx.

                                                           : PMTPulseRecoBase(name)
  //*********************************************************************
  {}

pmtana::AlgoSlidingWindow::AlgoSlidingWindow	(	const fhicl::ParameterSet &	pset,
		std::unique_ptr< pmtana::RiseTimeCalculatorBase >	risetimecalculator = nullptr,
		const std::string	name = "SlidingWindow"
	)

Alternative ctor.

Definition at line 19 of file AlgoSlidingWindow.cxx.

    : PMTPulseRecoBase(name)
  //*********************************************************************
  {
    _positive = pset.get<bool>("PositivePolarity", true);

    _adc_thres = pset.get<float>("ADCThreshold");

    _tail_adc_thres = pset.get<float>("TailADCThreshold", _adc_thres);

    _end_adc_thres = pset.get<float>("EndADCThreshold");

    _nsigma = pset.get<float>("NSigmaThreshold");

    _tail_nsigma = pset.get<float>("TailNSigma", _nsigma);

    _end_nsigma = pset.get<float>("EndNSigmaThreshold");

    _verbose = pset.get<bool>("Verbosity");

    _num_presample = pset.get<size_t>("NumPreSample");

    _num_postsample = pset.get<size_t>("NumPostSample", 0);

    _min_width = pset.get<size_t>("MinPulseWidth", 0);

    _risetime_calc_ptr = std::move(risetimecalculator);

    Reset();
  }

Member Function Documentation

bool pmtana::AlgoSlidingWindow::RecoPulse ( const pmtana::Waveform_t &  wf, const pmtana::PedestalMean_t &  mean_v, const pmtana::PedestalSigma_t &  sigma_v  )

protectedvirtual

Implementation of AlgoSlidingWindow::reco() method.

Implements pmtana::PMTPulseRecoBase.

Definition at line 64 of file AlgoSlidingWindow.cxx.

  {

    bool fire = false;

    bool in_tail = false;

    bool in_post = false;

    double pulse_tail_threshold = 0;

    double pulse_end_threshold = 0;

    double pulse_start_baseline = 0;

    int post_integration = 0;

    assert(wf.size() == mean_v.size() && wf.size() == sigma_v.size());

    //double threshold = ( _adc_thres > (_nsigma * _ped_rms) ? _adc_thres : (_nsigma * _ped_rms) );

    //threshold += _ped_mean;

    Reset();

    for (size_t i = 0; i < wf.size(); ++i) {

      double value = 0.;
      if (_positive)
        value = ((double)(wf[i])) - mean_v[i];
      else
        value = mean_v[i] - ((double)(wf[i]));

      float start_threshold = 0.;
      float tail_threshold = 0.;
      if (sigma_v[i] * _nsigma < _adc_thres)
        start_threshold = _adc_thres;
      else
        start_threshold = sigma_v[i] * _nsigma;

      if (sigma_v[i] * _tail_nsigma < _tail_adc_thres)
        tail_threshold = _tail_adc_thres;
      else
        tail_threshold = sigma_v[i] * _tail_nsigma;

      // End pulse if significantly high peak found (new pulse)
      if ((!fire || in_tail || in_post) && ((double)value > start_threshold)) {

        // If there's a pulse, end it
        if (in_tail) {
          _pulse.t_end = i - 1;

          // Register if width is acceptable
          if ((_pulse.t_end - _pulse.t_start) >= _min_width) {
            if(_risetime_calc_ptr)
              _pulse.t_rise = _risetime_calc_ptr->RiseTime(
                                {wf.begin()+_pulse.t_start, wf.begin()+_pulse.t_end},
                                {mean_v.begin()+_pulse.t_start, mean_v.begin()+_pulse.t_end},
                                _positive);

            _pulse_v.push_back(_pulse);
          }

          _pulse.reset_param();

          if (_verbose)
            std::cout << "\033[93mPulse End\033[00m: "
                      << "baseline: " << mean_v[i] << " ... "
                      << " ... adc above: " << value << " T=" << i << std::endl;
        }

        //
        // Found a new pulse ... try to get a few samples prior to this
        //

        pulse_tail_threshold = tail_threshold;
        pulse_start_baseline = mean_v[i];

        pulse_end_threshold = 0.;
        if (sigma_v[i] * _end_nsigma < _end_adc_thres)
          pulse_end_threshold = _end_adc_thres;
        else
          pulse_end_threshold = sigma_v[i] * _end_nsigma;

        int buffer_num_index = 0;
        if (_pulse_v.size())
          buffer_num_index = (int)i - _pulse_v.back().t_end - 1;
        else
          buffer_num_index = std::min(_num_presample, i);

        if (buffer_num_index > (int)_num_presample) buffer_num_index = _num_presample;

        if (buffer_num_index < 0) {
          std::cerr << "\033[95m[ERROR]\033[00m Logic error! Negative buffer_num_index..."
                    << std::endl;
          throw std::exception();
        }

        // If there's a pulse, end we where in in_post, end the previous pulse first
        if (in_post) {
          // Find were
          _pulse.t_end = static_cast<int>(i) - buffer_num_index;
          if (_pulse.t_end > 0) --_pulse.t_end; // leave a gap, if we can

          // Register if width is acceptable
          if ((_pulse.t_end - _pulse.t_start) >= _min_width) {
            if(_risetime_calc_ptr)
              _pulse.t_rise = _risetime_calc_ptr->RiseTime(
                                {wf.begin()+_pulse.t_start, wf.begin()+_pulse.t_end},
                                {mean_v.begin()+_pulse.t_start, mean_v.begin()+_pulse.t_end},
                                _positive);

            _pulse_v.push_back(_pulse);
          }

          _pulse.reset_param();

          if (_verbose)
            std::cout << "\033[93mPulse End\033[00m: new pulse starts during in_post: "
                      << "baseline: " << mean_v[i] << " ... "
                      << " ... adc above: " << value << " T=" << i << std::endl;
        }

        _pulse.t_start = i - buffer_num_index;
        _pulse.ped_mean = pulse_start_baseline;
        _pulse.ped_sigma = sigma_v[i];

        for (size_t pre_index = _pulse.t_start; pre_index < i; ++pre_index) {

          double pre_adc = wf[pre_index];
          if (_positive)
            pre_adc -= pulse_start_baseline;
          else
            pre_adc = pulse_start_baseline - pre_adc;

          if (pre_adc > 0.) _pulse.area += pre_adc;
        }

        if (_verbose)
          std::cout << "\033[93mPulse Start\033[00m: "
                    << "baseline: " << mean_v[i] << " ... threshold: " << start_threshold
                    << " ... adc above baseline: " << value << " ... pre-adc sum: " << _pulse.area
                    << " T=" << i << std::endl;

        fire = true;
        in_tail = false;
        in_post = false;
      }

      if (fire && value < pulse_tail_threshold) {
        fire = false;
        in_tail = true;
        in_post = false;
      }

      if ((fire || in_tail || in_post) && _verbose) {
        std::cout << (fire ? "\033[93mPulsing\033[00m: " : "\033[93mIn-tail\033[00m: ")
                  << "baseline: " << mean_v[i] << " std: " << sigma_v[i]
                  << " ... adc above baseline " << value << " T=" << i << std::endl;
      }

      if ((fire || in_tail) && value < pulse_end_threshold) {
        in_post = true;
        fire = in_tail = false;
        post_integration = _num_postsample;
      }

      if (in_post && post_integration < 1) {
        // Found the end of a pulse
        _pulse.t_end = i - 1;

        // Register if width is acceptable
        if ((_pulse.t_end - _pulse.t_start) >= _min_width) {
          if(_risetime_calc_ptr)
            _pulse.t_rise = _risetime_calc_ptr->RiseTime(
                              {wf.begin()+_pulse.t_start, wf.begin()+_pulse.t_end},
                              {mean_v.begin()+_pulse.t_start, mean_v.begin()+_pulse.t_end},
                              _positive);

          _pulse_v.push_back(_pulse);
        }

        if (_verbose)
          std::cout << "\033[93mPulse End\033[00m: "
                    << "baseline: " << mean_v[i] << " ... adc: " << value << " T=" << i
                    << " ... area sum " << _pulse.area << std::endl;

        _pulse.reset_param();

        fire = false;
        in_tail = false;
        in_post = false;
      }

      if (fire || in_tail || in_post) {

        //_pulse.area += ((double)value - (double)mean_v[i]);
        _pulse.area += value;

        if (_pulse.peak < value) {

          // Found a new maximum
          _pulse.peak = value;

          _pulse.t_max = i;
        }

        if (in_post) --post_integration;
      }
    }

    if (fire || in_tail || in_post) {

      // Take care of a pulse that did not finish within the readout window.

      fire = false;
      in_tail = false;

      _pulse.t_end = wf.size() - 1;

      // Register if width is acceptable
      if ((_pulse.t_end - _pulse.t_start) >= _min_width) {
        if(_risetime_calc_ptr)
          _pulse.t_rise = _risetime_calc_ptr->RiseTime(
                            {wf.begin()+_pulse.t_start, wf.begin()+_pulse.t_end},
                            {mean_v.begin()+_pulse.t_start, mean_v.begin()+_pulse.t_end},
                            _positive);
        _pulse_v.push_back(_pulse);
      }

      _pulse.reset_param();
    }

    return true;
  }

void pmtana::AlgoSlidingWindow::Reset ( )

virtual

Implementation of AlgoSlidingWindow::reset() method.

Reimplemented from pmtana::PMTPulseRecoBase.

Definition at line 56 of file AlgoSlidingWindow.cxx.

  {
    PMTPulseRecoBase::Reset();
  }

Member Data Documentation

float pmtana::AlgoSlidingWindow::_adc_thres

protected

A variable holder for a user-defined absolute ADC threshold value.

Definition at line 59 of file AlgoSlidingWindow.h.

float pmtana::AlgoSlidingWindow::_end_adc_thres

protected

Definition at line 59 of file AlgoSlidingWindow.h.

float pmtana::AlgoSlidingWindow::_end_nsigma

protected

Definition at line 65 of file AlgoSlidingWindow.h.

size_t pmtana::AlgoSlidingWindow::_min_width

protected

A variable holder to ensure the minimum pulse width.

Definition at line 62 of file AlgoSlidingWindow.h.

float pmtana::AlgoSlidingWindow::_nsigma

protected

A variable holder for a multiplicative factor for the pedestal standard deviation to define the threshold.

Definition at line 65 of file AlgoSlidingWindow.h.

size_t pmtana::AlgoSlidingWindow::_num_postsample

protected

Definition at line 67 of file AlgoSlidingWindow.h.

size_t pmtana::AlgoSlidingWindow::_num_presample

protected

Definition at line 67 of file AlgoSlidingWindow.h.

bool pmtana::AlgoSlidingWindow::_positive

protected

A boolean to set waveform positive/negative polarity.

Definition at line 56 of file AlgoSlidingWindow.h.

float pmtana::AlgoSlidingWindow::_tail_adc_thres

protected

Definition at line 59 of file AlgoSlidingWindow.h.

float pmtana::AlgoSlidingWindow::_tail_nsigma

protected

Definition at line 65 of file AlgoSlidingWindow.h.

bool pmtana::AlgoSlidingWindow::_verbose

protected

Definition at line 66 of file AlgoSlidingWindow.h.

---

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

• AlgoSlidingWindow.h
• AlgoSlidingWindow.cxx