ZDC::RPDDataAnalyzer Class Reference

#include <RPDDataAnalyzer.h>

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 , N_STATUS_BITS }
enum class	PileupFitFuncType { None , Exp , SecondOrderStretchedExp }

Public Member Functions
	RPDDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, std::string tag, RPDConfig const &config, std::vector< float > const &calibFactors)
virtual	~RPDDataAnalyzer ()=default
	RPDDataAnalyzer (RPDDataAnalyzer const &)=delete
RPDDataAnalyzer &	operator= (RPDDataAnalyzer const &)=delete
	RPDDataAnalyzer (RPDDataAnalyzer &&)=delete
RPDDataAnalyzer &	operator= (RPDDataAnalyzer &&)=delete
void	loadChannelData (unsigned int channel, const std::vector< uint16_t > &FadcData)
	Load a single channel's FADC data into member variable.
void	analyzeData ()
	Analyze RPD data.
unsigned int	getChMaxSample (unsigned int channel) const
	Get sample of max of RPD data in signal range after pileup subtraction.
float	getChSumAdc (unsigned int channel) const
	Get sum of RPD data in signal range after baseline and pileup subtraction.
float	getChSumAdcCalib (unsigned int channel) const
	Get sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied.
float	getChMaxAdc (unsigned int channel) const
	Get max of RPD data in signal range after baseline and pileup subtraction.
float	getChMaxAdcCalib (unsigned int channel) const
	Get max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied.
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).
float	getChBaseline (unsigned int channel) const
	Get baseline used in baseline subtraction.
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 ).
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) ).
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).
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).
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).
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).
unsigned int	getChStatus (unsigned int channel) const
	Get status word for channel.
unsigned int	getSideStatus () const
	Get status word for side.
void	reset ()
	Reset all member variables to default values.

Private Member Functions
bool	checkOverflow (unsigned int channel)
	Check for overflow and set relevant status bit.
bool	checkPulses (unsigned int channel)
	Calculate 2nd difference, identify pulses, and set relevant status bits.
unsigned int	countSignalRangeNegatives (std::vector< float > const &values) const
	Calculate the number of negative values in signal range.
bool	doBaselinePileupSubtraction (unsigned int channel)
	Determine if there is pileup, subtract baseline and pileup, and set relevant status bits.
void	calculateMaxSampleMaxAdc (unsigned int channel)
	Calculate max ADC and max sample.
void	calculateSumAdc (unsigned int channel)
	Calculate sum ADC and if there is pileup, calculate fractional pileup.
void	setSideStatusBits ()
	Set side status bits according to channel status bits.
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.
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.
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.

Private Attributes
ZDCMsg::MessageFunctionPtr	m_msgFunc_p
std::string	m_tag
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.
float	m_pulse2ndDerivThresh
	Samples before (not including) this sample are the signal region; nSamples goes to end of window.
float	m_postPulseFracThresh
	Second differences less than or equal to this number indicate a pulse.
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.
unsigned int	m_goodPulseSampleStop
	Pulses before this sample are considered pre-pulses.
float	m_nominalBaseline
	Pulses after this sample are considered post-pulses.
float	m_pileupBaselineSumThresh
	The global nominal baseline; used when pileup is detected.
float	m_pileupBaselineStdDevThresh
	Baseline sums less than this number indicate there is not pileup.
unsigned int	m_nNegativesAllowed
	Baseline standard deviations less than this number indicate there is not pileup.
unsigned int	m_AdcOverflow
	Maximum number of negative ADC values after baseline and pileup subtraction allowed in signal range.
std::array< float, s_nChannels >	m_outputCalibFactors {}
	ADC values greater than or equal to this number are considered overflow.
std::array< std::vector< uint16_t >, s_nChannels >	m_chFADCData
	multiplicative calibration factors to apply to output, e.g., max and sum ADC; per channel
std::array< std::vector< float >, s_nChannels >	m_chCorrectedFadcData
	raw RPD data; index channel then sample
std::array< unsigned int, s_nChannels >	m_chMaxSample {}
	RPD data with baseline and pileup subtracted; index channel then sample.
std::array< float, s_nChannels >	m_chSumAdc {}
	sample of max of RPD data in signal range after pileup subtraction; per channel
std::array< float, s_nChannels >	m_chSumAdcCalib {}
	sum of RPD data in signal range after baseline and pileup subtraction; per channel
std::array< float, s_nChannels >	m_chMaxAdc {}
	sum of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel
