RPDDataAnalyzer Class Reference

#include <RPDDataAnalyzer.h>

Collaboration diagram for RPDDataAnalyzer:

Public Types
enum	{   ValidBit = 0, OutOfTimePileupBit = 1, OverflowBit = 2, PrePulseBit = 3,   PostPulseBit = 4, NoPulseBit = 5, BadAvgBaselineSubtrBit = 6, InsufficientPileupFitPointsBit = 7,   PileupStretchedExpFitFailBit = 8, PileupStretchedExpGrowthBit = 9, PileupBadStretchedExpSubtrBit = 10, PileupExpFitFailBit = 11,   PileupExpGrowthBit = 12, PileupBadExpSubtrBit = 13, PileupStretchedExpPulseLikeBit = 14 }

Public Member Functions
	RPDDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, const std::string &tag, const RPDConfig &config, std::vector< float > const &calibFactors)
virtual	~RPDDataAnalyzer ()=default
void	loadChannelData (unsigned int channel, const std::vector< uint16_t > &FadcData)
	Load a single channel's FADC data into member variable. More...
void	analyzeData ()
	Analyze RPD data. More...
unsigned int	getChMaxSample (unsigned int channel) const
	Get sample of max of RPD data in signal range after pileup subtraction. More...
float	getChSumAdc (unsigned int channel) const
	Get sum of RPD data in signal range after baseline and pileup subtraction. More...
float	getChSumAdcCalib (unsigned int channel) const
	Get sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied. More...
float	getChMaxAdc (unsigned int channel) const
	Get max of RPD data in signal range after baseline and pileup subtraction. More...
float	getChMaxAdcCalib (unsigned int channel) const
	Get max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied. More...
float	getChPileupFrac (unsigned int channel) const
	Get OOT pileup sum as a fraction of non-pileup sum in entire window (0 if no OOT pileup, -1 if sum ADC <= 0). More...
float	getChBaseline (unsigned int channel) const
	Get baseline used in baseline subtraction. More...
const std::vector< float > &	getChPileupExpFitParams (unsigned int channel) const
	Get parameters for pileup exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*sample ). More...
const std::vector< float > &	getChPileupStretchedExpFitParams (unsigned int channel) const
	Get parameters for pileup stretched exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*(sample + 4)**(0.5) + [2]*(sample + 4)**(-0.5) ). More...
const std::vector< float > &	getChPileupExpFitParamErrs (unsigned int channel) const
	Get parameter errors for pileup exponential fit (if pileup was detected and fit did not fail). More...
const std::vector< float > &	getChPileupStretchedExpFitParamErrs (unsigned int channel) const
	Get parameter errors for pileup stretched exponential fit (if pileup was detected and fit did not fail). More...
float	getChPileupExpFitMSE (unsigned int channel) const
	Get mean squared error of pileup exponential fit in baseline samples (if pileup was detected and fit did not fail). More...
float	getChPileupStretchedExpFitMSE (unsigned int channel) const
	Get mean squared error of pileup stretched exponential fit in baseline samples (if pileup was detected and fit did not fail). More...
unsigned int	getChStatus (unsigned int channel) const
	Get status word for channel. More...
unsigned int	getSideStatus () const
	Get status word for side. More...
void	reset ()
	Reset all member variables to default values. More...

Private Member Functions
bool	checkOverflow (unsigned int channel)
	Check for overflow and set relevant status bit. More...
bool	checkPulses (unsigned int channel)
	Calculate 2nd difference, identify pulses, and set relevant status bits. More...
unsigned int	countSignalRangeNegatives (std::vector< float > const &values) const
	Calculate the number of negative values in signal range. More...
bool	doBaselinePileupSubtraction (unsigned int channel)
	Determine if there is pileup, subtract baseline and pileup, and set relevant status bits. More...
void	calculateMaxSampleMaxAdc (unsigned int channel)
	Calculate max ADC and max sample. More...
void	calculateSumAdc (unsigned int channel)
	Calculate sum ADC and if there is pileup, calculate fractional pileup. More...
void	setSideStatusBits ()
	Set side status bits according to channel status bits. More...
bool	doPileupExpFit (unsigned int channel, std::vector< std::pair< unsigned int, float >> const &pileupFitPoints)
	Perform an exponential fit in baseline-subtracted baseline samples and set relevant status bits. More...
bool	doPileupStretchedExpFit (unsigned int channel, std::vector< std::pair< unsigned int, float >> const &pileupFitPoints)
	Perform a stretched exponential fit in baseline-subtracted baseline samples and set relevant status bits. More...
float	calculateBaselineSamplesMSE (unsigned int channel, std::function< float(unsigned int)> const &fit) const
	Calculate the mean squared error of the fit function in the baseline samples. More...

Private Attributes
ZDCMsg::MessageFunctionPtr	m_msgFunc_p
std::string	m_tag
unsigned int	m_nRows
unsigned int	m_nColumns
unsigned int	m_nChannels
unsigned int	m_nChannelsLoaded = 0
unsigned int	m_nSamples
unsigned int	m_nBaselineSamples
unsigned int	m_endSignalSample
	Number of baseline samples; the sample equal to this number is the start of signal region. More...
float	m_pulse2ndDerivThresh
	Samples before (not including) this sample are the signal region; nSamples goes to end of window. More...
float	m_postPulseFracThresh
	Second differences less than or equal to this number indicate a pulse. More...
unsigned int	m_goodPulseSampleStart
	If there is a good pulse and post-pulse and size of post-pulse as a fraction of good pulse is less than or equal to this number, ignore post-pulse. More...
unsigned int	m_goodPulseSampleStop
	Pulses before this sample are considered pre-pulses. More...
unsigned int	m_nominalBaseline
	Pulses after this sample are considered post-pulses. More...
float	m_pileupBaselineSumThresh
	The global nominal baseline; used when pileup is detected. More...
float	m_pileupBaselineStdDevThresh
	Baseline sums less than this number indicate there is not pileup. More...
unsigned int	m_nNegativesAllowed
	Baseline standard deviations less than this number indicate there is not pileup. More...
unsigned int	m_AdcOverflow
	Maximum number of negative ADC values after baseline and pileup subtraction allowed in signal range. More...
std::vector< float >	m_outputCalibFactors
	ADC values greater than or equal to this number are considered overflow. More...
std::vector< std::vector< float > >	m_chFadcData
	multiplicative calibration factors to apply to output, e.g., max and sum ADC; per channel More...
std::vector< std::vector< float > >	m_chCorrectedFadcData
	raw RPD data; index channel then sample More...
