pid::PIDAAlg Class Reference

#include "PIDAAlg.h"

Classes
struct	PIDAProperties

Public Member Functions
	PIDAAlg (fhicl::ParameterSet const &p)
void	RunPIDAAlg (std::vector< float > const &, std::vector< float > const &)
void	RunPIDAAlg (anab::Calorimetry const &)
void	RunPIDAAlg (anab::Calorimetry const &, float &, float &)
float	getPIDAMean ()
float	getPIDASigma ()
const std::vector< float > &	getPIDAValues ()
const std::vector< float > &	getPIDAErrors ()
size_t	getNKDEBandwidths ()
float	getKDEBandwidth (const size_t i_b)
float	getPIDAKDEMostProbable (const size_t)
float	getPIDAKDEFullWidthHalfMax (const size_t)
void	PrintPIDAValues ()
void	setExponentConstant (float const &ex)
void	SetPIDATree (TTree *, TH1F *, std::vector< TH1F * >)
void	FillPIDATree (unsigned int, unsigned int, unsigned int, anab::Calorimetry const &)

Private Types
typedef struct pid::PIDAAlg::PIDAProperties	PIDAProperties_t

Private Member Functions
void	calculatePIDAMean ()
void	calculatePIDASigma ()
void	calculatePIDAIntegral (std::map< double, double > const &)
void	ClearInternalData ()
void	createKDEs ()
void	createKDE (const size_t)
void	calculatePIDAKDEMostProbable ()
void	calculatePIDAKDEFullWidthHalfMax ()
void	FillPIDAProperties (unsigned int, unsigned int, unsigned int, anab::Calorimetry const &)

Private Attributes
const float	fPIDA_BOGUS
float	fExponentConstant
float	fMinResRange
float	fMaxResRange
float	fMaxPIDAValue
float	fKDEEvalMaxSigma
float	fKDEEvalStepSize
std::vector< float >	fKDEBandwidths
std::vector< float >	fpida_values
std::vector< float >	fpida_errors
float	fpida_mean
float	fpida_sigma
float	fpida_integral_dedx
float	fpida_integral_pida
std::vector< float >	fpida_kde_mp
std::vector< float >	fpida_kde_fwhm
std::vector< float >	fpida_kde_b
std::vector< std::vector< float > >	fkde_distribution
std::vector< float >	fkde_dist_min
std::vector< float >	fkde_dist_max
util::NormalDistribution	fnormalDist
TTree *	fPIDATree
TH1F *	hPIDAvalues
TH1F *	hPIDAKDE [MAX_BANDWIDTHS]
unsigned int	fPIDAHistNbins
float	fPIDAHistMin
float	fPIDAHistMax
PIDAProperties_t	fPIDAProperties

Detailed Description

Definition at line 50 of file PIDAAlg.h.

Member Typedef Documentation

typedef struct pid::PIDAAlg::PIDAProperties pid::PIDAAlg::PIDAProperties_t

private

Constructor & Destructor Documentation

pid::PIDAAlg::PIDAAlg

(

fhicl::ParameterSet const &

p

)

Title: PIDA Algorithim Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov), based on ideas/code from Bruce Baller

Description: Algorithm that calculates the PIDA from a calorimetry object Input: anab::Calorimetry Output: PIDA information

Definition at line 24 of file PIDAAlg.cxx.

References ClearInternalData().

  : fPIDA_BOGUS(-9999)
  , fExponentConstant(p.get<float>("ExponentConstant", 0.42))
  , fMinResRange(p.get<float>("MinResRange", 0))
  , fMaxResRange(p.get<float>("MaxResRange", 30))
  , fMaxPIDAValue(p.get<float>("MaxPIDAValue", 50))
  , fKDEEvalMaxSigma(p.get<float>("KDEEvalMaxSigma", 3))
  , fKDEEvalStepSize(p.get<float>("KDEEvalStepSize", 0.01))
  , fKDEBandwidths(p.get<std::vector<float>>("KDEBandwidths"))
  , fnormalDist(util::NormalDistribution(fKDEEvalMaxSigma, fKDEEvalStepSize))
  , fPIDAHistNbins(p.get<unsigned int>("PIDAHistNbins", 100))
  , fPIDAHistMin(p.get<float>("PIDAHistMin", 0.0))
  , fPIDAHistMax(p.get<float>("PIDAHistMax", 50.0))
{
  ClearInternalData();
}