std::array< float, s_nChannels >	m_chMaxAdcCalib {}
	max of RPD data in signal range after baseline and pileup subtraction; per channel
std::array< float, s_nChannels >	m_chPileupFrac {}
	max of RPD data in signal range after baseline and pileup subtraction, with output calibration factors applied; per channel
std::array< float, s_nChannels >	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.
std::array< std::vector< float >, s_nChannels >	m_chPileupExpFitParams
	baseline used in baseline subtraction; per channel
std::array< std::vector< float >, s_nChannels >	m_chPileupStretchedExpFitParams
	parameters for pileup exponential fit (if pileup was detected and fit did not fail): exp( [0] + [1]*sample ); per channel
std::array< std::vector< float >, s_nChannels >	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
std::array< std::vector< float >, s_nChannels >	m_chPileupStretchedExpFitParamErrs
	parameter errors for pileup exponential fit (if pileup was detected and fit did not fail); per channel
std::array< PileupFitFuncType, s_nChannels >	m_chPileupFuncType {}
	parameter errors for pileup stretched exponential fit (if pileup was detected and fit did not fail); per channel
std::array< std::function< float(unsigned int)>, s_nChannels >	m_chExpPileupFuncs
	enum indicating type of pileup fit function; per channel
std::array< std::function< float(unsigned int)>, s_nChannels >	m_ch2ndOrderStretchedExpPileupFuncs
	pileup exponential fit function (if pileup was detected and fit did not fail); per channel
std::array< float, s_nChannels >	m_chExpPileupMSE {}
	pileup stretched exponential fit function (if pileup was detected and fit did not fail); per channel
std::array< float, s_nChannels >	m_ch2ndOrderStretchedExpPileupMSE {}
	mean squared error of pileup exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel
std::array< std::bitset< N_STATUS_BITS >, s_nChannels >	m_chStatus
	mean squared error of pileup stretched exponential fit in baseline samples (if pileup was detected and fit did not fail); per channel
std::bitset< N_STATUS_BITS >	m_sideStatus
	status bits per channel

Static Private Attributes
static unsigned int constexpr	s_nChannels = RPDUtils::nChannels
static unsigned int constexpr	s_minPileupFitPoints = 3
	status bits for side

Detailed Description

Definition at line 34 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
N_STATUS_BITS

Definition at line 36 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
    N_STATUS_BITS
  };

PileupFitFuncType

enum class ZDC::RPDDataAnalyzer::PileupFitFuncType

strong

Enumerator
None
Exp
SecondOrderStretchedExp

Definition at line 54 of file RPDDataAnalyzer.h.

                               {
    None, Exp, SecondOrderStretchedExp
  };

Constructor & Destructor Documentation

RPDDataAnalyzer() [1/3]

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

Definition at line 22 of file RPDDataAnalyzer.cxx.

  : m_msgFunc_p(std::move(messageFunc_p)),
    m_tag(std::move(tag)),
    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)
{
  if (m_endSignalSample == 0) m_endSignalSample = m_nSamples; // sentinel value 0 -> go to end of waveform
  if (m_outputCalibFactors.size() != s_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(s_nChannels) + ")"
    );
  }
  std::copy(calibFactors.begin(), calibFactors.end(), m_outputCalibFactors.data());
  m_chFADCData.fill(std::vector<uint16_t>(m_nSamples, 0));
  m_chCorrectedFadcData.fill(std::vector<float>(m_nSamples, 0));
  m_chPileupExpFitParams.fill(std::vector<float>(2, 0));
  m_chPileupStretchedExpFitParams.fill(std::vector<float>(3, 0));
  m_chPileupExpFitParamErrs.fill(std::vector<float>(2, 0));
  m_chPileupStretchedExpFitParamErrs.fill(std::vector<float>(3, 0));
  m_chPileupFuncType.fill(PileupFitFuncType::None);
  m_chExpPileupFuncs.fill(nullPileupFunc);
  m_ch2ndOrderStretchedExpPileupFuncs.fill(nullPileupFunc);
 
  m_sideStatus.reset();
  m_sideStatus.set(ValidBit, true);
  for (auto& status : m_chStatus) {
    status.reset();
    status.set(ValidBit, true);
  }
}

~RPDDataAnalyzer()

virtual ZDC::RPDDataAnalyzer::~RPDDataAnalyzer ( )

virtualdefault

RPDDataAnalyzer() [2/3]

ZDC::RPDDataAnalyzer::RPDDataAnalyzer ( RPDDataAnalyzer const & )