std::vector< float >	m_chMaxSample
	RPD data with baseline and pileup subtracted; index channel then sample. More...
std::vector< float >	m_chSumAdc
	sample of max of RPD data in signal range after pileup subtraction; per channel More...
std::vector< float >	m_chSumAdcCalib
	sum of RPD data in signal range after baseline and pileup subtraction; per channel More...
std::vector< float >	m_chMaxAdc
	sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel More...
std::vector< float >	m_chMaxAdcCalib
	max of RPD data in signal range after baseline and pileup subtraction; per channel More...
std::vector< float >	m_chPileupFrac
	max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel More...
std::vector< float >	m_chBaseline
	OOT pileup sum as a fraction of non-pileup sum in entire window (0 if no OOT pileup, -1 if sum ADC <= 0); per channel. More...
std::vector< std::vector< float > >	m_chPileupExpFitParams
	baseline used in baseline subtraction; per channel More...
std::vector< std::vector< float > >	m_chPileupStretchedExpFitParams
	parameters for pileup exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*sample ); per channel More...
std::vector< std::vector< float > >	m_chPileupExpFitParamErrs
	parameters for pileup stretched exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*(sample + 4)**(0.5) + [2]*(sample + 4)**(-0.5) ); per channel More...
std::vector< std::vector< float > >	m_chPileupStretchedExpFitParamErrs
	parameter errors for pileup exponential fit (if pileup was detected and fit did not fail); per channel More...
std::vector< bool >	m_chPileupFuncType
	parameter errors for pileup stretched exponential fit (if pileup was detected and fit did not fail); per channel More...
std::vector< std::function< float(unsigned int)> >	m_chExpPileupFuncs
	true when stretched exponential is used, false if exponential is used for pileup subtraction (if pileup was detected); per channel More...
std::vector< std::function< float(unsigned int)> >	m_ch2ndOrderStretchedExpPileupFuncs
	pileup exponential fit function (if pileup was detected and fit did not fail); per channel More...
std::vector< float >	m_chExpPileupMSE
	pileup stretched exponential fit function (if pileup was detected and fit did not fail); per channel More...
std::vector< float >	m_ch2ndOrderStretchedExpPileupMSE
	mean squared error of pileup exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel More...
std::vector< std::bitset< 32 > >	m_chStatus
	mean squared error of pileup stretched exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel More...
std::bitset< 32 >	m_sideStatus
	status bits per channel More...

Static Private Attributes
static unsigned constexpr int	s_minPileupFitPoints = 3
	status bits for side More...

Detailed Description

Definition at line 35 of file RPDDataAnalyzer.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
ValidBit
OutOfTimePileupBit
OverflowBit
PrePulseBit
PostPulseBit
NoPulseBit
BadAvgBaselineSubtrBit
InsufficientPileupFitPointsBit
PileupStretchedExpFitFailBit
PileupStretchedExpGrowthBit
PileupBadStretchedExpSubtrBit
PileupExpFitFailBit
PileupExpGrowthBit
PileupBadExpSubtrBit
PileupStretchedExpPulseLikeBit

Definition at line 38 of file RPDDataAnalyzer.h.

       {
    ValidBit                        =  0, // analysis and output are valid
    OutOfTimePileupBit              =  1, // OOT detected, pileup subtraction attempted
    OverflowBit                     =  2, // overflow detected => invalid
    PrePulseBit                     =  3, // pulse detected before expected range => invalid
    PostPulseBit                    =  4, // pulse detected after expected range => invalid
    NoPulseBit                      =  5, // no pulse detected => invalid
    BadAvgBaselineSubtrBit          =  6, // subtraction of avg. of baseline samples yielded too many negatives => invalid
    InsufficientPileupFitPointsBit  =  7, // baseline samples indicate pileup, but there are not enough points to perform fit -> nominal baseline used without pileup subtraction
    PileupStretchedExpFitFailBit    =  8, // fit to stretched exponential failed -> fallback to exponential fit
    PileupStretchedExpGrowthBit     =  9, // fit to stretched exponential does not decay -> fallback to exponential fit
    PileupBadStretchedExpSubtrBit   = 10, // subtraction of stretched exponential fit yielded too many negatives -> fallback to exponential fit
    PileupExpFitFailBit             = 11, // fit to exponential failed => invalid IF stretched exponential fit is also bad
    PileupExpGrowthBit              = 12, // fit to exponential does not decay => invalid IF stretched exponential fit is also bad
    PileupBadExpSubtrBit            = 13, // subtraction of stretched exponential yielded too many negatives => invalid IF stretched exponential fit is also bad
    PileupStretchedExpPulseLikeBit  = 14, // fit to stretched exponential probably looks more like a pulse than pileup
  };

Constructor & Destructor Documentation

RPDDataAnalyzer()

RPDDataAnalyzer::RPDDataAnalyzer	(	ZDCMsg::MessageFunctionPtr	messageFunc_p,
		const std::string &	tag,
		const RPDConfig &	config,
		std::vector< float > const &	calibFactors
	)