Member Function Documentation

void pid::PIDAAlg::calculatePIDAIntegral ( std::map< double, double > const &  range_dEdx_map )

private

Definition at line 208 of file PIDAAlg.cxx.

References fExponentConstant, fpida_integral_dedx, and fpida_integral_pida.

Referenced by RunPIDAAlg().

{

  if (range_dEdx_map.size() < 2) return;

  fpida_integral_dedx = 0;

  for (std::map<double, double>::const_iterator map_iter = range_dEdx_map.begin();
       map_iter != std::prev(range_dEdx_map.end());
       map_iter++) {
    double range_width = std::next(map_iter)->first - map_iter->first;
    fpida_integral_dedx += range_width * (std::next(map_iter)->second +
                                          0.5 * (map_iter->second - std::next(map_iter)->second));
  }

  fpida_integral_pida =
    fpida_integral_dedx * (1 - fExponentConstant) *
    std::pow((std::prev(range_dEdx_map.end())->first - range_dEdx_map.begin()->first),
             (fExponentConstant - 1));
}

void pid::PIDAAlg::calculatePIDAKDEFullWidthHalfMax ( )

private

void pid::PIDAAlg::calculatePIDAKDEMostProbable ( )

private

void pid::PIDAAlg::calculatePIDAMean ( )

private

Definition at line 185 of file PIDAAlg.cxx.

References fpida_mean, and fpida_values.

Referenced by calculatePIDASigma(), and getPIDAMean().

{

  if (fpida_values.size() == 0) throw "pid::PIDAAlg --- PIDA Values not filled!";

  fpida_mean = 0;
  for (auto const& val : fpida_values)
    fpida_mean += val;
  fpida_mean /= fpida_values.size();
}

void pid::PIDAAlg::calculatePIDASigma ( )

private

Definition at line 196 of file PIDAAlg.cxx.

References calculatePIDAMean(), fPIDA_BOGUS, fpida_mean, fpida_sigma, and fpida_values.

Referenced by createKDE(), FillPIDAProperties(), and getPIDASigma().

{

  if (fpida_mean == fPIDA_BOGUS) calculatePIDAMean();

  fpida_sigma = 0;
  for (auto const& val : fpida_values)
    fpida_sigma += (fpida_mean - val) * (fpida_mean - val);

  fpida_sigma = std::sqrt(fpida_sigma) / fpida_values.size();
}

void pid::PIDAAlg::ClearInternalData ( )

private

Definition at line 41 of file PIDAAlg.cxx.

References fkde_dist_max, fkde_dist_min, fkde_distribution, fKDEBandwidths, fPIDA_BOGUS, fpida_errors, fpida_integral_dedx, fpida_integral_pida, fpida_kde_b, fpida_kde_fwhm, fpida_kde_mp, fpida_mean, fpida_sigma, and fpida_values.

Referenced by PIDAAlg(), and RunPIDAAlg().

{
  fpida_mean = fPIDA_BOGUS;
  fpida_sigma = fPIDA_BOGUS;
  fpida_integral_dedx = fPIDA_BOGUS;
  fpida_integral_pida = fPIDA_BOGUS;
  fpida_values.clear();
  fpida_errors.clear();

  fpida_kde_mp = std::vector<float>(fKDEBandwidths.size(), fPIDA_BOGUS);
  fpida_kde_fwhm = std::vector<float>(fKDEBandwidths.size(), fPIDA_BOGUS);
  fpida_kde_b = std::vector<float>(fKDEBandwidths.size(), fPIDA_BOGUS);
  fkde_distribution = std::vector<std::vector<float>>(fKDEBandwidths.size());
  fkde_dist_min = std::vector<float>(fKDEBandwidths.size(), fPIDA_BOGUS);
  fkde_dist_max = std::vector<float>(fKDEBandwidths.size(), fPIDA_BOGUS);
}

void pid::PIDAAlg::createKDE ( const size_t  i_b )

private

Definition at line 229 of file PIDAAlg.cxx.

References calculatePIDASigma(), fkde_dist_max, fkde_dist_min, fkde_distribution, fKDEBandwidths, fKDEEvalMaxSigma, fKDEEvalStepSize, fnormalDist, fpida_errors, fpida_kde_b, fpida_kde_fwhm, fpida_kde_mp, fpida_sigma, fpida_values, and util::NormalDistribution::getValue().

