pmtana::AlgoCFD Class Reference

#include <AlgoCFD.h>

Inheritance diagram for pmtana::AlgoCFD:

Public Member Functions
	AlgoCFD (const std::string name="CFD")
	Default constructor. More...
	AlgoCFD (const fhicl::ParameterSet &pset, std::unique_ptr< pmtana::RiseTimeCalculatorBase > risetimecalculator=nullptr, const std::string name="CFD")
	Alternative ctor. More...
void	Reset ()
	Implementation of AlgoCFD::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 AlgoCFD::reco() method. More...
const std::map< unsigned, double >	LinearZeroPointX (const std::vector< double > &trace)
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

Private Attributes
float	_F
int	_D
double	_peak_thresh
double	_start_thresh
double	_end_thresh

Additional Inherited Members
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 AlgoCFD class.

Definition at line 35 of file AlgoCFD.h.

Constructor & Destructor Documentation

pmtana::AlgoCFD::AlgoCFD

(

const std::string

name = "CFD"

)

Default constructor.

Definition at line 17 of file AlgoCFD.cxx.

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

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

Alternative ctor.

Definition at line 23 of file AlgoCFD.cxx.

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

    _F = pset.get<float>("Fraction");
    _D = pset.get<int>  ("Delay");

    //_number_presample = pset.get<int>   ("BaselinePreSample");
    _peak_thresh      = pset.get<double>("PeakThresh");
    _start_thresh     = pset.get<double>("StartThresh");
    _end_thresh       = pset.get<double>("EndThresh");

    _risetime_calc_ptr = std::move(risetimecalculator);

    Reset();

  }

Member Function Documentation

const std::map< unsigned, double > pmtana::AlgoCFD::LinearZeroPointX ( const std::vector< double > &  trace )

protected

Definition at line 243 of file AlgoCFD.cxx.

                                                                                        {

    std::map<unsigned,double> crossing;

    //step through the trace and find where slope is POSITIVE across zero
    for ( unsigned i = 0; i < trace.size() - 1; ++i) {

      auto si = ::pmtana::sign(trace.at(i));
      auto sf = ::pmtana::sign(trace.at(i+1));

      if ( si == sf ) //no sign flip, no zero cross
        continue;

      if ( sf < si ) //this is a negative slope, continue
        continue;

      //calculate the crossing X based on linear interpolation bt two pts

      crossing[i] = (double) i - trace.at(i) * ( 1.0 / ( trace.at(i+1) - trace.at(i) ) );

    }


    return crossing;

  }

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

protectedvirtual

Implementation of AlgoCFD::reco() method.

Implements pmtana::PMTPulseRecoBase.