Definition at line 12 of file RPDDataAnalyzer.cxx.

  :
  m_msgFunc_p(std::move(messageFunc_p)),
  m_tag(tag),
  m_nRows(config.nRows),
  m_nColumns(config.nColumns),
  m_nChannels(m_nRows*m_nColumns),
  m_nSamples(config.nSamples),
  m_nBaselineSamples(config.nBaselineSamples),
  m_endSignalSample(config.endSignalSample),
  m_pulse2ndDerivThresh(config.pulse2ndDerivThresh),
  m_postPulseFracThresh(config.postPulseFracThresh),
  m_goodPulseSampleStart(config.goodPulseSampleStart),
  m_goodPulseSampleStop(config.goodPulseSampleStop),
  m_nominalBaseline(config.nominalBaseline),
  m_pileupBaselineSumThresh(config.pileupBaselineSumThresh),
  m_pileupBaselineStdDevThresh(config.pileupBaselineStdDevThresh),
  m_nNegativesAllowed(config.nNegativesAllowed),
  m_AdcOverflow(config.AdcOverflow),
  m_outputCalibFactors(calibFactors),
  m_chFadcData(m_nChannels, std::vector<float>(m_nSamples, 0)),
  m_chCorrectedFadcData(m_nChannels, std::vector<float>(m_nSamples, 0)),
  m_chMaxSample(m_nChannels, 0),
  m_chSumAdc(m_nChannels, 0),
  m_chSumAdcCalib(m_nChannels, 0),
  m_chMaxAdc(m_nChannels, 0),
  m_chMaxAdcCalib(m_nChannels, 0),
  m_chPileupFrac(m_nChannels, 0),
  m_chBaseline(m_nChannels, 0),
  m_chPileupExpFitParams(m_nChannels, std::vector<float>(2, 0)),
  m_chPileupStretchedExpFitParams(m_nChannels, std::vector<float>(3, 0)),
  m_chPileupExpFitParamErrs(m_nChannels, std::vector<float>(2, 0)),
  m_chPileupStretchedExpFitParamErrs(m_nChannels, std::vector<float>(3, 0)),
  m_chPileupFuncType(m_nChannels, false),
  m_chExpPileupFuncs(m_nChannels, zeroPileupFunc),
  m_ch2ndOrderStretchedExpPileupFuncs(m_nChannels, zeroPileupFunc),
  m_chExpPileupMSE(m_nChannels, 0),
  m_ch2ndOrderStretchedExpPileupMSE(m_nChannels, 0),
  m_chStatus(m_nChannels)
{
  if (m_endSignalSample == 0) m_endSignalSample = m_nSamples; // sentinel value 0 -> go to end of waveform
  if (m_outputCalibFactors.size() != m_nChannels) {
    (*m_msgFunc_p)(ZDCMsg::Fatal,
      "RPDDataAnalyzer::RPDDataAnalyzer: received incorrect number of channels in calibration factors ("
        + std::to_string(m_outputCalibFactors.size()) + " != " + std::to_string(m_nChannels) + ")"
    );
  }
  m_sideStatus.reset();
  m_sideStatus.set(ValidBit, true);
  for (auto& status : m_chStatus) {
    status.reset();
    status.set(ValidBit, true);
  }
}

~RPDDataAnalyzer()

virtual RPDDataAnalyzer::~RPDDataAnalyzer ( )

virtualdefault

Member Function Documentation

analyzeData()

void RPDDataAnalyzer::analyzeData

(

)

Analyze RPD data.

Definition at line 450 of file RPDDataAnalyzer.cxx.

{
  if (m_nChannelsLoaded != m_nChannels) {
    (*m_msgFunc_p)(ZDCMsg::Warn,
      "RPDDataAnalyzer::analyzeData: analyzing data with " + std::to_string(m_nChannelsLoaded) + " of "
      + std::to_string(m_nChannels) + " channels loaded"
    );
  }
  for (unsigned int channel = 0; channel < m_nChannels; channel++) {
    if (!checkOverflow(channel)) {
      // there was overflow, stop analysis
      m_chStatus.at(channel).set(ValidBit, false);
      continue;
    }
    if (!checkPulses(channel)) {
      // there was a pre-pulse or post-pulse, stop analysis
      m_chStatus.at(channel).set(ValidBit, false);
      continue;
    }
    // there is either only a good pulse or no pulse
    // only do baseline and pileup subtraction if there is a pulse!
    if (!m_chStatus.at(channel)[NoPulseBit] /* there is a pulse -> */ && !doBaselinePileupSubtraction(channel)) {
      // there was a pulse and a problem with baseline/pileup subtraction, stop analysis
      m_chStatus.at(channel).set(ValidBit, false);
      continue;
    }
    calculateMaxSampleMaxAdc(channel);
    calculateSumAdc(channel);
  }
  setSideStatusBits();
}

calculateBaselineSamplesMSE()

float RPDDataAnalyzer::calculateBaselineSamplesMSE ( unsigned int  channel, std::function< float(unsigned int)> const &  fit  ) const

private

Calculate the mean squared error of the fit function in the baseline samples.

Definition at line 182 of file RPDDataAnalyzer.cxx.

{
  float MSE = 0;
  for (unsigned int sample = 0; sample < m_nBaselineSamples; sample++) {
    MSE += std::pow(m_chFadcData.at(channel).at(sample) - m_chBaseline.at(channel) - fit(sample), 2);
  }
  MSE /= m_nBaselineSamples;
  return MSE;
}

calculateMaxSampleMaxAdc()

void RPDDataAnalyzer::calculateMaxSampleMaxAdc ( unsigned int  channel )

private

Calculate max ADC and max sample.

Definition at line 356 of file RPDDataAnalyzer.cxx.

{
  if (m_chStatus.at(channel)[NoPulseBit]) {
    m_chMaxAdc.at(channel) = 0;
    m_chMaxAdcCalib.at(channel) = 0;
    m_chMaxSample.at(channel) = -1;
    return;
  }
  float maxAdc = -std::numeric_limits<float>::infinity();
  unsigned int maxSample = 0;
  for (unsigned int sample = m_nBaselineSamples; sample < m_endSignalSample; sample++) {
    float adc = m_chCorrectedFadcData.at(channel).at(sample);
    if (adc > maxAdc) {
      maxAdc = adc;
      maxSample = sample;
    }
  }
  m_chMaxAdc.at(channel) = maxAdc;
  m_chMaxAdcCalib.at(channel) = maxAdc*m_outputCalibFactors.at(channel);
  m_chMaxSample.at(channel) = maxSample;
}

calculateSumAdc()

void RPDDataAnalyzer::calculateSumAdc ( unsigned int  channel )

private

Calculate sum ADC and if there is pileup, calculate fractional pileup.

Definition at line 381 of file RPDDataAnalyzer.cxx.

                                                          {
  if (m_chStatus.at(channel)[NoPulseBit]) {
    m_chSumAdc.at(channel) = 0;
    m_chSumAdcCalib.at(channel) = 0;
    return;
  }
  // sum range is after baseline until end of signal
  float signalRangeAdcSum = 0;
  for (unsigned int sample = m_nBaselineSamples; sample < m_endSignalSample; sample++) {
    signalRangeAdcSum += m_chCorrectedFadcData.at(channel).at(sample);
  }
  m_chSumAdc.at(channel) = signalRangeAdcSum;
  m_chSumAdcCalib.at(channel) = signalRangeAdcSum*m_outputCalibFactors.at(channel);
 
  if (m_chStatus.at(channel)[OutOfTimePileupBit]) {
    // there is pileup in this channel, calculate fraction of baseline-subtracted raw signal
    // that is pileup (beginning of window until end of signal)
    std::function<float(unsigned int)> pileupFunc;
    if (m_chPileupFuncType.at(channel)) {
      // use stretched exponential
      pileupFunc = m_ch2ndOrderStretchedExpPileupFuncs.at(channel);
    } else {
      // use exponential
      pileupFunc = m_chExpPileupFuncs.at(channel);
    }
 
    float totalAdcSum = 0;
    float pileupTotalAdcSum = 0;
    for (unsigned int sample = 0; sample < m_endSignalSample; sample++) {
      totalAdcSum += m_chFadcData.at(channel).at(sample) - m_nominalBaseline;
      pileupTotalAdcSum += pileupFunc(sample);
    }
    if (totalAdcSum > 0) {
      m_chPileupFrac.at(channel) = pileupTotalAdcSum/totalAdcSum;
    } else {
      // avoid dividing by zero or negative, return sentinel value of -1
      m_chPileupFrac.at(channel) = -1;
    }
  } // else fractional pileup is zero initialized, and this is what we want for no pileup
}