Referenced by createKDEs(), getPIDAKDEFullWidthHalfMax(), and getPIDAKDEMostProbable().

{

  if (fpida_values.size() == 0) throw "pid::PIDAAlg --- PIDA Values not filled!";

  //if( fkde_distribution[i_b].size()!=0 ) return;

  if (fKDEBandwidths[i_b] <= 0) {
    calculatePIDASigma();
    float bandwidth = fpida_sigma * 1.06 * std::pow((float)(fpida_values.size()), -0.2);
    fpida_errors = std::vector<float>(fpida_values.size(), bandwidth);
    fpida_kde_b[i_b] = bandwidth;
  }
  else {
    fpida_errors = std::vector<float>(fpida_values.size(), fKDEBandwidths[i_b]);
    fpida_kde_b[i_b] = fKDEBandwidths[i_b];
  }

  const auto min_pida_iterator = std::min_element(fpida_values.begin(), fpida_values.end());
  const size_t min_pida_location = std::distance(fpida_values.begin(), min_pida_iterator);
  fkde_dist_min[i_b] =
    fpida_values[min_pida_location] - fKDEEvalMaxSigma * fpida_errors[min_pida_location];

  const auto max_pida_iterator = std::max_element(fpida_values.begin(), fpida_values.end());
  const size_t max_pida_location = std::distance(fpida_values.begin(), max_pida_iterator);
  fkde_dist_max[i_b] =
    fpida_values[max_pida_location] + fKDEEvalMaxSigma * fpida_errors[max_pida_location];

  //make the kde distribution, and get the max value
  const size_t kde_dist_size =
    (size_t)((fkde_dist_max[i_b] - fkde_dist_min[i_b]) / fKDEEvalStepSize) + 1;
  fkde_distribution[i_b].resize(kde_dist_size);
  float kde_max = 0;
  size_t step_max = 0;
  for (size_t i_step = 0; i_step < kde_dist_size; i_step++) {
    float pida_val = fkde_dist_min[i_b] + i_step * fKDEEvalStepSize;
    fkde_distribution[i_b][i_step] = 0;

    for (size_t i_pida = 0; i_pida < fpida_values.size(); i_pida++)
      fkde_distribution[i_b][i_step] +=
        fnormalDist.getValue((fpida_values[i_pida] - pida_val) / fpida_errors[i_pida]) /
        fpida_errors[i_pida];

    if (fkde_distribution[i_b][i_step] > kde_max) {
      kde_max = fkde_distribution[i_b][i_step];
      step_max = i_step;
      fpida_kde_mp[i_b] = pida_val;
    }
  }

  //now get fwhm
  float half_max = 0.5 * fpida_kde_mp[i_b];
  float low_width = 0;
  for (size_t i_step = step_max; i_step > 0; i_step--) {
    if (fkde_distribution[i_b][i_step] < half_max) break;
    low_width += fKDEEvalStepSize;
  }
  float high_width = 0;
  for (size_t i_step = step_max; i_step < kde_dist_size; i_step++) {
    if (fkde_distribution[i_b][i_step] < half_max) break;
    high_width += fKDEEvalStepSize;
  }
  fpida_kde_fwhm[i_b] = low_width + high_width;
}

void pid::PIDAAlg::createKDEs ( )

private

Definition at line 294 of file PIDAAlg.cxx.

References createKDE(), and fKDEBandwidths.

Referenced by FillPIDAProperties().

{
  for (size_t i_b = 0; i_b < fKDEBandwidths.size(); i_b++)
    createKDE(i_b);
}

void pid::PIDAAlg::FillPIDAProperties ( unsigned int  run, unsigned int  event, unsigned int  calo_index, anab::Calorimetry const &  calo  )

private

Definition at line 300 of file PIDAAlg.cxx.