Definition at line 53 of file AlgoCFD.cxx.

  {

    Reset();

    std::vector<double> cfd; cfd.reserve(wf.size());

    // follow cfd procedure: invert waveform, multiply by constant fraction
    // add to delayed waveform.
    for (unsigned int k = 0; k < wf.size(); ++k)  {

      auto delayed = -1.0 * _F *  ( (float) wf.at(k) - mean_v.at(k) );

      if ((int)k < _D)

        cfd.push_back( delayed );

      else

        cfd.push_back(delayed +  ( (float) wf.at(k - _D) - mean_v.at(k) ) );
    }


    // Get the zero point crossings, how can I tell which are meaningful?
    // go to each crossing, see if waveform is above pedestal (high above pedestal)

    auto crossings = LinearZeroPointX(cfd);

    // lambda criteria to determine if inside pulse

    auto in_peak = [&wf,&sigma_v,&mean_v](int i, float thresh) -> bool
      { return wf.at(i) > sigma_v.at(i) * thresh +  mean_v.at(i); };

    // loop over CFD crossings
    for(const auto& cross : crossings) {

      if( in_peak( cross.first, _peak_thresh) ) {
        _pulse.reset_param();

        int i = cross.first;

        //backwards
        while ( in_peak(i, _start_thresh) ){
          i--;
          if ( i < 0 ) { i = 0; break; }
        }
        _pulse.t_start = i;

        //walk a little further backwards to see if we can get 5 low RMS
        // while ( !in_peak(i,_start_thresh) ) {
        //   if (i == ( _pulse.t_start - _number_presample ) ) break;
        //   i--;
        //   if ( i < 0 ) { i = 0; break; }
        // }

        // auto before_mean = double{0.0};

        // if ( _pulse.t_start - i > 0 )
        //   before_mean = std::accumulate(std::begin(mean_v) + i,
        //                              std::begin(mean_v) + _pulse.t_start, 0.0) / ((double) (_pulse.t_start - i));

        i = _pulse.t_start + 1;

        //forwards
        while ( in_peak(i,_end_thresh) ) {
          i++;
          if ( i > (int)(wf.size()) - 1 ) { i = (int)(wf.size()) - 1; break; }
        }

        _pulse.t_end = i;

        // //walk a little further forwards to see if we can get 5 low RMS
        // while ( !in_peak(i,_end_thresh) ) {
        //   if (i == ( _pulse.t_end + _number_presample ) ) break;
        //   i++;
        //   if ( i > wf.size() - 1 ) { i = wf.size() - 1; break; }
        // }

        // auto after_mean = double{0.0};

        // if( i - _pulse.t_end > 0)
        //   after_mean = std::accumulate(std::begin(mean_v) + _pulse.t_end + 1,
        //                             std::begin(mean_v) + i + 1, 0.0) / ((double) (i - _pulse.t_end));


        //how to decide before or after? set before for now
        //if ( wf.size() < 1500 ) //it's cosmic discriminator
        //before_mean = mean_v.front();

        // if( after_mean <= 0 and before_mean <= 0 ) {
        //   std::cerr << "\033[93m<<" << __FUNCTION__ << ">>\033[00m Could not find good pedestal for CDF"
        //          << " both before_mean and after_mean are zero or less? Ignoring this crossing." << std::endl;
        //   continue;
        // }

        //x

        auto start_ped = mean_v.at(_pulse.t_start);
        auto end_ped   = mean_v.at(_pulse.t_end);

        //just take the "smaller one"
        _pulse.ped_mean = start_ped <= end_ped ? start_ped : end_ped;

        if(wf.size() < 50) _pulse.ped_mean = mean_v.front(); //is COSMIC DISCRIMINATOR

        auto it = std::max_element(std::begin(wf) + _pulse.t_start, std::begin(wf) + _pulse.t_end);

        _pulse.t_max      =  it - std::begin(wf);
        _pulse.peak       = *it - _pulse.ped_mean;
        _pulse.t_cfdcross =  cross.second;

        for(auto k = _pulse.t_start; k <= _pulse.t_end; ++k) {
          auto a = wf.at(k) - _pulse.ped_mean;
          if ( a > 0 ) _pulse.area += a;
        }

        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},
                            true);

        _pulse_v.push_back(_pulse);
      }

    }

    // Vic:
    // Very close in time pulses have multiple CFD
    // crossing points. Should we check that pulses now have
    // some multiplicity? No lets just delete them.

    auto pulses_copy = _pulse_v;
    _pulse_v.clear();

    std::unordered_map<unsigned,pulse_param> delta;

    //unsigned width = 0;
    for( const auto& p : pulses_copy )  {

      if ( delta.count(p.t_start) )  {
        if (  (p.t_end - p.t_start) > (delta[p.t_start].t_end - delta[p.t_start].t_start) )
          delta[p.t_start] = p;
        else
          continue;
      }
      else {
        delta[p.t_start] = p;
      }
    }

    for(const auto & p : delta)
      _pulse_v.push_back(p.second);


    //do the same now ensure t_final's are all unique
    //width = 0;

    pulses_copy.clear();
    pulses_copy = _pulse_v;

    _pulse_v.clear();
    delta.clear();

    for( const auto& p : pulses_copy )  {

      if ( delta.count(p.t_end) )  {
        if (  (p.t_end - p.t_start) > (delta[p.t_end].t_end - delta[p.t_end].t_start) )
          delta[p.t_end] = p;
        else
          continue;
      }
      else {
        delta[p.t_end] = p;
      }
    }

    for(const auto & p : delta)
      _pulse_v.push_back(p.second);

    //there should be no overlapping pulses now...

    return true;

  }

void pmtana::AlgoCFD::Reset ( )

virtual

Implementation of AlgoCFD::reset() method.

Reimplemented from pmtana::PMTPulseRecoBase.

Definition at line 46 of file AlgoCFD.cxx.

  {
    PMTPulseRecoBase::Reset();
  }

Member Data Documentation

int pmtana::AlgoCFD::_D

private

Definition at line 63 of file AlgoCFD.h.

double pmtana::AlgoCFD::_end_thresh

private

Definition at line 68 of file AlgoCFD.h.

float pmtana::AlgoCFD::_F

private

Definition at line 62 of file AlgoCFD.h.

double pmtana::AlgoCFD::_peak_thresh

private

Definition at line 66 of file AlgoCFD.h.

double pmtana::AlgoCFD::_start_thresh

private

Definition at line 67 of file AlgoCFD.h.

---

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

• AlgoCFD.h
• AlgoCFD.cxx