checkOverflow()

bool RPDDataAnalyzer::checkOverflow ( unsigned int  channel )

private

Check for overflow and set relevant status bit.

Returns true if there was NO overflow (c'est bon).

Definition at line 123 of file RPDDataAnalyzer.cxx.

{
  for (unsigned int sample = 0; sample < m_nSamples; sample++) {
    if (m_chFadcData.at(channel).at(sample) >= m_AdcOverflow) {
      m_chStatus.at(channel).set(OverflowBit, true);
      return false; // overflow - not good
    }
  }
  return true; // all good
}

checkPulses()

bool RPDDataAnalyzer::checkPulses ( unsigned int  channel )

private

Calculate 2nd difference, identify pulses, and set relevant status bits.

Returns true if there is a good pulse detected, false if there was a problem, e.g., no pulse or a pulse outside of the expected range.

Definition at line 139 of file RPDDataAnalyzer.cxx.

                                                      {
  float prePulseSize = 0;
  unsigned int prePulseSample = 0;
  float goodPulseSize = 0;
  unsigned int goodPulseSample = 0;
  float postPulseSize = 0;
  unsigned int postPulseSample = 0;
  for (unsigned int sample = 1; sample < m_nSamples - 1; sample++) {
    float secondDiff = m_chFadcData.at(channel).at(sample + 1) - 2*m_chFadcData.at(channel).at(sample) + m_chFadcData.at(channel).at(sample - 1);
    if (secondDiff > m_pulse2ndDerivThresh) continue; // no pulse here
    if (sample < m_goodPulseSampleStart && secondDiff < prePulseSize) {
      prePulseSize = secondDiff;
      prePulseSample = sample;
    } else if (sample >= m_goodPulseSampleStart && sample <= m_goodPulseSampleStop && secondDiff < goodPulseSize) {
      goodPulseSize = secondDiff;
      goodPulseSample = sample;
    } else if (sample > m_goodPulseSampleStop && secondDiff < postPulseSize) {
      postPulseSize = secondDiff;
      postPulseSample = sample;
    }
  }
 
  bool hasPrePulse = prePulseSample;
  bool hasGoodPulse = goodPulseSample;
  bool hasPostPulse = postPulseSample;
 
  // we need to accomodate side A, which has dips in second derivative after good pulse range
  // if post-pulses are sufficiently small, we ignore them
  // we expect these anomolies at ~ sample 11 or 12
  if (hasGoodPulse && hasPostPulse && postPulseSize/goodPulseSize <= m_postPulseFracThresh) hasPostPulse = false;
 
  bool hasNoPulse = !hasPrePulse && !hasGoodPulse && !hasPostPulse;
 
  if (hasPrePulse) m_chStatus.at(channel).set(PrePulseBit, true);
  if (hasPostPulse) m_chStatus.at(channel).set(PostPulseBit, true);
  if (hasNoPulse) m_chStatus.at(channel).set(NoPulseBit, true);
 
  return !hasPrePulse && !hasPostPulse; // true if there is a only good pulse or if there is no pulse
}

countSignalRangeNegatives()

unsigned int RPDDataAnalyzer::countSignalRangeNegatives ( std::vector< float > const &  values ) const

private

Calculate the number of negative values in signal range.

Definition at line 264 of file RPDDataAnalyzer.cxx.

{
  unsigned int nNegatives = 0;
  for (unsigned int sample = m_nBaselineSamples; sample < m_endSignalSample; sample++) {
    if (values.at(sample) < 0) nNegatives++;
  }
  return nNegatives;
}

doBaselinePileupSubtraction()

bool RPDDataAnalyzer::doBaselinePileupSubtraction ( unsigned int  channel )

private

Determine if there is pileup, subtract baseline and pileup, and set relevant status bits.

Returns true if pileup subtraction succeeded, false if there was a problem.

points (sample, baseline-subtracted ADC) with ADC above baseline, to be used in fit in case of pileup

Definition at line 277 of file RPDDataAnalyzer.cxx.

                                                                      {
  float nominalBaselineSubtrSum = 0;
  std::vector<std::pair<unsigned int, float>> pileupFitPoints;
  for (unsigned int sample = 0; sample < m_nBaselineSamples; sample++) {
    float const& adc = m_chFadcData.at(channel).at(sample);
    float const adcBaselineSubtr = adc - m_nominalBaseline;
    nominalBaselineSubtrSum += adcBaselineSubtr;
    if (adcBaselineSubtr > 0) {
      // this sample is a candidate for pileup fit
      pileupFitPoints.emplace_back(sample, adcBaselineSubtr);
    }
  }
  float baselineStdDev = TMath::RMS(m_chFadcData.at(channel).begin(), std::next(m_chFadcData.at(channel).begin(), m_nBaselineSamples));
 
  if (nominalBaselineSubtrSum < m_pileupBaselineSumThresh || baselineStdDev < m_pileupBaselineStdDevThresh) {
    // there is NO pileup, we will trust the average of baseline samples as a good baseline estimate
    m_chBaseline.at(channel) = TMath::Mean(m_chFadcData.at(channel).begin(), std::next(m_chFadcData.at(channel).begin(), m_nBaselineSamples));
    // calculate fadc data with baseline subtracted
    for (unsigned int sample = 0; sample < m_nSamples; sample++) {
      m_chCorrectedFadcData.at(channel).at(sample) = m_chFadcData.at(channel).at(sample) - m_chBaseline.at(channel);
    }
    if (countSignalRangeNegatives(m_chCorrectedFadcData.at(channel)) > m_nNegativesAllowed) {
      m_chStatus.at(channel).set(BadAvgBaselineSubtrBit, true);
      return false;
    }
    return true; // all good
  }
 
  // we suspect that there is pileup - use nominal baseline
  m_chBaseline.at(channel) = m_nominalBaseline;
 
  if (pileupFitPoints.size() < s_minPileupFitPoints) {
    m_chStatus.at(channel).set(InsufficientPileupFitPointsBit, true);
    // there are not enough points to do fit, so just use nominal baseline and call it a day
    for (unsigned int sample = 0; sample < m_nSamples; sample++) {
      m_chCorrectedFadcData.at(channel).at(sample) = m_chFadcData.at(channel).at(sample) - m_chBaseline.at(channel);
    }
    return true; // all good
  }
 
  // there is OOT pileup in this channel => expect approx. negative exponential in baseline samples
  m_chStatus.at(channel).set(OutOfTimePileupBit, true);
  // fit (approximately) to exponential and stretched exponential in baseline samples
  bool expFitSuccess = doPileupExpFit(channel, pileupFitPoints);
  bool stretchedExpFitSuccess = doPileupStretchedExpFit(channel, pileupFitPoints);
 
  if (stretchedExpFitSuccess) {
    // calculate fadc data with baseline and pileup contribution subtracted
    for (unsigned int sample = 0; sample < m_nSamples; sample++) {
      m_chCorrectedFadcData.at(channel).at(sample) = m_chFadcData.at(channel).at(sample) - m_chBaseline.at(channel) - m_ch2ndOrderStretchedExpPileupFuncs.at(channel)(sample);
    }
    if (countSignalRangeNegatives(m_chCorrectedFadcData.at(channel)) > m_nNegativesAllowed) {
      m_chStatus.at(channel).set(PileupBadStretchedExpSubtrBit, true);
      // fallback to exponential fit
    } else {
      m_chPileupFuncType.at(channel) = true;
      return true; // all good
    }
  }
 
  if (expFitSuccess) {
    // calculate fadc data with baseline and pileup contribution subtracted
    for (unsigned int sample = 0; sample < m_nSamples; sample++) {
      m_chCorrectedFadcData.at(channel).at(sample) = m_chFadcData.at(channel).at(sample) - m_chBaseline.at(channel) - m_chExpPileupFuncs.at(channel)(sample);
    }
    if (countSignalRangeNegatives(m_chCorrectedFadcData.at(channel)) > m_nNegativesAllowed) {
      m_chStatus.at(channel).set(PileupBadExpSubtrBit, true);
      return false;
    }
    return true; // all good
  }
 
  return false; // both fits are bad...we have no measure of pileup!
}

doPileupExpFit()

bool RPDDataAnalyzer::doPileupExpFit ( unsigned int  channel, std::vector< std::pair< unsigned int, float >> const &  pileupFitPoints  )

private

Perform an exponential fit in baseline-subtracted baseline samples and set relevant status bits.

Returns true if the fit and subtraction are good, false if there was a problem.

Definition at line 196 of file RPDDataAnalyzer.cxx.

{
  TLinearFitter fitter(1, "1 ++ x");
  double x;
  for (auto const& [sample, y] : pileupFitPoints) {
    x = sample;
    fitter.AddPoint(&x, std::log(y));
  }
  if (fitter.Eval()) {
    (*m_msgFunc_p)(ZDCMsg::Warn, "RPDDataAnalyzer::doPileupExpFit: there was an error while evaluating TLinearFitter!");
    m_chStatus.at(channel).set(PileupExpFitFailBit, true);
    return false;
  }
  m_chPileupExpFitParams.at(channel) = {static_cast<float>(fitter.GetParameter(0)), static_cast<float>(fitter.GetParameter(1))};
  m_chPileupExpFitParamErrs.at(channel) = {static_cast<float>(fitter.GetParError(0)), static_cast<float>(fitter.GetParError(1))};
  m_chExpPileupFuncs.at(channel) = [intercept = fitter.GetParameter(0), slope = fitter.GetParameter(1)](unsigned int sample) { return std::exp(intercept + slope*sample); };
  m_chExpPileupMSE.at(channel) = calculateBaselineSamplesMSE(channel, m_chExpPileupFuncs.at(channel));
 
  // check for exponential growth in parameters - we definitely don't want that for a function that describes pileup
  if (fitter.GetParameter(1) >= 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupExpFit: p1 is " + std::to_string(fitter.GetParameter(1)) + " > 0 -> there is exponential growth in fit function!");
    m_chStatus.at(channel).set(PileupExpGrowthBit, true);
    return false;
  }
  return true; // all good
}

doPileupStretchedExpFit()

bool RPDDataAnalyzer::doPileupStretchedExpFit ( unsigned int  channel, std::vector< std::pair< unsigned int, float >> const &  pileupFitPoints  )

private

Perform a stretched exponential fit in baseline-subtracted baseline samples and set relevant status bits.

Returns true if the fit and subtraction are good, false if there was a problem.

Definition at line 227 of file RPDDataAnalyzer.cxx.

{
  TLinearFitter fitter(1, "1 ++ (x + 4)**(0.5) ++ (x + 4)**(-0.5)");
  double x;
  for (auto const& [sample, y] : pileupFitPoints) {
    x = sample;
    fitter.AddPoint(&x, std::log(y));
  }
  if (fitter.Eval()) {
    (*m_msgFunc_p)(ZDCMsg::Warn, "RPDDataAnalyzer::doPileupStretchedExpFit: there was an error while evaluating TLinearFitter!");
    m_chStatus.at(channel).set(PileupStretchedExpFitFailBit, true);
    return false;
  }
  m_chPileupStretchedExpFitParams.at(channel) = {static_cast<float>(fitter.GetParameter(0)), static_cast<float>(fitter.GetParameter(1)), static_cast<float>(fitter.GetParameter(2))};
  m_chPileupStretchedExpFitParamErrs.at(channel) = {static_cast<float>(fitter.GetParError(0)), static_cast<float>(fitter.GetParError(1)), static_cast<float>(fitter.GetParError(2))};
  m_ch2ndOrderStretchedExpPileupFuncs.at(channel) = [p0 = fitter.GetParameter(0), p1 = fitter.GetParameter(1), p2 = fitter.GetParameter(2)](unsigned int sample) {
    return std::exp(p0 + p1*std::pow(sample + 4, 0.5) + p2*std::pow(sample + 4, -0.5));
  };
  m_ch2ndOrderStretchedExpPileupMSE.at(channel) = calculateBaselineSamplesMSE(channel, m_ch2ndOrderStretchedExpPileupFuncs.at(channel));
 
  // check for exponential growth in parameters - we definitely don't want that for a function that describes pileup
  if (fitter.GetParameter(1) >= 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupStretchedExpFit: p1 is " + std::to_string(fitter.GetParameter(1)) + " > 0 -> there is exponential growth in fit function!");
    m_chStatus.at(channel).set(PileupStretchedExpGrowthBit, true);
    return false;
  }
  if (fitter.GetParameter(2)/fitter.GetParameter(1) - 4 > 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupStretchedExpFit: 1st deriv max occurs at sample " + std::to_string(fitter.GetParameter(1)) + " > 0 -> fit probably looks like a pulse (and not like pileup)");
    m_chStatus.at(channel).set(PileupStretchedExpPulseLikeBit, true);
    // analysis remains valid (for now)
  }
  return true; // all good
}

getChBaseline()

float RPDDataAnalyzer::getChBaseline

(

unsigned int

channel

)

const

Get baseline used in baseline subtraction.

Definition at line 533 of file RPDDataAnalyzer.cxx.

                                                               {
  return m_chBaseline.at(channel);
}

getChMaxAdc()

float RPDDataAnalyzer::getChMaxAdc

(

unsigned int

channel

)

const

Get max of RPD data in signal range after baseline and pileup subtraction.

Definition at line 509 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxAdc.at(channel);
}