References calculatePIDASigma(), pid::PIDAAlg::PIDAProperties::calo_index, pid::PIDAAlg::PIDAProperties::calo_KE, createKDEs(), pid::PIDAAlg::PIDAProperties::event, fkde_dist_min, fkde_distribution, fKDEBandwidths, fKDEEvalStepSize, fpida_integral_dedx, fpida_integral_pida, fpida_kde_b, fpida_kde_fwhm, fpida_kde_mp, fpida_mean, fpida_sigma, fpida_values, fPIDAProperties, fPIDATree, hPIDAKDE, hPIDAvalues, pid::PIDAAlg::PIDAProperties::integral_dedx, pid::PIDAAlg::PIDAProperties::integral_pida, pid::PIDAAlg::PIDAProperties::kde_bandwidth, pid::PIDAAlg::PIDAProperties::kde_fwhm, pid::PIDAAlg::PIDAProperties::kde_mp, anab::Calorimetry::KineticEnergy(), pid::PIDAAlg::PIDAProperties::mean, pid::PIDAAlg::PIDAProperties::n_bandwidths, pid::PIDAAlg::PIDAProperties::n_pid_pts, geo::PlaneID::Plane, anab::Calorimetry::PlaneID(), pid::PIDAAlg::PIDAProperties::planeid, anab::Calorimetry::Range(), pid::PIDAAlg::PIDAProperties::run, pid::PIDAAlg::PIDAProperties::sigma, and pid::PIDAAlg::PIDAProperties::trk_range.

Referenced by FillPIDATree().

{

  fPIDAProperties.run = run;
  fPIDAProperties.event = event;
  fPIDAProperties.calo_index = calo_index;
  fPIDAProperties.planeid = calo.PlaneID().Plane;
  fPIDAProperties.trk_range = calo.Range();
  fPIDAProperties.calo_KE = calo.KineticEnergy();

  fPIDAProperties.n_bandwidths = fKDEBandwidths.size();
  for (size_t i_b = 0; i_b < fPIDAProperties.n_bandwidths; i_b++)

    calculatePIDASigma();
  fPIDAProperties.n_pid_pts = fpida_values.size();
  fPIDAProperties.mean = fpida_mean;
  fPIDAProperties.sigma = fpida_sigma;

  fPIDAProperties.integral_dedx = fpida_integral_dedx;
  fPIDAProperties.integral_pida = fpida_integral_pida;

  createKDEs();
  for (size_t i_b = 0; i_b < fPIDAProperties.n_bandwidths; i_b++) {
    fPIDAProperties.kde_mp[i_b] = fpida_kde_mp[i_b];
    fPIDAProperties.kde_fwhm[i_b] = fpida_kde_fwhm[i_b];
    fPIDAProperties.kde_bandwidth[i_b] = fpida_kde_b[i_b];
  }

  hPIDAvalues->Reset();
  for (auto const& val : fpida_values)
    hPIDAvalues->Fill(val);

  for (size_t i_b = 0; i_b < fPIDAProperties.n_bandwidths; i_b++) {
    hPIDAKDE[i_b]->Reset();
    for (size_t i_step = 0; i_step < fkde_distribution[i_b].size(); i_step++)
      hPIDAKDE[i_b]->AddBinContent(
        hPIDAKDE[i_b]->FindBin(i_step * fKDEEvalStepSize + fkde_dist_min[i_b]),
        fkde_distribution[i_b][i_step]);
  }

  fPIDATree->Fill();
}

void pid::PIDAAlg::FillPIDATree	(	unsigned int	run,
		unsigned int	event,
		unsigned int	calo_index,
		anab::Calorimetry const &	calo
	)

Definition at line 176 of file PIDAAlg.cxx.

References FillPIDAProperties(), and RunPIDAAlg().

Referenced by pid::PIDAAnalyzer::analyze().

{
  RunPIDAAlg(calo);
  FillPIDAProperties(run, event, calo_index, calo);
}

float pid::PIDAAlg::getKDEBandwidth ( const size_t  i_b )

inline

Definition at line 65 of file PIDAAlg.h.

{ return fKDEBandwidths.at(i_b); }

size_t pid::PIDAAlg::getNKDEBandwidths ( )

inline

Definition at line 64 of file PIDAAlg.h.

Referenced by pid::PIDAAnalyzer::beginJob().

{ return fKDEBandwidths.size(); }

const std::vector< float > & pid::PIDAAlg::getPIDAErrors

(

)

Definition at line 130 of file PIDAAlg.cxx.

References fpida_errors.

{
  return fpida_errors;
}

float pid::PIDAAlg::getPIDAKDEFullWidthHalfMax

