pmtana Namespace Reference

Classes
class	AlgoCFD
class	AlgoFixedWindow
class	AlgoSiPM
class	AlgoSlidingWindow
class	AlgoSSPLeadingEdge
class	AlgoThreshold
class	OpticalRecoException
class	PedAlgoEdges
class	PedAlgoRmsSlider
class	PedAlgoRollingMean
class	PedAlgoUB
class	PMTAna
class	PMTPedestalBase
class	PMTPulseRecoBase
struct	pulse_param
class	PulseRecoManager

Typedefs
typedef std::vector< short >	Waveform_t
typedef std::vector< double >	PedestalMean_t
typedef std::vector< double >	PedestalSigma_t
typedef std::vector< pmtana::pulse_param >	pulse_param_array

Functions
bool	CheckIndex (const std::vector< short > &wf, const size_t &begin, size_t &end)
double	mean (const std::vector< short > &wf, size_t start, size_t nsample)
double	edge_aware_mean (const std::vector< short > &wf, int start, int end)
double	std (const std::vector< short > &wf, const double ped_mean, size_t start, size_t nsample)
double	BinnedMaxOccurrence (const PedestalMean_t &mean_v, const size_t nbins)
int	sign (double val)
double	BinnedMaxTH1D (const std::vector< double > &v, int bins)

Typedef Documentation

typedef std::vector< double > pmtana::PedestalMean_t

Definition at line 9 of file OpticalRecoTypes.h.

typedef std::vector< double > pmtana::PedestalSigma_t

Definition at line 10 of file OpticalRecoTypes.h.

typedef std::vector<pmtana::pulse_param> pmtana::pulse_param_array

Definition at line 49 of file PMTPulseRecoBase.h.

typedef std::vector< short > pmtana::Waveform_t

Definition at line 8 of file OpticalRecoTypes.h.

Function Documentation

double pmtana::BinnedMaxOccurrence	(	const PedestalMean_t &	mean_v,
		const size_t	nbins
	)

Definition at line 59 of file UtilFunc.cxx.

  {
    if(nbins<1) throw OpticalRecoException("Cannot have 0 binning");

    auto res = std::minmax_element(std::begin(mean_v),std::end(mean_v));

    double bin_width = ((*res.second) - (*res.first)) / ((double)nbins);

    if(nbins==1 || bin_width == 0) return ((*res.first) + bin_width /2.);

    //std::cout<<"Min: "<<(*res.first)<<" Max: "<<(*res.second)<<" Width: "<<bin_width<<std::endl;

    // Construct array of nbins
    static std::vector<size_t> ctr_v(nbins,0);
    for(auto& v : ctr_v) v=0;
    for(auto const& v : mean_v) {

      size_t index = int((v - (*res.first))/bin_width);
      //std::cout<<"adc = "<<v<<" width = "<<bin_width<< " ... "
      //<<index<<" / "<<ctr_v.size()<<std::endl;

      ctr_v[index]++;

    }

    // Find max occurrence
    auto max_it = std::max_element(std::begin(ctr_v),std::end(ctr_v));

    // Get the mean of max-occurrence bins
    double mean_max_occurrence = 0;
    double num_occurrence = 0;
    for(size_t bin=0; bin<ctr_v.size(); ++bin) {

      if(ctr_v[bin] != (*max_it)) continue;

      mean_max_occurrence += ((*res.first) + bin_width / 2. + bin_width * bin);

      num_occurrence += 1.0;
    }

    return (mean_max_occurrence / num_occurrence);
  }

double pmtana::BinnedMaxTH1D	(	const std::vector< double > &	v,
		int	bins
	)

Definition at line 112 of file UtilFunc.cxx.

                                                            {

    auto max_it = std::max_element(std::begin(v), std::end(v));
    auto min_it = std::min_element(std::begin(v), std::end(v));

    TH1D th("th",";;",bins,*min_it,*max_it);

    for (const auto & m : v) th.Fill(m);

    return th.GetXaxis()->GetBinCenter(th.GetMaximumBin());
  }

bool pmtana::CheckIndex	(	const std::vector< short > &	wf,
		const size_t &	begin,
		size_t &	end
	)

Definition at line 41 of file PMTPulseRecoBase.cxx.

  {
    if(begin >= wf.size() || end >= wf.size() || begin > end){

      std::cerr <<"Invalid arguments: waveform length = " << wf.size() << " begin = " << begin << " end = " << end << std::endl;

      return false;
    }

    if(!end) end = wf.size() - 1;

    return true;
  }

double pmtana::edge_aware_mean	(	const std::vector< short > &	wf,
		int	start,
		int	end
	)

Definition at line 25 of file UtilFunc.cxx.

                                                                         {

    auto m   = double{0.0};
    auto n_t = unsigned{0};

    for(int k = start; k < end; ++k) {
      if (k < 0 or k > (int)(wf.size()) - 1) continue;
      m += wf.at(k);
      ++n_t;
    }

    if( n_t > 0 ) m /= n_t;
    n_t = 0;

    return m;
  }

double pmtana::mean	(	const std::vector< short > &	wf,
		size_t	start,
		size_t	nsample
	)

Definition at line 13 of file UtilFunc.cxx.

  {
    if(!nsample) nsample = wf.size();
    if(start > wf.size() || (start+nsample) > wf.size())
      throw OpticalRecoException("Invalid start/end index!");

    double sum = std::accumulate(wf.begin()+start,wf.begin()+start+nsample,0.0) / ((double)nsample);

    return sum;
  }

int pmtana::sign

(

double

val

)

Definition at line 104 of file UtilFunc.cxx.

                       {

    if (val > 0) return  1;
    if (val < 0) return -1;
    return 0;

  }

double pmtana::std	(	const std::vector< short > &	wf,
		const double	ped_mean,
		size_t	start,
		size_t	nsample
	)

Definition at line 42 of file UtilFunc.cxx.

  {
    if(!nsample) nsample = wf.size();
    if(start > wf.size() || (start+nsample) > wf.size())
      throw OpticalRecoException("Invalid start/end index!");

    double sigma = 0;

    for(size_t index=start; index < (start+nsample); ++index)

      sigma += pow( (wf[index] - ped_mean), 2 );

    sigma = sqrt(sigma/((double)(nsample)));

    return sigma;
  }