getChMaxAdcCalib()

float RPDDataAnalyzer::getChMaxAdcCalib

(

unsigned int

channel

)

const

Get max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied.

Definition at line 517 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxAdcCalib.at(channel);
}

getChMaxSample()

unsigned int RPDDataAnalyzer::getChMaxSample

(

unsigned int

channel

)

const

Get sample of max of RPD data in signal range after pileup subtraction.

Definition at line 485 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxSample.at(channel);
}

getChPileupExpFitMSE()

float RPDDataAnalyzer::getChPileupExpFitMSE

(

unsigned int

channel

)

const

Get mean squared error of pileup exponential fit in baseline samples (if pileup was detected and fit did not fail).

Definition at line 568 of file RPDDataAnalyzer.cxx.

                                                                      {
  return m_chExpPileupMSE.at(channel);
}

getChPileupExpFitParamErrs()

const std::vector< float > & RPDDataAnalyzer::getChPileupExpFitParamErrs

(

unsigned int

channel

)

const

Get parameter errors for pileup exponential fit (if pileup was detected and fit did not fail).

Definition at line 554 of file RPDDataAnalyzer.cxx.

                                                                                              {
  return m_chPileupExpFitParamErrs.at(channel);
}

getChPileupExpFitParams()

const std::vector< float > & RPDDataAnalyzer::getChPileupExpFitParams