(

const size_t

i_b

)

Definition at line 118 of file PIDAAlg.cxx.

References createKDE(), fPIDA_BOGUS, and fpida_kde_fwhm.

{
  if (fpida_kde_fwhm[i_b] == fPIDA_BOGUS) createKDE(i_b);

  return fpida_kde_fwhm[i_b];
}

float pid::PIDAAlg::getPIDAKDEMostProbable

(

const size_t

i_b

)

Definition at line 111 of file PIDAAlg.cxx.

References createKDE(), fPIDA_BOGUS, and fpida_kde_mp.

{
  if (fpida_kde_mp[i_b] == fPIDA_BOGUS) createKDE(i_b);

  return fpida_kde_mp[i_b];
}

float pid::PIDAAlg::getPIDAMean

(

)

Definition at line 97 of file PIDAAlg.cxx.

References calculatePIDAMean(), fPIDA_BOGUS, and fpida_mean.

Referenced by RunPIDAAlg().

{
  if (fpida_mean == fPIDA_BOGUS) calculatePIDAMean();

  return fpida_mean;
}

float pid::PIDAAlg::getPIDASigma

(

)

Definition at line 104 of file PIDAAlg.cxx.

References calculatePIDASigma(), fPIDA_BOGUS, and fpida_sigma.

Referenced by RunPIDAAlg().

{
  if (fpida_sigma == fPIDA_BOGUS) calculatePIDASigma();

  return fpida_sigma;
}

const std::vector< float > & pid::PIDAAlg::getPIDAValues

(

)

Definition at line 125 of file PIDAAlg.cxx.

References fpida_values.

{
  return fpida_values;
}

void pid::PIDAAlg::PrintPIDAValues

(

)

Definition at line 346 of file PIDAAlg.cxx.

References fpida_values.

{
  for (size_t i_pida = 0; i_pida < fpida_values.size(); i_pida++)
    std::cout << "\tPIDA --- " << i_pida << "\t" << fpida_values[i_pida] << std::endl;
}

void pid::PIDAAlg::RunPIDAAlg	(	std::vector< float > const &	resRange,
		std::vector< float > const &	dEdx
	)

Definition at line 149 of file PIDAAlg.cxx.

References calculatePIDAIntegral(), ClearInternalData(), fExponentConstant, fMaxPIDAValue, fMaxResRange, fMinResRange, fpida_errors, and fpida_values.

Referenced by FillPIDATree(), and RunPIDAAlg().

{

  ClearInternalData();

  fpida_values.reserve(resRange.size());
  fpida_errors.reserve(resRange.size());

  std::map<double, double> range_dEdx_map;

  for (size_t i_r = 0; i_r < resRange.size(); i_r++) {
    if (resRange[i_r] > fMaxResRange || resRange[i_r] < fMinResRange) continue;

    range_dEdx_map[resRange[i_r]] = dEdx[i_r];

    float val = dEdx[i_r] * std::pow(resRange[i_r], fExponentConstant);
    if (val < fMaxPIDAValue) {
      fpida_values.push_back(val);
      //fpida_errors.push_back(0);
    }
  }

  calculatePIDAIntegral(range_dEdx_map);

  if (fpida_values.size() == 0) fpida_values.push_back(-99);
}

void pid::PIDAAlg::RunPIDAAlg

(

anab::Calorimetry const &

calo

)

Definition at line 135 of file PIDAAlg.cxx.

References anab::Calorimetry::dEdx(), tca::dEdx(), anab::Calorimetry::ResidualRange(), and RunPIDAAlg().

{
  std::vector<float> const& resRange = calo.ResidualRange();
  std::vector<float> const& dEdx = calo.dEdx();
  RunPIDAAlg(resRange, dEdx);
}

void pid::PIDAAlg::RunPIDAAlg	(	anab::Calorimetry const &	calo,
		float &	mean,
		float &	sigma
	)

Definition at line 142 of file PIDAAlg.cxx.

References getPIDAMean(), getPIDASigma(), and RunPIDAAlg().

{
  RunPIDAAlg(calo);
  mean = getPIDAMean();
  sigma = getPIDASigma();
}

void pid::PIDAAlg::setExponentConstant ( float const &  ex )

inline

Definition at line 71 of file PIDAAlg.h.

{ fExponentConstant = ex; }