delete

RPDDataAnalyzer() [3/3]

ZDC::RPDDataAnalyzer::RPDDataAnalyzer ( RPDDataAnalyzer && )

delete

Member Function Documentation

analyzeData()

void ZDC::RPDDataAnalyzer::analyzeData

(

)

Analyze RPD data.

Definition at line 459 of file RPDDataAnalyzer.cxx.

{
  if (m_nChannelsLoaded != s_nChannels) {
    (*m_msgFunc_p)(ZDCMsg::Warn,
      "RPDDataAnalyzer::analyzeData: analyzing data with " + std::to_string(m_nChannelsLoaded) + " of "
      + std::to_string(s_nChannels) + " channels loaded"
    );
  }
  for (unsigned int channel = 0; channel < s_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 ZDC::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 183 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 ZDC::RPDDataAnalyzer::calculateMaxSampleMaxAdc ( unsigned int channel )

private

Calculate max ADC and max sample.

Definition at line 362 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 ZDC::RPDDataAnalyzer::calculateSumAdc ( unsigned int channel )

private

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

Definition at line 387 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;
    switch (m_chPileupFuncType.at(channel)) {
      case PileupFitFuncType::SecondOrderStretchedExp:
        pileupFunc = m_ch2ndOrderStretchedExpPileupFuncs.at(channel);
        break;
      case PileupFitFuncType::Exp:
        pileupFunc = m_chExpPileupFuncs.at(channel);
        break;
      default:
        break;
    }
 
    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 ZDC::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 124 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 ZDC::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 140 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 const 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 ZDC::RPDDataAnalyzer::countSignalRangeNegatives ( std::vector< float > const & values ) const

private

Calculate the number of negative values in signal range.

Definition at line 269 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 ZDC::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 282 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::StdDev(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) = PileupFitFuncType::SecondOrderStretchedExp;
      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;
    }
    m_chPileupFuncType.at(channel) = PileupFitFuncType::Exp;
    return true; // all good
  }
 
  return false; // both fits are bad...we have no measure of pileup!
}

doPileupExpFit()

bool ZDC::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 197 of file RPDDataAnalyzer.cxx.