(

unsigned int

channel

)

const

Get parameters for pileup exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*sample ).

Definition at line 540 of file RPDDataAnalyzer.cxx.

                                                                                           {
  return m_chPileupExpFitParams.at(channel);
}

getChPileupFrac()

float RPDDataAnalyzer::getChPileupFrac

(

unsigned int

channel

)

const

Get OOT pileup sum as a fraction of non-pileup sum in entire window (0 if no OOT pileup, -1 if sum ADC <= 0).

Definition at line 525 of file RPDDataAnalyzer.cxx.

{
  return m_chPileupFrac.at(channel);
}

getChPileupStretchedExpFitMSE()

float RPDDataAnalyzer::getChPileupStretchedExpFitMSE

(

unsigned int

channel

)

const

Get mean squared error of pileup stretched exponential fit in baseline samples (if pileup was detected and fit did not fail).

Definition at line 575 of file RPDDataAnalyzer.cxx.

                                                                               {
  return m_ch2ndOrderStretchedExpPileupMSE.at(channel);
}

getChPileupStretchedExpFitParamErrs()

const std::vector< float > & RPDDataAnalyzer::getChPileupStretchedExpFitParamErrs

(

unsigned int

channel

)

const

Get parameter errors for pileup stretched exponential fit (if pileup was detected and fit did not fail).

Definition at line 561 of file RPDDataAnalyzer.cxx.

                                                                                                       {
  return m_chPileupStretchedExpFitParamErrs.at(channel);
}

getChPileupStretchedExpFitParams()

const std::vector< float > & RPDDataAnalyzer::getChPileupStretchedExpFitParams

(

unsigned int

channel

)

const

Get parameters for pileup stretched exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*(sample + 4)**(0.5) + [2]*(sample + 4)**(-0.5) ).

Definition at line 547 of file RPDDataAnalyzer.cxx.

                                                                                                    {
  return m_chPileupStretchedExpFitParams.at(channel);
}

getChStatus()

unsigned int RPDDataAnalyzer::getChStatus

(

unsigned int

channel

)

const

Get status word for channel.

Definition at line 582 of file RPDDataAnalyzer.cxx.

{
  return static_cast<unsigned int>(m_chStatus.at(channel).to_ulong());
}

getChSumAdc()

float RPDDataAnalyzer::getChSumAdc

(

unsigned int

channel

)

const

Get sum of RPD data in signal range after baseline and pileup subtraction.

Definition at line 493 of file RPDDataAnalyzer.cxx.

{
  return m_chSumAdc.at(channel);
}

getChSumAdcCalib()

float RPDDataAnalyzer::getChSumAdcCalib

(

unsigned int

channel

)

const

Get sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied.

Definition at line 501 of file RPDDataAnalyzer.cxx.

{
  return m_chSumAdcCalib.at(channel);
}

getSideStatus()

unsigned int RPDDataAnalyzer::getSideStatus

(

)

const

Get status word for side.

Definition at line 590 of file RPDDataAnalyzer.cxx.

{
  return static_cast<unsigned int>(m_sideStatus.to_ulong());
}

loadChannelData()

void RPDDataAnalyzer::loadChannelData	(	unsigned int	channel,
		const std::vector< uint16_t > &	FadcData
	)

Load a single channel's FADC data into member variable.

Definition at line 71 of file RPDDataAnalyzer.cxx.

{
  if (FadcData.size() != m_nSamples) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "RPDDataAnalyzer::loadChannelData: received incorrect number of samples in FADC data");
  }
  for (unsigned int sample = 0; sample < m_nSamples; sample++) {
    m_chFadcData.at(channel).at(sample) = FadcData.at(sample);
  }
  m_nChannelsLoaded++;
}

reset()

void RPDDataAnalyzer::reset

(

)

Reset all member variables to default values.

Definition at line 85 of file RPDDataAnalyzer.cxx.