void pid::PIDAAlg::SetPIDATree	(	TTree *	tree,
		TH1F *	hist_vals,
		std::vector< TH1F * >	hist_kde
	)

Definition at line 58 of file PIDAAlg.cxx.

References fKDEBandwidths, fPIDAHistMax, fPIDAHistMin, fPIDAHistNbins, fPIDAProperties, fPIDATree, hPIDAKDE, hPIDAvalues, pid::PIDAAlg::PIDAProperties::kde_bandwidth, pid::PIDAAlg::PIDAProperties::kde_fwhm, pid::PIDAAlg::PIDAProperties::kde_mp, pid::PIDAAlg::PIDAProperties::leaf_structure, MAX_BANDWIDTHS, and pid::PIDAAlg::PIDAProperties::n_bandwidths.

Referenced by pid::PIDAAnalyzer::beginJob().

{

  if (hist_kde.size() > MAX_BANDWIDTHS)
    throw "Error: input histograms larger than max allowed bandwidths.";
  if (hist_kde.size() != fKDEBandwidths.size())
    throw "Error: input histograms do not have same size as bandwidths.";

  fPIDATree = tree;

  hPIDAvalues = hist_vals;
  hPIDAvalues->SetNameTitle("hPIDAvalues", "PIDA Distribution");
  hPIDAvalues->SetBins(fPIDAHistNbins, fPIDAHistMin, fPIDAHistMax);

  for (size_t i_hist = 0; i_hist < hist_kde.size(); i_hist++) {
    hPIDAKDE[i_hist] = hist_kde[i_hist];

    std::stringstream hname, htitle;
    hname << "hPIDAKDE_" << i_hist;
    htitle << "PIDA KDE-smoothed Distribution, Bandwidth=" << fKDEBandwidths.at(i_hist);

    hPIDAKDE[i_hist]->SetNameTitle(hname.str().c_str(), htitle.str().c_str());
    hPIDAKDE[i_hist]->SetBins(fPIDAHistNbins, fPIDAHistMin, fPIDAHistMax);
  }

  fPIDATree->Branch("pida", &fPIDAProperties, fPIDAProperties.leaf_structure.c_str());
  fPIDATree->Branch("hpida_vals", "TH1F", hPIDAvalues);
  fPIDATree->Branch("n_bandwidths", &(fPIDAProperties.n_bandwidths), "n_bandwidths/i");
  fPIDATree->Branch(
    "kde_bandwidth", fPIDAProperties.kde_bandwidth, "kde_bandwidth[n_bandwidths]/F");
  fPIDATree->Branch("kde_mp", fPIDAProperties.kde_mp, "kde_mp[n_bandwidths]/F");
  fPIDATree->Branch("kde_fwhm", fPIDAProperties.kde_fwhm, "kde_fwhm[n_bandwidths]/F");
  for (size_t i_hist = 0; i_hist < hist_kde.size(); i_hist++) {
    std::stringstream bname;
    bname << "hpida_kde_" << i_hist;
    fPIDATree->Branch(bname.str().c_str(), "TH1F", hPIDAKDE[i_hist]);
  }
}

Member Data Documentation

float pid::PIDAAlg::fExponentConstant

private

Definition at line 79 of file PIDAAlg.h.

Referenced by calculatePIDAIntegral(), and RunPIDAAlg().

std::vector<float> pid::PIDAAlg::fkde_dist_max

private

Definition at line 111 of file PIDAAlg.h.

Referenced by ClearInternalData(), and createKDE().

std::vector<float> pid::PIDAAlg::fkde_dist_min

private

Definition at line 110 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), and FillPIDAProperties().

std::vector<std::vector<float> > pid::PIDAAlg::fkde_distribution

private

Definition at line 109 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), and FillPIDAProperties().

std::vector<float> pid::PIDAAlg::fKDEBandwidths

private

Definition at line 85 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), createKDEs(), FillPIDAProperties(), and SetPIDATree().

float pid::PIDAAlg::fKDEEvalMaxSigma

private

Definition at line 83 of file PIDAAlg.h.

Referenced by createKDE().

float pid::PIDAAlg::fKDEEvalStepSize

private

Definition at line 84 of file PIDAAlg.h.

Referenced by createKDE(), and FillPIDAProperties().