{
  auto pFitter = std::make_unique<TLinearFitter>(1, "1 ++ x");
  double x {};
  for (auto const& [sample, y] : pileupFitPoints) {
    x = sample;
    pFitter->AddPoint(&x, std::log(y));
  }
  if (pFitter->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>(pFitter->GetParameter(0)), static_cast<float>(pFitter->GetParameter(1))};
  m_chPileupExpFitParamErrs.at(channel) = {static_cast<float>(pFitter->GetParError(0)), static_cast<float>(pFitter->GetParError(1))};
  m_chExpPileupFuncs.at(channel) = [intercept = pFitter->GetParameter(0), slope = pFitter->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 (pFitter->GetParameter(1) >= 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupExpFit: p1 is " + std::to_string(pFitter->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 ZDC::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 228 of file RPDDataAnalyzer.cxx.

{
  auto pFitter = std::make_unique<TLinearFitter>(1, "1 ++ (x + 4)**(0.5) ++ (x + 4)**(-0.5)");
  double x {};
  for (auto const& [sample, y] : pileupFitPoints) {
    x = sample;
    pFitter->AddPoint(&x, std::log(y));
  }
  if (pFitter->Eval()) {
    (*m_msgFunc_p)(ZDCMsg::Warn, "RPDDataAnalyzer::doPileupStretchedExpFit: there was an error while evaluating TLinearFitter!");
    m_chStatus.at(channel).set(PileupStretchedExpFitFailBit, true);
    return false;
  }
  auto getFitParam = [&pFitter](int i){return pFitter->GetParameter(i);};
  auto fGetFitErr = [&pFitter](int i){return static_cast<float>(pFitter->GetParError(i));};
  auto fGetFitParam = [&pFitter](int i){return static_cast<float>(pFitter->GetParameter(i));};
  //
  m_chPileupStretchedExpFitParams.at(channel) = {fGetFitParam(0), fGetFitParam(1), fGetFitParam(2)};
  m_chPileupStretchedExpFitParamErrs.at(channel) = {fGetFitErr(0), fGetFitErr(1), fGetFitErr(2)};
  m_ch2ndOrderStretchedExpPileupFuncs.at(channel) = [p0 = getFitParam(0), p1 = getFitParam(1), p2 = getFitParam(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 (getFitParam(1) >= 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupStretchedExpFit: p1 is " + std::to_string(getFitParam(1)) + " > 0 -> there is exponential growth in fit function!");
    m_chStatus.at(channel).set(PileupStretchedExpGrowthBit, true);
    return false;
  }
  if (getFitParam(2)/getFitParam(1) - 4 > 0) {
    (*m_msgFunc_p)(ZDCMsg::Debug, "RPDDataAnalyzer::doPileupStretchedExpFit: 1st deriv max occurs at sample " + std::to_string(getFitParam(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 ZDC::RPDDataAnalyzer::getChBaseline

(

unsigned int

channel

)

const

Get baseline used in baseline subtraction.

Definition at line 542 of file RPDDataAnalyzer.cxx.

                                                               {
  return m_chBaseline.at(channel);
}

getChMaxAdc()

float ZDC::RPDDataAnalyzer::getChMaxAdc

(

unsigned int

channel

)

const

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

Definition at line 518 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxAdc.at(channel);
}

getChMaxAdcCalib()

float ZDC::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 526 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxAdcCalib.at(channel);
}

getChMaxSample()

unsigned int ZDC::RPDDataAnalyzer::getChMaxSample

(

unsigned int

channel

)

const

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

Definition at line 494 of file RPDDataAnalyzer.cxx.

{
  return m_chMaxSample.at(channel);
}

getChPileupExpFitMSE()

float ZDC::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 577 of file RPDDataAnalyzer.cxx.

                                                                      {
  return m_chExpPileupMSE.at(channel);
}

getChPileupExpFitParamErrs()

const std::vector< float > & ZDC::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 563 of file RPDDataAnalyzer.cxx.

                                                                                              {
  return m_chPileupExpFitParamErrs.at(channel);
}

getChPileupExpFitParams()

const std::vector< float > & ZDC::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 549 of file RPDDataAnalyzer.cxx.

                                                                                           {
  return m_chPileupExpFitParams.at(channel);
}

getChPileupFrac()

float ZDC::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 534 of file RPDDataAnalyzer.cxx.

{
  return m_chPileupFrac.at(channel);
}

getChPileupStretchedExpFitMSE()

float ZDC::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 584 of file RPDDataAnalyzer.cxx.

                                                                               {
  return m_ch2ndOrderStretchedExpPileupMSE.at(channel);
}

getChPileupStretchedExpFitParamErrs()

const std::vector< float > & ZDC::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 570 of file RPDDataAnalyzer.cxx.

                                                                                                       {
  return m_chPileupStretchedExpFitParamErrs.at(channel);
}

getChPileupStretchedExpFitParams()

const std::vector< float > & ZDC::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 556 of file RPDDataAnalyzer.cxx.

                                                                                                    {
  return m_chPileupStretchedExpFitParams.at(channel);
}

getChStatus()

unsigned int ZDC::RPDDataAnalyzer::getChStatus

(

unsigned int

channel

)

const

Get status word for channel.

Definition at line 591 of file RPDDataAnalyzer.cxx.

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

getChSumAdc()

float ZDC::RPDDataAnalyzer::getChSumAdc

(

unsigned int

channel

)

const

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

Definition at line 502 of file RPDDataAnalyzer.cxx.

{
  return m_chSumAdc.at(channel);
}

getChSumAdcCalib()

float ZDC::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 510 of file RPDDataAnalyzer.cxx.

{
  return m_chSumAdcCalib.at(channel);
}

getSideStatus()

unsigned int ZDC::RPDDataAnalyzer::getSideStatus

(

)

const

Get status word for side.

Definition at line 599 of file RPDDataAnalyzer.cxx.

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

loadChannelData()

void ZDC::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 (" + std::to_string(FadcData.size()) + ", expected " + std::to_string(m_nSamples) + ")"
    );
  }
  m_chFADCData.at(channel) = FadcData;
  m_nChannelsLoaded++;
}

operator=() [1/2]

RPDDataAnalyzer & ZDC::RPDDataAnalyzer::operator= ( RPDDataAnalyzer && )

delete

operator=() [2/2]

RPDDataAnalyzer & ZDC::RPDDataAnalyzer::operator= ( RPDDataAnalyzer const & )

delete

reset()

void ZDC::RPDDataAnalyzer::reset

(

)

Reset all member variables to default values.

Definition at line 86 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);
  }
 
  RPDUtils::helpZero(m_chFADCData);
  RPDUtils::helpZero(m_chCorrectedFadcData);
  RPDUtils::helpZero(m_chPileupExpFitParams);
  RPDUtils::helpZero(m_chPileupStretchedExpFitParams);
  RPDUtils::helpZero(m_chPileupExpFitParamErrs);
  RPDUtils::helpZero(m_chPileupStretchedExpFitParamErrs);
  m_chPileupFuncType.fill(PileupFitFuncType::None);
 
  helpResetFuncs(m_chExpPileupFuncs);
  helpResetFuncs(m_ch2ndOrderStretchedExpPileupFuncs);
 
  RPDUtils::helpZero(m_chExpPileupMSE);
  RPDUtils::helpZero(m_ch2ndOrderStretchedExpPileupMSE);
 
  m_nChannelsLoaded = 0;
  RPDUtils::helpZero(m_chMaxSample);
  RPDUtils::helpZero(m_chSumAdc);
  RPDUtils::helpZero(m_chSumAdcCalib);
  RPDUtils::helpZero(m_chMaxAdc);
  RPDUtils::helpZero(m_chMaxAdcCalib);
  RPDUtils::helpZero(m_chPileupFrac);
  RPDUtils::helpZero(m_chBaseline);
}

setSideStatusBits()

void ZDC::RPDDataAnalyzer::setSideStatusBits ( )

private

Set side status bits according to channel status bits.

Definition at line 434 of file RPDDataAnalyzer.cxx.

{
  for (unsigned int channel = 0; channel < s_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 ZDC::RPDDataAnalyzer::m_AdcOverflow

private

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

Definition at line 119 of file RPDDataAnalyzer.h.

m_ch2ndOrderStretchedExpPileupFuncs

std::array<std::function<float(unsigned int)>, s_nChannels> ZDC::RPDDataAnalyzer::m_ch2ndOrderStretchedExpPileupFuncs

private

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

Definition at line 137 of file RPDDataAnalyzer.h.

m_ch2ndOrderStretchedExpPileupMSE

std::array<float, s_nChannels> ZDC::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 139 of file RPDDataAnalyzer.h.

{}; 

m_chBaseline

std::array<float, s_nChannels> ZDC::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 130 of file RPDDataAnalyzer.h.

{}; 

m_chCorrectedFadcData

std::array<std::vector<float>, s_nChannels> ZDC::RPDDataAnalyzer::m_chCorrectedFadcData

private

raw RPD data; index channel then sample

Definition at line 123 of file RPDDataAnalyzer.h.

m_chExpPileupFuncs

std::array<std::function<float(unsigned int)>, s_nChannels> ZDC::RPDDataAnalyzer::m_chExpPileupFuncs

private

enum indicating type of pileup fit function; per channel

Definition at line 136 of file RPDDataAnalyzer.h.

m_chExpPileupMSE

std::array<float, s_nChannels> ZDC::RPDDataAnalyzer::m_chExpPileupMSE {}

private

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

Definition at line 138 of file RPDDataAnalyzer.h.

{}; 

m_chFADCData

std::array<std::vector<uint16_t>, s_nChannels> ZDC::RPDDataAnalyzer::m_chFADCData

private

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

Definition at line 122 of file RPDDataAnalyzer.h.

m_chMaxAdc

std::array<float, s_nChannels> ZDC::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 127 of file RPDDataAnalyzer.h.

{}; 

m_chMaxAdcCalib

std::array<float, s_nChannels> ZDC::RPDDataAnalyzer::m_chMaxAdcCalib {}

private

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

Definition at line 128 of file RPDDataAnalyzer.h.

{}; 

m_chMaxSample

std::array<unsigned int, s_nChannels> ZDC::RPDDataAnalyzer::m_chMaxSample {}

private

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

Definition at line 124 of file RPDDataAnalyzer.h.

{}; 

m_chPileupExpFitParamErrs

std::array<std::vector<float>, s_nChannels> ZDC::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 133 of file RPDDataAnalyzer.h.

m_chPileupExpFitParams

std::array<std::vector<float>, s_nChannels> ZDC::RPDDataAnalyzer::m_chPileupExpFitParams

private

baseline used in baseline subtraction; per channel

Definition at line 131 of file RPDDataAnalyzer.h.

m_chPileupFrac

std::array<float, s_nChannels> ZDC::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 129 of file RPDDataAnalyzer.h.

{}; 

m_chPileupFuncType

std::array<PileupFitFuncType, s_nChannels> ZDC::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 135 of file RPDDataAnalyzer.h.

{}; 

m_chPileupStretchedExpFitParamErrs

std::array<std::vector<float>, s_nChannels> ZDC::RPDDataAnalyzer::m_chPileupStretchedExpFitParamErrs

private

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

Definition at line 134 of file RPDDataAnalyzer.h.

m_chPileupStretchedExpFitParams

std::array<std::vector<float>, s_nChannels> ZDC::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 132 of file RPDDataAnalyzer.h.

m_chStatus

std::array<std::bitset<N_STATUS_BITS>, s_nChannels> ZDC::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 140 of file RPDDataAnalyzer.h.

m_chSumAdc

std::array<float, s_nChannels> ZDC::RPDDataAnalyzer::m_chSumAdc {}

private

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

Definition at line 125 of file RPDDataAnalyzer.h.

{}; 

m_chSumAdcCalib

std::array<float, s_nChannels> ZDC::RPDDataAnalyzer::m_chSumAdcCalib {}

private

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

Definition at line 126 of file RPDDataAnalyzer.h.

{}; 

m_endSignalSample

unsigned int ZDC::RPDDataAnalyzer::m_endSignalSample

private

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

Definition at line 110 of file RPDDataAnalyzer.h.

m_goodPulseSampleStart

unsigned int ZDC::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 113 of file RPDDataAnalyzer.h.

m_goodPulseSampleStop

unsigned int ZDC::RPDDataAnalyzer::m_goodPulseSampleStop

private

Pulses before this sample are considered pre-pulses.

Definition at line 114 of file RPDDataAnalyzer.h.

m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDC::RPDDataAnalyzer::m_msgFunc_p

private

Definition at line 102 of file RPDDataAnalyzer.h.

m_nBaselineSamples

unsigned int ZDC::RPDDataAnalyzer::m_nBaselineSamples

private

Definition at line 109 of file RPDDataAnalyzer.h.

m_nChannelsLoaded

unsigned int ZDC::RPDDataAnalyzer::m_nChannelsLoaded = 0

private

Definition at line 107 of file RPDDataAnalyzer.h.

m_nNegativesAllowed

unsigned int ZDC::RPDDataAnalyzer::m_nNegativesAllowed

private

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

Definition at line 118 of file RPDDataAnalyzer.h.

m_nominalBaseline

float ZDC::RPDDataAnalyzer::m_nominalBaseline

private

Pulses after this sample are considered post-pulses.

Definition at line 115 of file RPDDataAnalyzer.h.

m_nSamples

unsigned int ZDC::RPDDataAnalyzer::m_nSamples

private

Definition at line 108 of file RPDDataAnalyzer.h.

m_outputCalibFactors

std::array<float, s_nChannels> ZDC::RPDDataAnalyzer::m_outputCalibFactors {}

private

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

Definition at line 120 of file RPDDataAnalyzer.h.

{}; 

m_pileupBaselineStdDevThresh

float ZDC::RPDDataAnalyzer::m_pileupBaselineStdDevThresh

private

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

Definition at line 117 of file RPDDataAnalyzer.h.

m_pileupBaselineSumThresh

float ZDC::RPDDataAnalyzer::m_pileupBaselineSumThresh

private

The global nominal baseline; used when pileup is detected.

Definition at line 116 of file RPDDataAnalyzer.h.

m_postPulseFracThresh

float ZDC::RPDDataAnalyzer::m_postPulseFracThresh

private

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

Definition at line 112 of file RPDDataAnalyzer.h.

m_pulse2ndDerivThresh

float ZDC::RPDDataAnalyzer::m_pulse2ndDerivThresh

private

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

Definition at line 111 of file RPDDataAnalyzer.h.

m_sideStatus

std::bitset<N_STATUS_BITS> ZDC::RPDDataAnalyzer::m_sideStatus

private

status bits per channel

Definition at line 141 of file RPDDataAnalyzer.h.

m_tag

std::string ZDC::RPDDataAnalyzer::m_tag

private

Definition at line 103 of file RPDDataAnalyzer.h.

s_minPileupFitPoints

unsigned int constexpr ZDC::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 149 of file RPDDataAnalyzer.h.

s_nChannels

unsigned int constexpr ZDC::RPDDataAnalyzer::s_nChannels = RPDUtils::nChannels

staticconstexprprivate

Definition at line 105 of file RPDDataAnalyzer.h.

---

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

• RPDDataAnalyzer.h
• RPDDataAnalyzer.cxx