{
  // reset status bits; valid bit is true by default
  m_sideStatus.reset();
  m_sideStatus.set(ValidBit, true);
  for (auto& status : m_chStatus) {
    status.reset();
    status.set(ValidBit, true);
  }
 
  zeroVectorVector(m_chFadcData);
  zeroVectorVector(m_chCorrectedFadcData);
  zeroVectorVector(m_chPileupExpFitParams);
  zeroVectorVector(m_chPileupStretchedExpFitParams);
  zeroVectorVector(m_chPileupExpFitParamErrs);
  zeroVectorVector(m_chPileupStretchedExpFitParamErrs);
  m_chPileupFuncType.assign(m_chPileupFuncType.size(), false);
 
  zeroPileupFuncVector(m_chExpPileupFuncs);
  zeroPileupFuncVector(m_ch2ndOrderStretchedExpPileupFuncs);
 
  zeroVector(m_chExpPileupMSE);
  zeroVector(m_ch2ndOrderStretchedExpPileupMSE);
 
  m_nChannelsLoaded = 0;
  zeroVector(m_chMaxSample);
  zeroVector(m_chSumAdc);
  zeroVector(m_chSumAdcCalib);
  zeroVector(m_chMaxAdc);
  zeroVector(m_chMaxAdcCalib);
  zeroVector(m_chPileupFrac);
  zeroVector(m_chBaseline);
}

setSideStatusBits()

void RPDDataAnalyzer::setSideStatusBits ( )

private

Set side status bits according to channel status bits.

Definition at line 425 of file RPDDataAnalyzer.cxx.

{
  for (unsigned int channel = 0; channel < m_nChannels; channel++) {
    if (!m_chStatus.at(channel)[ValidBit]) m_sideStatus.set(ValidBit, false);
 
    if (m_chStatus.at(channel)[OutOfTimePileupBit]) m_sideStatus.set(OutOfTimePileupBit, true);
    if (m_chStatus.at(channel)[OverflowBit]) m_sideStatus.set(OverflowBit, true);
    if (m_chStatus.at(channel)[PrePulseBit]) m_sideStatus.set(PrePulseBit, true);
    if (m_chStatus.at(channel)[PostPulseBit]) m_sideStatus.set(PostPulseBit, true);
    if (m_chStatus.at(channel)[NoPulseBit]) m_sideStatus.set(NoPulseBit, true);
    if (m_chStatus.at(channel)[BadAvgBaselineSubtrBit]) m_sideStatus.set(BadAvgBaselineSubtrBit, true);
    if (m_chStatus.at(channel)[InsufficientPileupFitPointsBit]) m_sideStatus.set(InsufficientPileupFitPointsBit, true);
    if (m_chStatus.at(channel)[PileupStretchedExpFitFailBit]) m_sideStatus.set(PileupStretchedExpFitFailBit, true);
    if (m_chStatus.at(channel)[PileupStretchedExpGrowthBit]) m_sideStatus.set(PileupStretchedExpGrowthBit, true);
    if (m_chStatus.at(channel)[PileupBadStretchedExpSubtrBit]) m_sideStatus.set(PileupBadStretchedExpSubtrBit, true);
    if (m_chStatus.at(channel)[PileupExpFitFailBit]) m_sideStatus.set(PileupExpFitFailBit, true);
    if (m_chStatus.at(channel)[PileupExpGrowthBit]) m_sideStatus.set(PileupExpGrowthBit, true);
    if (m_chStatus.at(channel)[PileupBadExpSubtrBit]) m_sideStatus.set(PileupBadExpSubtrBit, true);
    if (m_chStatus.at(channel)[PileupStretchedExpPulseLikeBit]) m_sideStatus.set(PileupStretchedExpPulseLikeBit, true);
  }
}

Member Data Documentation

m_AdcOverflow

unsigned int RPDDataAnalyzer::m_AdcOverflow

private

Maximum number of negative ADC values after baseline and pileup subtraction allowed in signal range.

Definition at line 113 of file RPDDataAnalyzer.h.

m_ch2ndOrderStretchedExpPileupFuncs

std::vector<std::function<float(unsigned int)> > RPDDataAnalyzer::m_ch2ndOrderStretchedExpPileupFuncs

private

pileup exponential fit function (if pileup was detected and fit did not fail); per channel

Definition at line 131 of file RPDDataAnalyzer.h.

m_ch2ndOrderStretchedExpPileupMSE

std::vector<float> RPDDataAnalyzer::m_ch2ndOrderStretchedExpPileupMSE

private

mean squared error of pileup exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel

Definition at line 133 of file RPDDataAnalyzer.h.

m_chBaseline

std::vector<float> RPDDataAnalyzer::m_chBaseline

private

OOT pileup sum as a fraction of non-pileup sum in entire window (0 if no OOT pileup, -1 if sum ADC <= 0); per channel.

Definition at line 124 of file RPDDataAnalyzer.h.

m_chCorrectedFadcData

std::vector<std::vector<float> > RPDDataAnalyzer::m_chCorrectedFadcData

private

raw RPD data; index channel then sample

Definition at line 117 of file RPDDataAnalyzer.h.

m_chExpPileupFuncs

std::vector<std::function<float(unsigned int)> > RPDDataAnalyzer::m_chExpPileupFuncs

private

true when stretched exponential is used, false if exponential is used for pileup subtraction (if pileup was detected); per channel

Definition at line 130 of file RPDDataAnalyzer.h.

m_chExpPileupMSE

std::vector<float> RPDDataAnalyzer::m_chExpPileupMSE

private

pileup stretched exponential fit function (if pileup was detected and fit did not fail); per channel

Definition at line 132 of file RPDDataAnalyzer.h.

m_chFadcData

std::vector<std::vector<float> > RPDDataAnalyzer::m_chFadcData

private

multiplicative calibration factors to apply to output, e.g., max and sum ADC; per channel

Definition at line 116 of file RPDDataAnalyzer.h.

m_chMaxAdc

std::vector<float> RPDDataAnalyzer::m_chMaxAdc

private

sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel

Definition at line 121 of file RPDDataAnalyzer.h.

m_chMaxAdcCalib

std::vector<float> RPDDataAnalyzer::m_chMaxAdcCalib

private

max of RPD data in signal range after baseline and pileup subtraction; per channel

Definition at line 122 of file RPDDataAnalyzer.h.

m_chMaxSample

std::vector<float> RPDDataAnalyzer::m_chMaxSample

private

RPD data with baseline and pileup subtracted; index channel then sample.

Definition at line 118 of file RPDDataAnalyzer.h.

m_chPileupExpFitParamErrs

std::vector<std::vector<float> > RPDDataAnalyzer::m_chPileupExpFitParamErrs