float pid::PIDAAlg::fMaxPIDAValue

private

Definition at line 82 of file PIDAAlg.h.

Referenced by RunPIDAAlg().

float pid::PIDAAlg::fMaxResRange

private

Definition at line 81 of file PIDAAlg.h.

Referenced by RunPIDAAlg().

float pid::PIDAAlg::fMinResRange

private

Definition at line 80 of file PIDAAlg.h.

Referenced by RunPIDAAlg().

util::NormalDistribution pid::PIDAAlg::fnormalDist

private

Definition at line 113 of file PIDAAlg.h.

Referenced by createKDE().

const float pid::PIDAAlg::fPIDA_BOGUS

private

Definition at line 77 of file PIDAAlg.h.

Referenced by calculatePIDASigma(), ClearInternalData(), getPIDAKDEFullWidthHalfMax(), getPIDAKDEMostProbable(), getPIDAMean(), and getPIDASigma().

std::vector<float> pid::PIDAAlg::fpida_errors

private

Definition at line 88 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), getPIDAErrors(), and RunPIDAAlg().

float pid::PIDAAlg::fpida_integral_dedx

private

Definition at line 91 of file PIDAAlg.h.

Referenced by calculatePIDAIntegral(), ClearInternalData(), and FillPIDAProperties().

float pid::PIDAAlg::fpida_integral_pida

private

Definition at line 92 of file PIDAAlg.h.

Referenced by calculatePIDAIntegral(), ClearInternalData(), and FillPIDAProperties().

std::vector<float> pid::PIDAAlg::fpida_kde_b

private

Definition at line 106 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), and FillPIDAProperties().

std::vector<float> pid::PIDAAlg::fpida_kde_fwhm

private

Definition at line 105 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), FillPIDAProperties(), and getPIDAKDEFullWidthHalfMax().

std::vector<float> pid::PIDAAlg::fpida_kde_mp

private

Definition at line 104 of file PIDAAlg.h.

Referenced by ClearInternalData(), createKDE(), FillPIDAProperties(), and getPIDAKDEMostProbable().

float pid::PIDAAlg::fpida_mean

private

Definition at line 89 of file PIDAAlg.h.

Referenced by calculatePIDAMean(), calculatePIDASigma(), ClearInternalData(), FillPIDAProperties(), and getPIDAMean().

float pid::PIDAAlg::fpida_sigma

private

Definition at line 90 of file PIDAAlg.h.

Referenced by calculatePIDASigma(), ClearInternalData(), createKDE(), FillPIDAProperties(), and getPIDASigma().

std::vector<float> pid::PIDAAlg::fpida_values

private

Definition at line 87 of file PIDAAlg.h.

Referenced by calculatePIDAMean(), calculatePIDASigma(), ClearInternalData(), createKDE(), FillPIDAProperties(), getPIDAValues(), PrintPIDAValues(), and RunPIDAAlg().

float pid::PIDAAlg::fPIDAHistMax

private

Definition at line 120 of file PIDAAlg.h.

Referenced by SetPIDATree().

float pid::PIDAAlg::fPIDAHistMin

private

Definition at line 119 of file PIDAAlg.h.

Referenced by SetPIDATree().

unsigned int pid::PIDAAlg::fPIDAHistNbins

private

Definition at line 118 of file PIDAAlg.h.

Referenced by SetPIDATree().

PIDAProperties_t pid::PIDAAlg::fPIDAProperties

private

Definition at line 147 of file PIDAAlg.h.

Referenced by FillPIDAProperties(), and SetPIDATree().

TTree* pid::PIDAAlg::fPIDATree

private

Definition at line 115 of file PIDAAlg.h.

Referenced by FillPIDAProperties(), and SetPIDATree().

TH1F* pid::PIDAAlg::hPIDAKDE[MAX_BANDWIDTHS]

private

Definition at line 117 of file PIDAAlg.h.

Referenced by FillPIDAProperties(), and SetPIDATree().

TH1F* pid::PIDAAlg::hPIDAvalues

private

Definition at line 116 of file PIDAAlg.h.

Referenced by FillPIDAProperties(), and SetPIDATree().

---

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

• larana/v10_00_16/source/larana/ParticleIdentification/PIDAAlg.h
• larana/v10_00_16/source/larana/ParticleIdentification/PIDAAlg.cxx