private

parameters for pileup stretched exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*(sample + 4)**(0.5) + [2]*(sample + 4)**(-0.5) ); per channel

Definition at line 127 of file RPDDataAnalyzer.h.

m_chPileupExpFitParams

std::vector<std::vector<float> > RPDDataAnalyzer::m_chPileupExpFitParams

private

baseline used in baseline subtraction; per channel

Definition at line 125 of file RPDDataAnalyzer.h.

m_chPileupFrac

std::vector<float> RPDDataAnalyzer::m_chPileupFrac

private

max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel

Definition at line 123 of file RPDDataAnalyzer.h.

m_chPileupFuncType

std::vector<bool> RPDDataAnalyzer::m_chPileupFuncType

private

parameter errors for pileup stretched exponential fit (if pileup was detected and fit did not fail); per channel

Definition at line 129 of file RPDDataAnalyzer.h.

m_chPileupStretchedExpFitParamErrs

std::vector<std::vector<float> > RPDDataAnalyzer::m_chPileupStretchedExpFitParamErrs

private

parameter errors for pileup exponential fit (if pileup was detected and fit did not fail); per channel

Definition at line 128 of file RPDDataAnalyzer.h.

m_chPileupStretchedExpFitParams

std::vector<std::vector<float> > RPDDataAnalyzer::m_chPileupStretchedExpFitParams

private

parameters for pileup exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*sample ); per channel

Definition at line 126 of file RPDDataAnalyzer.h.

m_chStatus

std::vector<std::bitset<32> > RPDDataAnalyzer::m_chStatus

private

mean squared error of pileup stretched exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel

Definition at line 134 of file RPDDataAnalyzer.h.

m_chSumAdc

std::vector<float> RPDDataAnalyzer::m_chSumAdc

private

sample of max of RPD data in signal range after pileup subtraction; per channel

Definition at line 119 of file RPDDataAnalyzer.h.

m_chSumAdcCalib

std::vector<float> RPDDataAnalyzer::m_chSumAdcCalib

private

sum of RPD data in signal range after baseline and pileup subtraction; per channel

Definition at line 120 of file RPDDataAnalyzer.h.

m_endSignalSample

unsigned int RPDDataAnalyzer::m_endSignalSample

private

Number of baseline samples; the sample equal to this number is the start of signal region.

Definition at line 104 of file RPDDataAnalyzer.h.

m_goodPulseSampleStart

unsigned int RPDDataAnalyzer::m_goodPulseSampleStart

private

If there is a good pulse and post-pulse and size of post-pulse as a fraction of good pulse is less than or equal to this number, ignore post-pulse.

Definition at line 107 of file RPDDataAnalyzer.h.

m_goodPulseSampleStop

unsigned int RPDDataAnalyzer::m_goodPulseSampleStop

private

Pulses before this sample are considered pre-pulses.

Definition at line 108 of file RPDDataAnalyzer.h.

m_msgFunc_p

ZDCMsg::MessageFunctionPtr RPDDataAnalyzer::m_msgFunc_p

private

Definition at line 96 of file RPDDataAnalyzer.h.

m_nBaselineSamples

unsigned int RPDDataAnalyzer::m_nBaselineSamples

private

Definition at line 103 of file RPDDataAnalyzer.h.

m_nChannels

unsigned int RPDDataAnalyzer::m_nChannels

private

Definition at line 100 of file RPDDataAnalyzer.h.

m_nChannelsLoaded

unsigned int RPDDataAnalyzer::m_nChannelsLoaded = 0

private

Definition at line 101 of file RPDDataAnalyzer.h.

m_nColumns

unsigned int RPDDataAnalyzer::m_nColumns

private

Definition at line 99 of file RPDDataAnalyzer.h.

m_nNegativesAllowed

unsigned int RPDDataAnalyzer::m_nNegativesAllowed

private

Baseline standard deviations less than this number indicate there is not pileup.

Definition at line 112 of file RPDDataAnalyzer.h.

m_nominalBaseline

unsigned int RPDDataAnalyzer::m_nominalBaseline

private

Pulses after this sample are considered post-pulses.

Definition at line 109 of file RPDDataAnalyzer.h.

m_nRows

unsigned int RPDDataAnalyzer::m_nRows

private

Definition at line 98 of file RPDDataAnalyzer.h.

m_nSamples

unsigned int RPDDataAnalyzer::m_nSamples

private

Definition at line 102 of file RPDDataAnalyzer.h.

m_outputCalibFactors

std::vector<float> RPDDataAnalyzer::m_outputCalibFactors

private

ADC values greater than or equal to this number are considered overflow.

Definition at line 114 of file RPDDataAnalyzer.h.

m_pileupBaselineStdDevThresh

float RPDDataAnalyzer::m_pileupBaselineStdDevThresh

private

Baseline sums less than this number indicate there is not pileup.

Definition at line 111 of file RPDDataAnalyzer.h.

m_pileupBaselineSumThresh

float RPDDataAnalyzer::m_pileupBaselineSumThresh

private

The global nominal baseline; used when pileup is detected.

Definition at line 110 of file RPDDataAnalyzer.h.

m_postPulseFracThresh

float RPDDataAnalyzer::m_postPulseFracThresh

private

Second differences less than or equal to this number indicate a pulse.

Definition at line 106 of file RPDDataAnalyzer.h.

m_pulse2ndDerivThresh

float RPDDataAnalyzer::m_pulse2ndDerivThresh

private

Samples before (not including) this sample are the signal region; nSamples goes to end of window.

Definition at line 105 of file RPDDataAnalyzer.h.

m_sideStatus

std::bitset<32> RPDDataAnalyzer::m_sideStatus

private

status bits per channel

Definition at line 135 of file RPDDataAnalyzer.h.

m_tag

std::string RPDDataAnalyzer::m_tag

private

Definition at line 97 of file RPDDataAnalyzer.h.

s_minPileupFitPoints

unsigned constexpr int RPDDataAnalyzer::s_minPileupFitPoints = 3

staticconstexprprivate

status bits for side

in the case of pileup, the number of points (above baseline) in baseline samples required to perform fit. this number must be at least the number of parameters in pileup fits, else inversion of Gram matrix in TLinearFitter will fail and generate ROOT error that propagates to Athena. if insufficient points, set InsufficientPileupFitPointsBit and abort pileup subtraction.

Definition at line 143 of file RPDDataAnalyzer.h.

---

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

• RPDDataAnalyzer.h
• RPDDataAnalyzer.cxx