#include <ZDCPulseAnalyzer.h>

Collaboration diagram for ZDCPulseAnalyzer:

Public Types
enum	{ PulseBit = 0, LowGainBit = 1, FailBit = 2, HGOverflowBit = 3, HGUnderflowBit = 4, PSHGOverUnderflowBit = 5, LGOverflowBit = 6, LGUnderflowBit = 7, PrePulseBit = 8, PostPulseBit = 9, FitFailedBit = 10, BadChisqBit = 11, BadT0Bit = 12, ExcludeEarlyLGBit = 13, ExcludeLateLGBit = 14, preExpTailBit = 15, FitMinAmpBit = 16, RepassPulseBit = 17, ArmSumIncludeBit = 18, N_STATUS_BITS }

enum	LowGainMode { LGModeNormal = 0, LGModeForceLG, LGModeRefitLG }

enum	TimingCorrMode { NoTimingCorr = 0, TimingCorrLin, TimingCorrLog }

Public Member Functions
	ZDCPulseAnalyzer (ZDCMsg::MessageFunctionPtr msgFunc_p, const std::string &tag, int Nsample, float deltaTSample, size_t preSampleIdx, int pedestal, float gainHG, const std::string &fitFunction, int peak2ndDerivMinSample, float peak2DerivMinThreshHG, float peak2DerivMinThreshLG)

	~ZDCPulseAnalyzer ()

void	SetFitOPtions (const std::string &fitOptions)

void	enableDelayed (float deltaT, float pedestalShift, bool fixedBaseline=false)

void	enableRepass (float peak2ndDerivMinRepassHG, float peak2ndDerivMinRepassLG)

void	enableTimeSigCut (bool AND, float sigCut, const std::string &TF1String, const std::vector< double > &parsHG, const std::vector< double > &parsLG)

void	enablePreExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)

void	enablePostExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)

void	SetPeak2ndDerivMinTolerance (size_t tolerance)

void	setLGMode (unsigned int mode)

unsigned int	getLGMode () const

void	set2ndDerivStep (size_t step)

void	SetCutValues (float chisqDivAmpCutHG, float chisqDivAmpCutLG, float deltaT0MinHG, float deltaT0MaxHG, float deltaT0MinLG, float deltaT0MaxLG)

void	SetNoiseSigmas (float noiseSigHG, float noiseSigLG)

void	SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)

void	SetFitMinMaxAmp (float minAmpHG, float minAmpLG, float maxAmpHG, float maxAmpLG)

void	SetTauT0Values (bool fixTau1, bool fixTau2, float tau1, float tau2, float t0HG, float t0LG)

void	SetADCOverUnderflowValues (int HGOverflowADC, int HGUnderflowADC, int LGOverflowADC)

void	SetTimingCorrParams (TimingCorrMode mode, float refADC, float refScale, const std::vector< float > &HGT0CorrParams, const std::vector< float > &LGT0CorrParams)

void	SetFitTimeMax (float tmax)

void	SetNonlinCorrParams (float refADC, float refScale, const std::vector< float > &paramsHG, const std::vector< float > &paramsLG)

void	enableFADCCorrections (bool correctPerSample, std::unique_ptr< const TH1 > &correHistHG, std::unique_ptr< const TH1 > &correHistLG)

void	disableFADCCorrections ()

bool	LoadAndAnalyzeData (const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG)

bool	LoadAndAnalyzeData (const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG, const std::vector< float > &ADCSamplesHGDelayed, const std::vector< float > &ADCSamplesLGDelayed)

bool	ReanalyzeData ()

bool	HaveData () const

bool	HavePulse () const

bool	UseLowGain () const

bool	Failed () const

bool	HGOverflow () const

bool	HGUnderflow () const

bool	PSHGOverUnderflow () const

bool	LGOverflow () const

bool	LGUnderflow () const

bool	PrePulse () const

bool	PostPulse () const

bool	FitFailed () const

bool	BadChisq () const

bool	BadT0 () const

bool	ExcludeEarlyLG () const

bool	ExcludeLateLG () const

bool	preExpTail () const

bool	fitMinimumAmplitude () const

bool	repassPulse () const

bool	ArmSumInclude () const

float	GetFitAmplitude () const

float	GetFitT0 () const

float	GetT0Sub () const

float	GetT0Corr () const

float	getTimeSig () const

float	GetChisq () const

float	GetFitTau1 () const

float	GetFitTau2 () const

float	GetFitPreT0 () const

float	GetFitPreAmp () const

float	GetFitPostT0 () const

float	GetFitPostAmp () const

float	GetFitExpAmp () const

float	GetAmpNoNonLin () const

float	GetAmplitude () const

float	GetAmpError () const

float	GetPreExpAmp () const

float	getRefitLGAmp () const

float	getRefitLGFitAmp () const

float	getRefitLGAmpCorr () const

float	getRefitLGChisq () const

float	getRefitLGTime () const

float	getRefitLGTimeSub () const

float	getPresample () const

float	getMaxADCHG () const

float	getMaxADCLG () const

float	getMinADCHG () const

float	getMinADCLG () const

float	getMaxADCSub () const

float	getMinADCSub () const

int	getMaxADCSampleHG () const

int	getMinADCSampleHG () const

int	getMaxADCSampleLG () const

int	getMinADCSampleLG () const

float	getADCPeakHG () const

float	getADCPeakLG () const

float	GetMaxDelta () const

float	GetMinDelta () const

float	GetFitTMax () const

float	GetFitTMin () const

float	GetdelayBS () const

float	GetMinDeriv2nd () const

float	GetMinDeriv2ndIndex () const

unsigned int	GetStatusMask () const

float	GetPreSampleAmp () const

float	GetBkgdMaxFraction () const

float	GetDelayedBaselineShiftFit () const

float	GetDelayedBaselineCorr () const

const TH1 *	GetHistogramPtr (bool refitLG=false) const

std::shared_ptr< TGraphErrors >	GetCombinedGraph (bool forceLG=false) const

std::shared_ptr< TGraphErrors >	GetGraph (bool forceLG=false) const

std::vector< float >	GetFitPulls (bool forceLG=false) const

void	dump () const

void	dumpSetting () const

void	dumpTF1 (const TF1 *) const

const std::vector< float > &	GetSamplesSub () const

const std::vector< float > &	GetSamplesDeriv2nd () const

Static Public Member Functions
static void	SetQuietFits (bool quiet)

static void	SetSaveFitFunc (bool save)

static bool	QuietFits ()

Private Types
typedef std::vector< float >::const_iterator	SampleCIter

Private Member Functions
void	Reset (bool reanalyze=false)

void	SetDefaults ()

void	SetupFitFunctions ()

bool	DoAnalysis (bool repass)

bool	ScanAndSubtractSamples ()

bool	AnalyzeData (size_t nSamples, size_t preSample, const std::vector< float > &samples, const std::vector< bool > &useSamples, float peak2ndDerivMinThresh, float noiseSig, const std::vector< float > &toCorrParams, float maxChisqDivAmp, float minT0Corr, float maxT0Corr)

double	getAmplitudeCorrection (bool highGain)

void	prepareLGRefit (const std::vector< float > &samplesLG, const std::vector< float > &samplesSig, const std::vector< bool > &useSamples)

void	FillHistogram (bool refitLG) const

void	DoFit (bool refitLG=false)

void	DoFitCombined (bool refitLG=false)

void	UpdateFitterTimeLimits (TFitter fitter, ZDCFitWrapper wrapper, bool prePulse)

Static Private Member Functions
static std::vector< float >	Calculate2ndDerivative (const std::vector< float > &inputData, unsigned int step)

static std::vector< float >	CalculateDerivative (const std::vector< float > &inputData, unsigned int step)

static float	obtainDelayedBaselineCorr (const std::vector< float > &samples)

static std::unique_ptr< TFitter >	MakeCombinedFitter (TF1 *func)

static void	CombinedPulsesFCN (int &numParam, double , double &f, double par, int flag)

Private Attributes
ZDCMsg::MessageFunctionPtr	m_msgFunc_p {}

std::string	m_tag

unsigned int	m_Nsample {}

unsigned int	m_preSampleIdx {}

float	m_deltaTSample {}

int	m_pedestal {}

float	m_gainHG {}

unsigned int	m_LGMode {LGModeNormal}

float	m_tmin {}

float	m_tmax {}

std::string	m_fitFunction

size_t	m_2ndDerivStep {1}

size_t	m_peak2ndDerivMinSample {}

size_t	m_peak2ndDerivMinTolerance {1}

float	m_peak2ndDerivMinThreshLG {}

float	m_peak2ndDerivMinThreshHG {}

bool	m_useDelayed {false}

bool	m_enableRepass {false}

float	m_peak2ndDerivMinRepassLG {}

float	m_peak2ndDerivMinRepassHG {}

float	m_gainFactorHG {}

float	m_gainFactorLG {}

float	m_noiseSigHG {}

float	m_noiseSigLG {}

std::string	m_fitOptions

int	m_HGOverflowADC {}

int	m_HGUnderflowADC {}

int	m_LGOverflowADC {}

float	m_nominalT0HG {}

float	m_nominalT0LG {}

float	m_nominalTau1 {}

float	m_nominalTau2 {}

bool	m_fixTau1 {}

bool	m_fixTau2 {}

float	m_defaultFitTMax {}

float	m_defaultFitTMin {}

float	m_chisqDivAmpCutLG {}

float	m_chisqDivAmpCutHG {}

float	m_T0CutLowLG {}

float	m_T0CutHighLG {}

float	m_T0CutLowHG {}

float	m_T0CutHighHG {}

std::unique_ptr< const TF1 >	m_timeResFuncHG_p {}

std::unique_ptr< const TF1 >	m_timeResFuncLG_p {}

float	m_t0CutSig {}

unsigned int	m_timeCutMode {0}

float	m_defaultT0Max {}

float	m_defaultT0Min {}

float	m_fitAmpMinHG {}

float	m_fitAmpMinLG {}

float	m_fitAmpMaxHG {}

float	m_fitAmpMaxLG {}

bool	m_enablePreExcl {false}

unsigned int	m_maxSamplesPreExcl {0}

unsigned int	m_preExclHGADCThresh {0}

unsigned int	m_preExclLGADCThresh {0}

bool	m_enablePostExcl {false}

unsigned int	m_postExclHGADCThresh {0}

unsigned int	m_postExclLGADCThresh {0}

unsigned int	m_maxSamplesPostExcl {0}

unsigned int	m_timingCorrMode {NoTimingCorr}

float	m_timingCorrRefADC {500}

float	m_timingCorrScale {100}

std::vector< float >	m_LGT0CorrParams

std::vector< float >	m_HGT0CorrParams

bool	m_haveNonlinCorr {false}

float	m_nonLinCorrRefADC {500}

float	m_nonLinCorrRefScale {100}

std::vector< float >	m_nonLinCorrParamsHG

std::vector< float >	m_nonLinCorrParamsLG

bool	m_haveFADCCorrections {false}

bool	m_FADCCorrPerSample {false}

std::unique_ptr< const TH1 >	m_FADCCorrHG {}

std::unique_ptr< const TH1 >	m_FADCCorrLG {}

std::unique_ptr< TH1 >	m_fitHist

std::unique_ptr< TH1 >	m_fitHistLGRefit

bool	m_initializedFits {false}

std::unique_ptr< ZDCFitWrapper >	m_defaultFitWrapper

std::unique_ptr< ZDCPrePulseFitWrapper >	m_prePulseFitWrapper

std::unique_ptr< ZDCPreExpFitWrapper >	m_preExpFitWrapper

bool	m_adjTimeRangeEvent {}

unsigned int	m_minSampleEvt {}

unsigned int	m_maxSampleEvt {}

bool	m_useFixedBaseline {}

float	m_delayedDeltaT {}

float	m_delayedPedestalDiff {}

std::unique_ptr< TH1 >	m_delayedHist

std::unique_ptr< TH1 >	m_delayedHistLGRefit

std::unique_ptr< TFitter >	m_prePulseCombinedFitter

std::unique_ptr< TFitter >	m_defaultCombinedFitter

bool	m_haveData {}

bool	m_havePulse {}

bool	m_useLowGain {}

bool	m_fail {}

bool	m_HGOverflow {}

bool	m_HGUnderflow {}

bool	m_PSHGOverUnderflow {}

bool	m_LGOverflow {}

bool	m_LGUnderflow {}

bool	m_prePulse {}

bool	m_postPulse {}

bool	m_fitFailed {}

bool	m_badChisq {}

bool	m_badT0 {}

bool	m_ExcludeEarly {}

bool	m_ExcludeLate {}

bool	m_preExpTail {}

bool	m_fixPrePulse {}

bool	m_fitMinAmp {}

bool	m_repassPulse {}

bool	m_backToHG_pre {}

float	m_baselineCorr {}

int	m_usedPresampIdx {}

float	m_preSample {}

float	m_minADCHG {}

float	m_maxADCHG {}

int	m_minADCSampleHG

int	m_maxADCSampleHG

float	m_maxADCLG {}

float	m_minADCLG {}

int	m_minADCSampleLG

int	m_maxADCSampleLG

float	m_ADCPeakHG {}

float	m_ADCPeakLG {}

float	m_maxDelta {}

float	m_minDelta {}

float	m_initialExpAmp {}

float	m_minDeriv2nd {}

int	m_minDeriv2ndIndex {}

float	m_fitTMax {}

float	m_fitTMin {}

float	m_fitPostT0lo {}

float	m_minDeriv2ndSig

float	m_preExpSig

float	m_prePulseSig

float	m_initialPrePulseT0 {}

float	m_initialPrePulseAmp {}

float	m_initialPostPulseT0 {}

float	m_fitAmplitude {}

float	m_fitAmpError {}

float	m_fitTime {}

float	m_fitTimeSub {}

float	m_fitTimeCorr {}

float	m_timeSig {}

float	m_fitTCorr2nd {}

float	m_fitTau1 {}

float	m_fitTau2 {}

float	m_fitChisq {}

float	m_fitNDoF {}

float	m_fitPreT0 {}

float	m_fitPreAmp {}

float	m_fitPostT0 {}

float	m_fitPostAmp {}

float	m_fitExpAmp {}

float	m_amplitude {}

float	m_ampNoNonLin {}

float	m_ampError {}

float	m_preSampleAmp {}

float	m_preAmplitude {}

float	m_postAmplitude {}

float	m_expAmplitude {}

float	m_bkgdMaxFraction {}

float	m_delayedBaselineShift {}

bool	m_evtLGRefit {false}

float	m_refitLGAmpl {0}

float	m_refitLGFitAmpl {0}

float	m_refitLGAmplCorr {0}

float	m_refitLGAmpError {0}

float	m_refitLGChisq {0}

float	m_refitLGTime {0}

float	m_refitLGTimeSub {0}

int	m_lastHGOverFlowSample {-1}

int	m_firstHGOverFlowSample {-1}

unsigned int	m_NSamplesAna {0}

std::vector< float >	m_ADCSamplesHG

std::vector< float >	m_ADCSamplesLG

std::vector< float >	m_ADCSamplesHGSub

std::vector< float >	m_ADCSamplesLGSub

std::vector< bool >	m_useSampleLG

std::vector< bool >	m_useSampleHG

std::vector< float >	m_ADCSSampSigHG

std::vector< float >	m_ADCSSampSigLG

std::vector< float >	m_samplesSub

std::vector< float >	m_samplesSig

std::vector< float >	m_samplesLGRefit

std::vector< float >	m_samplesSigLGRefit

std::vector< float >	m_samplesDeriv2nd

std::vector< float >	m_fitPulls

Static Private Attributes
static bool	s_quietFits = true

static bool	s_saveFitFunc = false

static TH1 *	s_undelayedFitHist = nullptr

static TH1 *	s_delayedFitHist = nullptr

static TF1 *	s_combinedFitFunc = nullptr

static float	s_combinedFitTMax = 1000

static float	s_combinedFitTMin = -0.5

static std::vector< float >	s_pullValues

Detailed Description

Definition at line 23 of file ZDCPulseAnalyzer.h.

Member Typedef Documentation

◆ SampleCIter

typedef std::vector<float>::const_iterator ZDCPulseAnalyzer::SampleCIter

private

Definition at line 62 of file ZDCPulseAnalyzer.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
PulseBit
LowGainBit
FailBit
HGOverflowBit
HGUnderflowBit
PSHGOverUnderflowBit
LGOverflowBit
LGUnderflowBit
PrePulseBit
PostPulseBit
FitFailedBit
BadChisqBit
BadT0Bit
ExcludeEarlyLGBit
ExcludeLateLGBit
preExpTailBit
FitMinAmpBit
RepassPulseBit
ArmSumIncludeBit
N_STATUS_BITS

Definition at line 26 of file ZDCPulseAnalyzer.h.

        {PulseBit              = 0,  //  &1
         LowGainBit            = 1,  //  &2
         FailBit               = 2,  //  &4
         HGOverflowBit         = 3,  //  &8
         // -------------------------
         HGUnderflowBit        = 4,  //  &16
         PSHGOverUnderflowBit  = 5,  //  &32
         LGOverflowBit         = 6,  //  &64
         LGUnderflowBit        = 7,  //  &128
         // -------------------------
         PrePulseBit           = 8,  //  &256
         PostPulseBit          = 9,  //  &512
         FitFailedBit          = 10, //  &1024
         BadChisqBit           = 11, //  &2048
         // -------------------------
         BadT0Bit              = 12, //  &4096
         ExcludeEarlyLGBit     = 13, //  &8192
         ExcludeLateLGBit      = 14, //  &16384
         preExpTailBit         = 15, //  &32768
         //
         FitMinAmpBit          = 16, // 0x10000
         RepassPulseBit        = 17, // 0x20000
         ArmSumIncludeBit      = 18,
  
         N_STATUS_BITS
        };

◆ LowGainMode

enum ZDCPulseAnalyzer::LowGainMode

Enumerator
LGModeNormal
LGModeForceLG
LGModeRefitLG

Definition at line 53 of file ZDCPulseAnalyzer.h.

                    {
     LGModeNormal = 0,
     LGModeForceLG,
     LGModeRefitLG
   };

◆ TimingCorrMode

enum ZDCPulseAnalyzer::TimingCorrMode

Enumerator
NoTimingCorr
TimingCorrLin
TimingCorrLog

Definition at line 59 of file ZDCPulseAnalyzer.h.

59 {NoTimingCorr = 0, TimingCorrLin, TimingCorrLog};

Constructor & Destructor Documentation

◆ ZDCPulseAnalyzer()

ZDCPulseAnalyzer::ZDCPulseAnalyzer	(	ZDCMsg::MessageFunctionPtr	msgFunc_p,
		const std::string &	tag,
		int	Nsample,
		float	deltaTSample,
		size_t	preSampleIdx,
		int	pedestal,
		float	gainHG,
		const std::string &	fitFunction,
		int	peak2ndDerivMinSample,
		float	peak2DerivMinThreshHG,
		float	peak2DerivMinThreshLG
	)

Definition at line 87 of file ZDCPulseAnalyzer.cxx.

                                                                                                  :
   m_msgFunc_p(std::move(msgFunc_p)),
   m_tag(tag), m_Nsample(Nsample),
   m_preSampleIdx(preSampleIdx),
   m_deltaTSample(deltaTSample),
   m_pedestal(pedestal), m_gainHG(gainHG), m_fitFunction(fitFunction),
   m_peak2ndDerivMinSample(peak2ndDerivMinSample),
     m_peak2ndDerivMinThreshLG(peak2ndDerivMinThreshLG),
   m_peak2ndDerivMinThreshHG(peak2ndDerivMinThreshHG),
   m_ADCSamplesHGSub(Nsample, 0), m_ADCSamplesLGSub(Nsample, 0),
   m_ADCSSampSigHG(Nsample, 0), m_ADCSSampSigLG(Nsample, 0), 
   m_samplesSub(Nsample, 0)
 {
   // Create the histogram used for fitting
   //
   m_tmin = -deltaTSample / 2;
   m_tmax = m_tmin + ((float) Nsample) * deltaTSample;
  
   std::string histName = "ZDCFitHist" + tag;
   std::string histNameLGRefit = "ZDCFitHist" + tag + "_LGRefit";
  
   m_fitHist = std::make_unique<TH1F>(histName.c_str(), "", m_Nsample, m_tmin, m_tmax);
   m_fitHistLGRefit = std::make_unique<TH1F>(histNameLGRefit.c_str(), "", m_Nsample, m_tmin, m_tmax);
  
   m_fitHist->SetDirectory(0);
   m_fitHistLGRefit->SetDirectory(0);
  
   SetDefaults();
   Reset();
 }

◆ ~ZDCPulseAnalyzer()

ZDCPulseAnalyzer::~ZDCPulseAnalyzer ( )

inline

Definition at line 442 of file ZDCPulseAnalyzer.h.

442 {}

Member Function Documentation

◆ AnalyzeData()

bool ZDCPulseAnalyzer::AnalyzeData	(	size_t	nSamples,
		size_t	preSample,
		const std::vector< float > &	samples,
		const std::vector< bool > &	useSamples,
		float	peak2ndDerivMinThresh,
		float	noiseSig,
		const std::vector< float > &	toCorrParams,
		float	maxChisqDivAmp,
		float	minT0Corr,
		float	maxT0Corr
	)

private

Definition at line 1036 of file ZDCPulseAnalyzer.cxx.

 {
  
   // We keep track of which sample we used to do the subtraction sepaate from m_minSampleEvt
   //  because the corresponding time is the reference time we provide to the fit function when
   //  we have pre-pulses and in case we change the m_minSampleEvt after doing the subtraction
   //
   //    e.g. our refit when the chisquare cuts fails
   //
  
   // Find the first used sample in the event
   //
   bool haveFirst = false;
   unsigned int lastUsed = 0;
   
   for (unsigned int sample = preSampleIdx; sample < nSamples; sample++) {
     if (useSample[sample]) {
       //
       // We're going to use this sample in the analysis, update bookeeping
       //
       if (!haveFirst) {
     if (sample > m_minSampleEvt) m_minSampleEvt = sample;
     haveFirst = true;
       }
       else {
     lastUsed = sample;
       }
     }
   }
  
   if (lastUsed < m_maxSampleEvt) m_maxSampleEvt = lastUsed;
  
   // Check to see whether we've changed the range of samples used in the analysis
   //
   // Should be obseleted with reworking of the fitting using Root::Fit package
   //
   if (m_minSampleEvt > preSampleIdx) {
      m_ExcludeEarly = true;
      m_adjTimeRangeEvent = true;
   }
  
   if (m_maxSampleEvt < nSamples - 1) {
     m_adjTimeRangeEvent = true;
     m_ExcludeLate = true;
   }
  
   // Prepare for subtraction
   //
   m_usedPresampIdx = m_minSampleEvt;
   m_preSample = samples[m_usedPresampIdx];
  
   std::ostringstream pedMessage;
   pedMessage << "Pedestal index = " << m_usedPresampIdx << ", value = " << m_preSample;
   (*m_msgFunc_p)(ZDCMsg::Verbose, pedMessage.str().c_str());
  
   m_samplesSub = samples;
   m_samplesSig.assign(m_NSamplesAna, noiseSig);
       
   
   //
   // When we are combinig delayed and undelayed samples we have to deal with the fact that
   //   the two readouts can have different noise and thus different baselines. Which is a huge
   //   headache.
   //
   if (m_useDelayed) {
     if (m_useFixedBaseline) {
       m_baselineCorr = m_delayedPedestalDiff;
     }
     else {
       //
       //  Use much-improved method to match delayed and undelayed baselines
       //
       m_baselineCorr = obtainDelayedBaselineCorr(m_samplesSub);
       std::ostringstream baselineMsg;
       baselineMsg << "Delayed samples baseline correction = " << m_baselineCorr << std::endl;
       (*m_msgFunc_p)(ZDCMsg::Debug, baselineMsg.str().c_str());
     }
  
     // Now apply the baseline correction to align ADC values for delayed and undelayed samples
     //
     for (size_t isample = 0; isample < nSamples; isample++) {
       if (isample % 2) m_samplesSub[isample] -= m_baselineCorr;
     }
  
     // If we use one of the delayed samples for presample, we have to adjust the presample value as well
     //
     if (m_usedPresampIdx % 2) m_preSample -= m_baselineCorr;
   }
  
   // Do the presample subtraction
   //
   std::for_each(m_samplesSub.begin(), m_samplesSub.end(), [ = ] (float & adcUnsub) {return adcUnsub -= m_preSample;} );
  
   // Calculate the second derivatives using step size m_2ndDerivStep
   //
   m_samplesDeriv2nd = Calculate2ndDerivative(m_samplesSub, m_2ndDerivStep);
  
   // Find the sample which has the lowest 2nd derivative. We loop over the range defined by the
   //  tolerance on the position of the minimum second derivative. Note: the +1 in the upper iterator is because
   //  that's where the loop terminates, not the last element.
   //
   SampleCIter minDeriv2ndIter;
  
   int upperDelta = std::min(m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 1, nSamples);
  
   minDeriv2ndIter = std::min_element(m_samplesDeriv2nd.begin() + m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance, m_samplesDeriv2nd.begin() + upperDelta);
  
   m_minDeriv2nd = *minDeriv2ndIter;
   m_minDeriv2ndSig = -m_minDeriv2nd/(std::sqrt(6.0)*noiseSig);
  
   m_minDeriv2ndIndex = std::distance(m_samplesDeriv2nd.cbegin(), minDeriv2ndIter);
  
   // BAC 02-04-23 This check turned out to be problematic. Todo: figure out how to replace
   //
   // // Also check the ADC value for the "peak" sample to make sure it is significant (at least 3 sigma)
   // // The factor of sqrt(2) on the noise is because we have done a pre-sample subtraction
   // //
   if (m_minDeriv2nd <= peak2ndDerivMinThresh) {
     m_havePulse = true;
     (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " has pulse ");
   }
   else {
     (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " does not have pulse ");
     m_havePulse = false;
   }
  
   // save the low and high gain ADC values at the peak -- if we have a pulse, at m_minDeriv2ndIndex
   //   otherwise at m_peak2ndDerivMinSample
   //
   if (m_havePulse) {
     m_ADCPeakHG = m_ADCSamplesHG.at(m_minDeriv2ndIndex);
     m_ADCPeakLG = m_ADCSamplesLG.at(m_minDeriv2ndIndex);
   }
   else {
     m_ADCPeakHG = m_ADCSamplesHG.at(m_peak2ndDerivMinSample);
     m_ADCPeakLG = m_ADCSamplesLG.at(m_peak2ndDerivMinSample);
   }
   
   // Now decide whether we have a preceeding pulse or not. There are two possible kinds of preceeding pulses:
   //   1) exponential tail from a preceeding pulse
   //   2) peaked pulse before the main pulse
   //
   //   we can, of course, have both
   //
  
   // To check for exponential tail, test the slope determined by the minimum ADC value (and pre-sample)
   // **beware** this can cause trouble in 2015 data where the pulses had overshoot due to the transformers
   //
  
   // Implement a much simpler test for presence of an exponential tail from an OOT pulse
   //   namely if the slope evaluated at the presample is significantly negative, then 
   //   we have a preceeding pulse.
   //
   // Note that we don't have to subtract the FADC value corresponding to the presample because 
   //   that subtraction has already been done.
   //
   if (m_havePulse) {
     // If we've alreday excluded early samples, we have almost by construction have negative exponential tail
     //
     if (m_ExcludeEarly) m_preExpTail = true;
  
     //
     //  The subtracted ADC value at m_usedPresampIdx is, by construction, zero
     //    The next sample has had the pre-sample subtracted, so it represents the initial derivative
     //
     float derivPresampleSig = m_samplesSub[m_usedPresampIdx+1]/(std::sqrt(2.0)*noiseSig);
     if (derivPresampleSig < -5) {
       m_preExpTail = true;
       m_preExpSig = derivPresampleSig;
     }
     
     for (unsigned int isample = m_usedPresampIdx; isample < m_samplesSub.size(); isample++) {
       if (!useSample[isample]) continue;
  
       float sampleSig = -m_samplesSub[isample]/(std::sqrt(2.0)*noiseSig);
       float sigRatio = sampleSig/m_minDeriv2ndSig;
           
       if ((sampleSig > 5 && sigRatio > 0.02) || sigRatio > 0.5) {
     m_preExpTail = true;
     if (sampleSig > m_preExpSig) m_preExpSig = sampleSig;
       }
     }
  
     // Now we search for maxima before the main pulse
     //
     int loopLimit = (m_havePulse ? m_minDeriv2ndIndex - 2 : m_peak2ndDerivMinSample - 2);
     int loopStart = m_minSampleEvt == 0 ? 1 : m_minSampleEvt;
     
     float maxPrepulseSig = 0;
     unsigned int maxPrepulseSample = 0;
     
     for (int isample = loopStart; isample <= loopLimit; isample++) {
       if (!useSample[isample]) continue;
       
       //
       // If any of the second derivatives prior to the peak are significantly negative, we have a an extra pulse
       //   prior to the main one -- as opposed to just an expnential tail
       //
       float prePulseSig = -m_samplesDeriv2nd[isample]/(std::sqrt(6.0)*noiseSig);
  
       // std::cout << m_tag << ", for sample " << isample << ", 2nd derivative = " << m_samplesDeriv2nd[isample]
       //        << " 0.05 * m_minDeriv2nd) = " << 0.05 * m_minDeriv2nd
       //        << ", prePulseSig = " << prePulseSig << std::endl;
       
       if ((prePulseSig > 6 && m_samplesDeriv2nd[isample] < 0.05 * m_minDeriv2nd) ||
       m_samplesDeriv2nd[isample]  < 0.5*m_minDeriv2nd)
       {
      m_prePulse = true;
     if (prePulseSig > maxPrepulseSig) {
       maxPrepulseSig = prePulseSig;
       maxPrepulseSample = isample;
     }
       }
     }
  
     if (m_prePulse) {
       //      std::cout << m_tag << ": prepulse sigma = " << m_prePulseSig << ", pre exp sigma = " << m_preExpSig << std::endl;
       m_prePulseSig = maxPrepulseSig;
       
       if (m_preExpTail) {
     //
     // We have a prepulse. If we already indicated an negative exponential,
     //   if the prepulse has greater significance, we override the negative exponential
     //
     if (m_prePulseSig >  m_preExpSig) {
       m_preExpTail = false;
     }
     else {
       m_prePulse = false;
     }
       }
  
       m_initialPrePulseAmp = m_samplesSub[maxPrepulseSample];
       m_initialPrePulseT0 = m_deltaTSample * (maxPrepulseSample);
     }
  
     //    if (m_preExpTail) m_prePulse = true;    
  
     // -----------------------------------------------------
     // Post pulse detection
     //
     unsigned int postStartIdx = std::max(static_cast<unsigned int>(m_minDeriv2ndIndex + 2),
                      static_cast<unsigned int>(m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 1));
  
     
     for (int isample = postStartIdx; isample < (int) m_samplesDeriv2nd.size() - 1; isample++) {
       if (!useSample[isample]) continue;
       
       // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       // BAC 12-01-2024
       //
       // The following code is commented out as a temporary measure to deal with apparent reflections
       //   associated with large out-of-time pulses that introduce a "kink" that triggers the derivative
       //   test. A work-around that doesn't introduce specific code for the 2023 Pb+Pb run but allows
       //   adaption for this specific issue is going to take some work. For now we leave the 2nd derivative
       //   test, but will also need to introduce some configurability of the cut -- which we need anyway
       //
       // Calculate the forward derivative. the pulse should never increase on the tail. If it
       //   does, we almost certainly have a post-pulse
       //
       // float deriv = m_samplesSub[isample + 1] - m_samplesSub[isample];
       // if (deriv/(std::sqrt(2)*noiseSig) > 6) {
       //   m_postPulse = true;
       //   m_maxSampleEvt = isample;
       //   m_adjTimeRangeEvent = true;
       //   break;
       // }
       // else {
       //----------------------------------------------------------------------------------------------
       //
       // Now we check the second derivative which might also indicate a post pulse
       //   even if the derivative is not sufficiently large
       //
       // add small 1e-3 in division to avoid floating overflow
       //
  
       float deriv = m_samplesSub[isample + 1] - m_samplesSub[isample];
       float derivSig = deriv/(std::sqrt(2)*noiseSig);
       float deriv2ndSig = -m_samplesDeriv2nd[isample] / (std::sqrt(6)*noiseSig);
  
       float deriv2ndTest = m_samplesDeriv2nd[isample] / (-m_minDeriv2nd + 1.0e-3);
  
       if (derivSig > 5) {
     //
     // Check the 2nd derivative -- we should be at a minimum(?)
     //  
     if (std::abs(deriv2ndTest) > 0.15) {
       m_postPulse = true;
       m_maxSampleEvt = std::min<int>(isample - (m_2ndDerivStep - 1), m_maxSampleEvt);
  
       m_adjTimeRangeEvent = true;
       break;
     }
       }
           
       // The place to apply the cut on samples depends on whether we have found a "minimum" or a "maximum"
       //   The -m_2ndDerivStep for the minimum accounts for the shift between 2nd derivative and the samples
       //   if we find a maximum we cut one sample lower
       //
       if (deriv2ndSig > 5 && deriv2ndTest < -0.1) {
     m_postPulse = true;
     m_maxSampleEvt = std::min<int>(isample - m_2ndDerivStep, m_maxSampleEvt);
  
     m_adjTimeRangeEvent = true;
     break;
       }
     }
   }
  
   if (m_postPulse) {
     std::ostringstream ostrm;
     ostrm << "Post pulse found, m_maxSampleEvt = " << m_maxSampleEvt;
     (*m_msgFunc_p)(ZDCMsg::Debug, ostrm.str());
   }
  
   
   // -----------------------------------------------------
  
   //  Stop now if we have no pulse or we've detected a failure
   //
   if (m_fail || !m_havePulse) return false;
  
   if (!m_useDelayed) DoFit();
   else DoFitCombined();
   
   if (FitFailed()) {
     m_fail = true;
   }
   else {
     std::ostringstream ostrm;
     ostrm << "Pulse fit successful with chisquare = " << m_fitChisq;
     (*m_msgFunc_p)(ZDCMsg::Debug, ostrm.str());
  
     m_fitTimeCorr = m_fitTimeSub;
  
     if (m_timingCorrMode != NoTimingCorr) {
       //
       // We correct relative to the m_timingCorrRefADC using m_timingCorrScale to scale
       //
       double t0CorrFact = (m_fitAmplitude - m_timingCorrRefADC) / m_timingCorrScale;
       if (m_timingCorrMode == TimingCorrLog) t0CorrFact = std::log(t0CorrFact);
  
       // Calculate the correction using a polynomial of power determined by the size of the vector.
       //   For historical reasons we include here a constant term, though it is degenerate with
       //   the nominal t0 and/or timing calibrations.
       //
       float correction = 0;
  
       for (unsigned int ipow = 0; ipow < t0CorrParams.size(); ipow++) {
     correction += t0CorrParams[ipow]*std::pow(t0CorrFact, double(ipow));
       }
  
       // The correction represents the offset of the timing value from zero so we subtract the result
       //
       m_fitTimeCorr -= correction; 
     }
  
     bool failFixedCut = m_fitTimeCorr < minT0Corr || m_fitTimeCorr > maxT0Corr;
  
     // Calculate the timing significance. Note this implementation breaks the model for
     //  how DoAnalysis is currently used by explicitly testing m_useLowGain, but that model
     //  needs adjustment anyway ... (one step at a time)
     //
     // Note that to avoid coupling non-linear corrections to the amplitude and the 
     //   timing significance we evaluate the time resolution using the fit amplitude
     //
     if (m_timeCutMode != 0) {
       double timeResolution = 0;
       if (m_useLowGain) timeResolution = m_timeResFuncLG_p->Eval(m_fitAmplitude);
       else timeResolution = m_timeResFuncHG_p->Eval(m_fitAmplitude);
  
       m_timeSig = m_fitTimeCorr/timeResolution;
       if (std::abs(m_timeSig) > m_t0CutSig) {
     //
     // We've failed the significance cut. In OR mode (1) we mark the time
     //  as bad if we've lso failed the fixed cut. In AND mode, we mark it
     //  as bad regardless of the fixed cut.
     //
     if (m_timeCutMode == 1) {
       if (failFixedCut) m_badT0 = true;
     }
     else m_badT0 = true;
       }
       else if (m_timeCutMode == 2 && failFixedCut) m_badT0 = failFixedCut;
     }
     else {
       m_timeSig = -1;
       m_badT0 = failFixedCut;
     }
     
     // Now check for valid chisq and valid time
     //
     if (m_fitChisq/m_fitNDoF > 2 && m_fitChisq / (m_fitAmplitude + 1.0e-6) > maxChisqDivAmp) m_badChisq = true;
   }
  
   return !m_fitFailed;
 }

◆ ArmSumInclude()

bool ZDCPulseAnalyzer::ArmSumInclude ( ) const

inline

Definition at line 575 of file ZDCPulseAnalyzer.h.

575 {return HavePulse() && !(FitFailed() || BadChisq() || BadT0() || fitMinimumAmplitude() || LGOverflow());}

◆ BadChisq()

bool ZDCPulseAnalyzer::BadChisq ( ) const

inline

Definition at line 567 of file ZDCPulseAnalyzer.h.

567 {return m_badChisq;}

◆ BadT0()

bool ZDCPulseAnalyzer::BadT0 ( ) const

inline

Definition at line 569 of file ZDCPulseAnalyzer.h.

569 {return m_badT0;}

◆ Calculate2ndDerivative()

std::vector< float > ZDCPulseAnalyzer::Calculate2ndDerivative	(	const std::vector< float > &	inputData,
		unsigned int	step
	)

staticprivate

Definition at line 2141 of file ZDCPulseAnalyzer.cxx.

 {
   unsigned int nSamples = inputData.size();
  
   // We start with two zero entries for which we can't calculate the double-step derivative
   //   and woud pad with two zero entries at the end. Start by initializing 
   //
   unsigned int vecSize = 2*step + nSamples - step - 1;
   std::vector<float> results(vecSize, 0);
  
   unsigned int fillIndex = step;
   for (unsigned int sample = step; sample < nSamples - step; sample++) {
     int deriv2nd = inputData[sample + step] + inputData[sample - step] - 2*inputData[sample];
     results.at(fillIndex++) = deriv2nd;
   }
  
   return results;
 }

◆ CalculateDerivative()

std::vector< float > ZDCPulseAnalyzer::CalculateDerivative	(	const std::vector< float > &	inputData,
		unsigned int	step
	)

staticprivate

Definition at line 2120 of file ZDCPulseAnalyzer.cxx.

 {
   unsigned int nSamples = inputData.size();
  
   // So we pad at the beginning and end based on step (i.e. with step - 1 zeros). Fill out the fill vector with zeros initially
   //
   unsigned int vecSize = 2*(step - 1) + nSamples - step - 1;
   std::vector<float> results(vecSize, 0);
  
   // Now fill out the values
   //
   unsigned int fillIdx = step - 1;
   
   for (unsigned int sample = 0; sample < nSamples - step; sample++) {
     int deriv = inputData[sample + step] - inputData[sample];
     results.at(fillIdx++) = deriv;
   }
  
   return results;
 }

◆ CombinedPulsesFCN()

void ZDCPulseAnalyzer::CombinedPulsesFCN	(	int &	numParam,
		double *	,
		double &	f,
		double *	par,
		int	flag
	)

staticprivate

Definition at line 33 of file ZDCPulseAnalyzer.cxx.

 {
   //  The first parameter is a correction factor to account for decrease in beam intensity between x
   //    and y scan. It is applied here and not passed to the actual fit function
   //
   int nSamples = s_undelayedFitHist->GetNbinsX();
  
   if (flag == 3) {
     s_pullValues.assign(nSamples * 2, 0);
   }
  
   double chiSquare = 0;
  
   float delayBaselineAdjust = par[0];
  
   // undelayed
   //
   for (int isample = 0; isample < nSamples; isample++) {
     double histValue = s_undelayedFitHist->GetBinContent(isample + 1);
     double histError = std::max(s_undelayedFitHist->GetBinError(isample + 1), 1.0);
     double t = s_undelayedFitHist->GetBinCenter(isample + 1);
  
     if (t > s_combinedFitTMax) break;
     if (t < s_combinedFitTMin) continue;
  
     double funcVal = s_combinedFitFunc->EvalPar(&t, &par[1]);
  
     double pull = (histValue - funcVal) / histError;
  
     if (flag == 3) s_pullValues[2 * isample] = pull;
     chiSquare += pull * pull;
   }
  
   // delayed
   //
   for (int isample = 0; isample < nSamples; isample++) {
     double histValue = s_delayedFitHist->GetBinContent(isample + 1);
     double histError = std::max(s_delayedFitHist->GetBinError(isample + 1), 1.0);
     double t = s_delayedFitHist->GetBinCenter(isample + 1);
  
     if (t > s_combinedFitTMax) break;
     if (t < s_combinedFitTMin) continue;
  
     double funcVal = s_combinedFitFunc->EvalPar(&t, &par[1]) + delayBaselineAdjust;
     double pull = (histValue - funcVal) / histError;
  
     if (flag == 3) s_pullValues[2 * isample + 1] = pull;
     chiSquare += pull * pull;
   }
  
   f = chiSquare;
 }

◆ disableFADCCorrections()

void ZDCPulseAnalyzer::disableFADCCorrections ( )

inline

Definition at line 540 of file ZDCPulseAnalyzer.h.

540 {m_haveFADCCorrections = false;}

◆ DoAnalysis()

bool ZDCPulseAnalyzer::DoAnalysis ( bool repass )

private

Definition at line 930 of file ZDCPulseAnalyzer.cxx.

 {
   float deriv2ndThreshHG = 0;
   float deriv2ndThreshLG = 0;
  
   if (!repass) {
     ScanAndSubtractSamples();
     
     deriv2ndThreshHG = m_peak2ndDerivMinThreshHG;
     deriv2ndThreshLG = m_peak2ndDerivMinThreshLG;
   }
   else {
     deriv2ndThreshHG = m_peak2ndDerivMinRepassHG;
     deriv2ndThreshLG = m_peak2ndDerivMinRepassLG;
   }
  
   m_useLowGain = m_HGUnderflow || m_HGOverflow || (m_LGMode == LGModeForceLG);
   if (m_useLowGain) {
     (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " using low gain data ");
  
     bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesLGSub, m_useSampleLG,
                   deriv2ndThreshLG, m_noiseSigLG, m_LGT0CorrParams, 
                               m_chisqDivAmpCutLG, m_T0CutLowLG, m_T0CutHighLG);
     if (result) {
       //
       // +++BAC
       //
       // I have removed some code that attempted a refit in case of failure of the chi-square cut
       // Instead, we should implement an analysis of the failure with possible re-fit afterwards
       //  with possible change of the pre- or post-pulse condition
       //
       // --BAC
       //
  
       double amplCorrFactor = getAmplitudeCorrection(false);
       
       //
       // Multiply amplitude by gain factor
       //
       m_ampNoNonLin   = m_fitAmplitude * m_gainFactorLG;
       m_amplitude     = m_fitAmplitude * amplCorrFactor * m_gainFactorLG;
       m_ampError      = m_fitAmpError * amplCorrFactor * m_gainFactorLG;
       m_preSampleAmp  = m_preSample    * m_gainFactorLG;
       m_preAmplitude  = m_fitPreAmp    * m_gainFactorLG;
       m_postAmplitude = m_fitPostAmp   * m_gainFactorLG;
       m_expAmplitude  = m_fitExpAmp    * m_gainFactorLG;
  
       // BAC: also scale up the 2nd derivative by the gain factor so low and high gain can be treated on the same footing
       //
       m_minDeriv2nd *= m_gainFactorLG;
     }
  
     return result;
   }
   else {
     (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " using high gain data ");
  
     bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesHGSub, m_useSampleHG,
                   deriv2ndThreshHG, m_noiseSigHG, m_HGT0CorrParams, 
                               m_chisqDivAmpCutHG, m_T0CutLowHG, m_T0CutHighHG);
     if (result) {
       // +++BAC
       //
       // I have removed some code that attempted a refit in case of failure of the chi-square cut
       // Instead, we should implement an analysis of the failure with possible re-fit afterwards
       //  with possible change of the pre- or post-pulse condition
       //
       // --BAC
  
       m_preSampleAmp = m_preSample  * m_gainFactorHG;
       m_amplitude = m_fitAmplitude  * m_gainFactorHG;
       m_ampNoNonLin   = m_amplitude;
       m_ampError = m_fitAmpError    * m_gainFactorHG;
       m_preAmplitude  = m_fitPreAmp * m_gainFactorHG;
       m_postAmplitude = m_fitPostAmp* m_gainFactorHG;
       m_expAmplitude  = m_fitExpAmp * m_gainFactorHG;
  
       m_minDeriv2nd *= m_gainFactorHG;
  
       //  If we have a non-linear correction, apply it here
       //
       //    We apply it as an inverse correction - i.e. we divide by a correction
       //      term tha is a sum of coefficients times the ADC minus a reference
       //      to a power. The lowest power is 1, the highest is deteremined by
       //      the number of provided coefficients 
       //
       double amplCorrFactor = getAmplitudeCorrection(true);
  
       m_amplitude *= amplCorrFactor;
       m_ampError *= amplCorrFactor;
     }
  
     // If LG refit has been requested, do it now
     //
     if (m_LGMode == LGModeRefitLG && m_havePulse) {
       prepareLGRefit(m_ADCSamplesLGSub, m_ADCSSampSigLG, m_useSampleLG);
       DoFit(true);
  
       double amplCorrFactor = getAmplitudeCorrection(false);
       m_refitLGAmplCorr = m_refitLGAmpl*amplCorrFactor;
     }
     
     return result;
   }
 }

◆ DoFit()

void ZDCPulseAnalyzer::DoFit ( bool refitLG = false )

private

Definition at line 1465 of file ZDCPulseAnalyzer.cxx.

 {
   bool fitLG = m_useLowGain || refitLG;
   
   TH1* hist_p = nullptr;
   FillHistogram(refitLG);
     
   // Set the initial values
   //
   float ampInitial, fitAmpMin, fitAmpMax, t0Initial;
  
   if (fitLG) {
     fitAmpMin = m_fitAmpMinLG;
     fitAmpMax = m_fitAmpMaxLG;
     t0Initial = m_nominalT0LG;
     ampInitial = m_ADCPeakLG;
   }
   else {
     ampInitial = m_ADCPeakHG;
     fitAmpMin = m_fitAmpMinHG;
     fitAmpMax = m_fitAmpMaxHG;
     t0Initial = m_nominalT0HG;
  }
  
   if (refitLG) {
     hist_p = m_fitHistLGRefit.get();
   }
   else {
     hist_p = m_fitHist.get();
   }
   if (ampInitial < fitAmpMin) ampInitial = fitAmpMin * 1.5;
  
  
   ZDCFitWrapper* fitWrapper = m_defaultFitWrapper.get();
   if (preExpTail()) {
     fitWrapper = m_preExpFitWrapper.get();
     (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->SetInitialExpPulse(m_initialExpAmp);
   }
   else if (PrePulse()) {
     fitWrapper = m_prePulseFitWrapper.get();
     (static_cast<ZDCPrePulseFitWrapper*>(fitWrapper))->SetInitialPrePulse(m_initialPrePulseAmp, m_initialPrePulseT0,0,25);
   }
   
   if (m_adjTimeRangeEvent) {
     m_fitTMin = std::max(m_fitTMin, m_deltaTSample * m_minSampleEvt - m_deltaTSample / 2);
     m_fitTMax = std::min(m_fitTMax, m_deltaTSample * m_maxSampleEvt + m_deltaTSample / 2);
  
     float fitTReference = m_deltaTSample * m_usedPresampIdx;
  
     fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
   }
   else {
     fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
   }
  
   // Now perform the fit
   //
   std::string options = m_fitOptions + "Ns";
   if (QuietFits()) {
     options += "Q";
   }
  
   bool fitFailed = false;
  
   dumpTF1(fitWrapper->GetWrapperTF1RawPtr());
   
   //
   //  Fit the data with the function provided by the fit wrapper
   //
   TFitResultPtr result_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
   int fitStatus = result_ptr;
   
   //
   // If the first fit failed, also check the EDM. If sufficiently small, the failure is almost surely due
   //   to parameter limits and we just accept the result
   //
   if (fitStatus != 0 && result_ptr->Edm() > 0.001) 
     {
     //
     // We contstrain the fit and try again
     //
     fitWrapper->ConstrainFit();
  
     TFitResultPtr constrFitResult_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
     fitWrapper->UnconstrainFit();
  
     if ((int) constrFitResult_ptr != 0) {
       //
       // Even the constrained fit failed, so we quit.
       //
       fitFailed = true;
     }
     else {
       // Now we try the fit again with the constraint removed
       //
       TFitResultPtr unconstrFitResult_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
       if ((int) unconstrFitResult_ptr != 0) {
     //
     // The unconstrained fit failed again, so we redo the constrained fit
     //
     fitWrapper->ConstrainFit();
       
     TFitResultPtr constrFit2Result_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
     if ((int) constrFit2Result_ptr != 0) {
       //
       // Even the constrained fit failed the second time, so we quit.
       //
       fitFailed = true;
     }
  
     result_ptr = constrFit2Result_ptr;
     fitWrapper->UnconstrainFit();
       }
       else {
     result_ptr = unconstrFitResult_ptr;
       }
     }
   }
  
   if (!m_fitFailed && s_saveFitFunc) {
     hist_p->GetListOfFunctions()->Clear();
  
     TF1* func = fitWrapper->GetWrapperTF1RawPtr();
     std::string name = func->GetName();
  
     TF1* copyFunc = static_cast<TF1*>(func->Clone((name + "_copy").c_str()));
     hist_p->GetListOfFunctions()->Add(copyFunc);
   }
  
   if (!refitLG) {
     m_fitFailed = fitFailed;
     m_bkgdMaxFraction = fitWrapper->GetBkgdMaxFraction();
     m_fitAmplitude = fitWrapper->GetAmplitude();
     m_fitAmpError = fitWrapper->GetAmpError();
  
     if (preExpTail()) {
       m_fitExpAmp  = (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->GetExpAmp();
     }
     else {
       m_fitExpAmp = 0;
     }
     
     m_fitTime      = fitWrapper->GetTime();
     m_fitTimeSub = m_fitTime - t0Initial;
  
     m_fitChisq = result_ptr->Chi2();
     m_fitNDoF = result_ptr->Ndf();
     
     m_fitTau1 = fitWrapper->GetTau1();
     m_fitTau2 = fitWrapper->GetTau2();
     
     // Here we need to check if the fit amplitude is small (close) enough to fitAmpMin.
     // with "< 1+epsilon" where epsilon ~ 1%
     if (m_fitAmplitude < fitAmpMin * 1.01) {
       m_fitMinAmp = true;
     }
   }
   else {
     m_evtLGRefit = true;
     m_refitLGFitAmpl = fitWrapper->GetAmplitude();
     m_refitLGAmpl = fitWrapper->GetAmplitude() * m_gainFactorLG;
     m_refitLGAmpError = fitWrapper->GetAmpError() * m_gainFactorLG;
     m_refitLGChisq = result_ptr->Chi2();
     m_refitLGTime = fitWrapper->GetTime();
     m_refitLGTimeSub = m_refitLGTime - t0Initial;
   }
 }

◆ DoFitCombined()

void ZDCPulseAnalyzer::DoFitCombined ( bool refitLG = false )

private

Definition at line 1633 of file ZDCPulseAnalyzer.cxx.

 {
   bool fitLG = refitLG || m_useLowGain;
   TH1* hist_p = nullptr, *delayedHist_p = nullptr;
  
   FillHistogram(refitLG);
   if (refitLG) {
     hist_p = m_fitHistLGRefit.get();
     delayedHist_p = m_delayedHistLGRefit.get();
   }
   else {
     hist_p = m_fitHist.get();
     delayedHist_p = m_delayedHist.get();
   }
   
   float fitAmpMin, fitAmpMax, t0Initial, ampInitial;
   if (fitLG) {
     ampInitial = m_ADCPeakLG;
     fitAmpMin = m_fitAmpMinLG;
     fitAmpMax = m_fitAmpMaxLG;
     t0Initial = m_nominalT0LG;
   }
   else {
     ampInitial = m_ADCPeakHG;
     fitAmpMin = m_fitAmpMinHG;
     fitAmpMax = m_fitAmpMaxHG;
     t0Initial = m_nominalT0HG;
   }
  
   // Set the initial values
   //
   if (ampInitial < fitAmpMin) ampInitial = fitAmpMin * 1.5;
  
   ZDCFitWrapper* fitWrapper = m_defaultFitWrapper.get();
   //if (PrePulse()) fitWrapper = fitWrapper = m_preExpFitWrapper.get();
  
   if (preExpTail()) {
     fitWrapper = m_preExpFitWrapper.get();
     (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->SetInitialExpPulse(m_initialExpAmp);
   }
   else if (PrePulse()) {
     fitWrapper = m_prePulseFitWrapper.get();
     (static_cast<ZDCPrePulseFitWrapper*>(fitWrapper))->SetInitialPrePulse(m_initialPrePulseAmp, m_initialPrePulseT0,0,25);
   }
  
   // Initialize the fit wrapper for this event, specifying a
   //   per-event fit range if necessary
   //
   if (m_adjTimeRangeEvent) {
     m_fitTMin = std::max(m_fitTMin, m_deltaTSample * m_minSampleEvt - m_deltaTSample / 2);
     m_fitTMax = std::min(m_fitTMax, m_deltaTSample * m_maxSampleEvt + m_deltaTSample / 2);
  
     float fitTReference = m_deltaTSample * m_usedPresampIdx;
  
     fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
   }
   else {
     fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
   }
  
   // Set up the virtual fitter
   //
   TFitter* theFitter = nullptr;
  
   if (PrePulse()) {
     m_prePulseCombinedFitter = MakeCombinedFitter(fitWrapper->GetWrapperTF1RawPtr());
  
     theFitter = m_prePulseCombinedFitter.get();
   }
   else {
     m_defaultCombinedFitter = MakeCombinedFitter(fitWrapper->GetWrapperTF1RawPtr());
  
     theFitter = m_defaultCombinedFitter.get();
   }
  
   dumpTF1(fitWrapper->GetWrapperTF1RawPtr());
  
   // Set the static pointers to histograms and function for use in FCN
   //
   s_undelayedFitHist = hist_p;
   s_delayedFitHist = delayedHist_p;
   s_combinedFitFunc = fitWrapper->GetWrapperTF1RawPtr();
   s_combinedFitTMax = m_fitTMax;
   s_combinedFitTMin = m_fitTMin;
  
   
   size_t numFitPar = theFitter->GetNumberTotalParameters();
  
   theFitter->GetMinuit()->fISW[4] = -1;
  
   // Now perform the fit
   //
   if (s_quietFits) {
     theFitter->GetMinuit()->fISW[4] = -1;
  
     int  ierr= 0; 
     theFitter->GetMinuit()->mnexcm("SET NOWarnings",nullptr,0,ierr);
   }
   else theFitter->GetMinuit()->fISW[4] = 0;
  
   // Only include baseline shift in fit for pre-pulses. Otherwise baseline matching should work
   //
   if (PrePulse()) {
     theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
     theFitter->ReleaseParameter(0);
   }
   else {
     theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
     theFitter->FixParameter(0);
   }
  
   
   double arglist[100];
   arglist[0] = 5000; // number of function calls
   arglist[1] = 0.01; // tolerance
   int status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
  
   double fitAmp = theFitter->GetParameter(1);
   
   // Capture the chi-square etc.
   //
   double chi2, edm, errdef;
   int nvpar, nparx;
   
   theFitter->GetStats(chi2, edm, errdef, nvpar, nparx);
  
   // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
   // with "< 1+epsilon" where epsilon ~ 1%
   //
   if (status || fitAmp < fitAmpMin * 1.01 || edm > 0.01){
  
     //
     // We first retry the fit with no baseline adjust
     //
     theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
     theFitter->FixParameter(0);
  
     // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
     // with "< 1+epsilon" where epsilon ~ 1%
     if (fitAmp < fitAmpMin * 1.01) {
       if (m_adjTimeRangeEvent) {
         float fitTReference = m_deltaTSample * m_usedPresampIdx;
         fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
       }
       else {
         fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
       }
     }
  
     status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
     if (status != 0) {
       //
       // Fit failed event with no baseline adust, so be it
       //
       theFitter->ReleaseParameter(0);
       m_fitFailed = true;
     }
     else {
       //
       // The fit succeeded with no baseline adjust, re-fit allowing for baseline adjust using
       //  the parameters from previous fit as the starting point
       //
       theFitter->ReleaseParameter(0);
       status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
  
       if (status) {
         // Since we know the fit can succeed without the baseline adjust, go back to it
         //
         theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
         theFitter->FixParameter(0);
         status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
       }
     }
   }
   else m_fitFailed = false;
  
   // Check to see if the fit forced the amplitude to the minimum, if so set the corresponding status bit
   //
   fitAmp = theFitter->GetParameter(1);
  
   // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
   // with "< 1+epsilon" where epsilon ~ 1%
   if (fitAmp < fitAmpMin * 1.01) {
     m_fitMinAmp = true;
   }
  
   if (!s_quietFits) theFitter->GetMinuit()->fISW[4] = -1;
  
   std::vector<double> funcParams(numFitPar - 1);
   std::vector<double> funcParamErrs(numFitPar - 1);
  
   // Save the baseline shift between delayed and undelayed samples
   //
   m_delayedBaselineShift = theFitter->GetParameter(0);
  
   // Capture and store the fit function parameteds and errors
   //
   for (size_t ipar = 1; ipar < numFitPar; ipar++) {
     funcParams[ipar - 1] = theFitter->GetParameter(ipar);
     funcParamErrs[ipar - 1] = theFitter->GetParError(ipar);
   }
  
   s_combinedFitFunc->SetParameters(&funcParams[0]);
   s_combinedFitFunc->SetParErrors(&funcParamErrs[0]);
  
   // Capture the chi-square etc.
   //
   theFitter->GetStats(chi2, edm, errdef, nvpar, nparx);
  
   int ndf = 2 * m_Nsample - nvpar;
  
   s_combinedFitFunc->SetChisquare(chi2);
   s_combinedFitFunc->SetNDF(ndf);
  
   // add to list of functions
   if (s_saveFitFunc) {
     s_undelayedFitHist->GetListOfFunctions()->Clear();
     s_undelayedFitHist->GetListOfFunctions()->Add(s_combinedFitFunc);
  
     s_delayedFitHist->GetListOfFunctions()->Clear();
     s_delayedFitHist->GetListOfFunctions()->Add(s_combinedFitFunc);
   }
  
   if (!refitLG) {
     // Save the pull values from the last call to FCN
     //
     arglist[0] = 3; // number of function calls
     theFitter->ExecuteCommand("Cal1fcn", arglist, 1);
     m_fitPulls = s_pullValues;
     
     m_fitAmplitude = fitWrapper->GetAmplitude();
     m_fitTime      = fitWrapper->GetTime();
     if (PrePulse()) {
       m_fitPreT0   = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPreT0();
       m_fitPreAmp  = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPreAmp();
       m_fitPostT0  = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPostT0();
       m_fitPostAmp = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPostAmp();
     }
     
     if (preExpTail()) {
       m_fitExpAmp  = (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->GetExpAmp();
     }
     else {
       m_fitExpAmp = 0;
     }
     
     m_fitTimeSub = m_fitTime - t0Initial;
     m_fitChisq = chi2;
     m_fitNDoF = ndf;
     
     m_fitTau1 = fitWrapper->GetTau1();
     m_fitTau2 = fitWrapper->GetTau2();
     
     m_fitAmpError = fitWrapper->GetAmpError();
     m_bkgdMaxFraction = fitWrapper->GetBkgdMaxFraction();
   }
   else {
     m_evtLGRefit = true;
     m_refitLGFitAmpl = fitWrapper->GetAmplitude();
     m_refitLGAmpl = fitWrapper->GetAmplitude() * m_gainFactorLG;
     m_refitLGAmpError = fitWrapper->GetAmpError() * m_gainFactorLG;
     m_refitLGChisq = chi2;
     m_refitLGTime = fitWrapper->GetTime();
     m_refitLGTimeSub = m_refitLGTime - t0Initial;
   }
 }

◆ dump()

void ZDCPulseAnalyzer::dump ( ) const

Definition at line 1956 of file ZDCPulseAnalyzer.cxx.

 {
   (*m_msgFunc_p)(ZDCMsg::Info, ("ZDCPulseAnalyzer dump for tag = " + m_tag));
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("Presample index, value = " + std::to_string(m_preSampleIdx) +  ", " + std::to_string(m_preSample)));
  
   if (m_useDelayed) {
     (*m_msgFunc_p)(ZDCMsg::Info, ("using delayed samples with delta T = " + std::to_string(m_delayedDeltaT) + ", and pedestalDiff == " +
                                   std::to_string(m_delayedPedestalDiff)));
   }
  
   std::ostringstream message1;
   message1 << "samplesSub ";
   for (size_t sample = 0; sample < m_samplesSub.size(); sample++) {
     message1 << ", [" << sample << "] = " << m_samplesSub[sample];
   }
   (*m_msgFunc_p)(ZDCMsg::Info, message1.str());
  
   std::ostringstream message3;
   message3 << "samplesDeriv2nd ";
   for (size_t sample = 0; sample < m_samplesDeriv2nd.size(); sample++) {
     message3 << ", [" << sample << "] = " << m_samplesDeriv2nd[sample];
   }
   (*m_msgFunc_p)(ZDCMsg::Info, message3.str());
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("minimum 2nd deriv sample, value = " + std::to_string(m_minDeriv2ndIndex) + ", " + std::to_string(m_minDeriv2nd)));
 }

◆ dumpSetting()

void ZDCPulseAnalyzer::dumpSetting ( ) const

Definition at line 2003 of file ZDCPulseAnalyzer.cxx.

 {
   if (m_useDelayed) {
     (*m_msgFunc_p)(ZDCMsg::Info, ("using delayed samples with delta T = " + std::to_string(m_delayedDeltaT) + ", and pedestalDiff == " + std::to_string(m_delayedPedestalDiff)));
   }
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("m_fixTau1 = " + std::to_string(m_fixTau1) + "  m_fixTau2=" + std::to_string(m_fixTau2) + "  m_nominalTau1=" + std::to_string(m_nominalTau1) + "  m_nominalTau2=" + std::to_string(m_nominalTau2) + "  m_nominalT0HG=" + std::to_string(m_nominalT0HG) + "  m_nominalT0LG=" + std::to_string(m_nominalT0LG)));
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("m_defaultFitTMax = " + std::to_string(m_defaultFitTMax)));
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("m_HGOverflowADC = " + std::to_string(m_HGOverflowADC) + "  m_HGUnderflowADC=" + std::to_string(m_HGUnderflowADC) + "  m_LGOverflowADC=" + std::to_string(m_LGOverflowADC)));
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("m_chisqDivAmpCutLG = " + std::to_string(m_chisqDivAmpCutLG) + "  m_chisqDivAmpCutHG=" + std::to_string(m_chisqDivAmpCutHG)));
  
   (*m_msgFunc_p)(ZDCMsg::Info, ("m_T0CutLowLG = " + std::to_string(m_T0CutLowLG) + "  m_T0CutHighLG=" + std::to_string(m_T0CutHighLG) + "  m_T0CutLowHG=" + std::to_string(m_T0CutLowHG) + "  m_T0CutHighHG=" + std::to_string(m_T0CutHighHG)));
 }

◆ dumpTF1()

void ZDCPulseAnalyzer::dumpTF1 ( const TF1 * func ) const

Definition at line 1984 of file ZDCPulseAnalyzer.cxx.

 {
   std::string message = "Dump of TF1: " + std::string(func->GetName());
   bool continueDump = (*m_msgFunc_p)(ZDCMsg::Verbose, std::move(message));
   if (!continueDump) return;
   
   unsigned int npar = func->GetNpar();
   for (unsigned int ipar = 0; ipar < npar; ipar++) {
     std::ostringstream msgstr;
  
     double parMin = 0, parMax = 0;
     func->GetParLimits(ipar, parMin, parMax);
                
     msgstr << "Parameter " << ipar << ", value = " << func->GetParameter(ipar) << ", error = "
        << func->GetParError(ipar) << ", min = " << parMin << ", max = " << parMax;
     (*m_msgFunc_p)(ZDCMsg::Verbose, msgstr.str());
   }
 }

◆ enableDelayed()

void ZDCPulseAnalyzer::enableDelayed	(	float	deltaT,
		float	pedestalShift,
		bool	fixedBaseline = `false`
	)

Definition at line 121 of file ZDCPulseAnalyzer.cxx.

 {
   m_useDelayed = true;
   m_useFixedBaseline = fixedBaseline;
  
   m_delayedDeltaT = deltaT;
   m_delayedPedestalDiff = pedestalShift;
  
   m_deltaTSample /= 2.;
  
   std::string delayedHGName = std::string(m_fitHist->GetName()) + "delayed";
   std::string delayedLGName = std::string(m_fitHistLGRefit->GetName()) + "delayed";
  
   m_delayedHist = std::make_unique<TH1F>(delayedHGName.c_str(), "", m_Nsample, m_tmin + m_delayedDeltaT, m_tmax + m_delayedDeltaT);
   m_delayedHist->SetDirectory(0);
  
   m_delayedHistLGRefit = std::make_unique<TH1F>(delayedLGName.c_str(), "", m_Nsample, m_tmin + m_delayedDeltaT, m_tmax + m_delayedDeltaT);
   m_delayedHistLGRefit->SetDirectory(0);
  
   m_ADCSamplesHGSub.assign(2 * m_Nsample, 0);
   m_ADCSamplesLGSub.assign(2 * m_Nsample, 0);
 }

◆ enableFADCCorrections()

void ZDCPulseAnalyzer::enableFADCCorrections	(	bool	correctPerSample,
		std::unique_ptr< const TH1 > &	correHistHG,
		std::unique_ptr< const TH1 > &	correHistLG
	)

Definition at line 452 of file ZDCPulseAnalyzer.cxx.

 {
   m_haveFADCCorrections = true;
   m_FADCCorrPerSample = correctPerSample;
   
   // check for appropriate limits
   //
   auto getXmin=[](const TH1 * pH){
     return pH->GetXaxis()->GetXmin();
   };
   auto getXmax=[](const TH1 * pH){
     return pH->GetXaxis()->GetXmax();
   };
   auto xmin= getXmin(correHistHG.get());
   auto xmax= getXmax(correHistHG.get());
   if (std::abs(xmin+0.5) > 1e-3 || std::abs(xmax - 4095.5) > 1e-3) {
     (*m_msgFunc_p)(ZDCMsg::Error, "ZDCPulseAnalyzer::enableFADCCorrections:: invalid high gain correction histogram range: xmin, xmax = " +
                    std::to_string(xmin ) + ", " + std::to_string(xmax) );
   }
   else {
     m_FADCCorrHG = std::move(correHistHG);
   }
   xmin= getXmin(correHistLG.get());
   xmax= getXmax(correHistLG.get());
   if (std::abs(xmin+0.5) > 1e-3 ||
       std::abs(xmax - 4095.5) > 1e-3) {
     (*m_msgFunc_p)(ZDCMsg::Error, "ZDCPulseAnalyzer::enableFADCCorrections:: invalid low gain correction histogram range: xmin, xmax = " +
                    std::to_string(xmin) + ", " + std::to_string(xmax) );
   }
   else {
     m_FADCCorrLG = std::move(correHistLG);
   }
 }

◆ enablePostExclusion()

void ZDCPulseAnalyzer::enablePostExclusion	(	unsigned int	maxSamplesExcl,
		unsigned int	HGADCThresh,
		unsigned int	LGADCThresh
	)

inline

Definition at line 465 of file ZDCPulseAnalyzer.h.

   {
     m_enablePostExcl = true;
     m_maxSamplesPostExcl = maxSamplesExcl;
     m_postExclHGADCThresh = HGADCThresh;
     m_postExclLGADCThresh = LGADCThresh;
   }

◆ enablePreExclusion()

void ZDCPulseAnalyzer::enablePreExclusion	(	unsigned int	maxSamplesExcl,
		unsigned int	HGADCThresh,
		unsigned int	LGADCThresh
	)

inline

Definition at line 457 of file ZDCPulseAnalyzer.h.

   {
     m_enablePreExcl = true;
     m_maxSamplesPreExcl = maxSamplesExcl;
     m_preExclHGADCThresh = HGADCThresh;
     m_preExclLGADCThresh = LGADCThresh;
   }

◆ enableRepass()

void ZDCPulseAnalyzer::enableRepass	(	float	peak2ndDerivMinRepassHG,
		float	peak2ndDerivMinRepassLG
	)

Definition at line 144 of file ZDCPulseAnalyzer.cxx.

 {
   m_enableRepass = true;
   m_peak2ndDerivMinRepassHG = peak2ndDerivMinRepassHG;
   m_peak2ndDerivMinRepassLG = peak2ndDerivMinRepassLG;
 }

◆ enableTimeSigCut()

void ZDCPulseAnalyzer::enableTimeSigCut	(	bool	AND,
		float	sigCut,
		const std::string &	TF1String,
		const std::vector< double > &	parsHG,
		const std::vector< double > &	parsLG
	)

Definition at line 423 of file ZDCPulseAnalyzer.cxx.

 {
   m_timeCutMode = AND ? 2 : 1;
   m_t0CutSig = sigCut;
  
   // Make the TF1's that provide the resolution
   //
   std::string timeResHGName = "TimeResFuncHG_" + m_tag;
   std::string timeResLGName = "TimeResFuncLG_" + m_tag;
  
   TF1* funcHG_p = new TF1(timeResHGName.c_str(), TF1String.c_str(), 0, m_HGOverflowADC);
   TF1* funcLG_p = new TF1(timeResLGName.c_str(), TF1String.c_str(), 0, m_LGOverflowADC);
  
   if (parsHG.size() != static_cast<unsigned int>(funcHG_p->GetNpar()) ||
       parsLG.size() != static_cast<unsigned int>(funcLG_p->GetNpar())) {
     //
     // generate an error message
   }
  
   funcHG_p->SetParameters(&parsHG[0]);
   funcLG_p->SetParameters(&parsLG[0]);
   
   m_timeResFuncHG_p.reset(funcHG_p);
   m_timeResFuncLG_p.reset(funcLG_p);
  
 }

◆ ExcludeEarlyLG()

bool ZDCPulseAnalyzer::ExcludeEarlyLG ( ) const

inline

Definition at line 570 of file ZDCPulseAnalyzer.h.

570 {return m_ExcludeEarly;}

◆ ExcludeLateLG()

bool ZDCPulseAnalyzer::ExcludeLateLG ( ) const

inline

Definition at line 571 of file ZDCPulseAnalyzer.h.

571 {return m_ExcludeLate;}

◆ Failed()

bool ZDCPulseAnalyzer::Failed ( ) const

inline

Definition at line 556 of file ZDCPulseAnalyzer.h.

556 {return m_fail;}

◆ FillHistogram()

void ZDCPulseAnalyzer::FillHistogram ( bool refitLG ) const

inlineprivate

Definition at line 382 of file ZDCPulseAnalyzer.h.

   {
     if (!m_useDelayed) {
       if (!refitLG) {
     // Set the data and errors in the histogram object
     //
     for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
       m_fitHist->SetBinContent(isample + 1, m_samplesSub[isample]);
       m_fitHist->SetBinError(isample + 1, m_samplesSig[isample]);
     }
       }
       else {
     for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
       m_fitHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample]);
       m_fitHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]);
     }
       }
     }
     else {
       if (!refitLG) {
         // Set the data and errors in the histogram object
     //
     for (size_t isample = 0; isample < m_Nsample; isample++) {
       m_fitHist->SetBinContent(isample + 1, m_samplesSub[isample * 2]);
       m_delayedHist->SetBinContent(isample + 1, m_samplesSub[isample * 2 + 1]);
       
       m_fitHist->SetBinError(isample + 1, m_samplesSig[isample]); 
       m_delayedHist->SetBinError(isample + 1, m_samplesSig[isample]);
     }
       }
       else {
         // Set the data and errors in the histogram object
     //
     for (size_t isample = 0; isample < m_Nsample; isample++) {
       m_fitHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample * 2]);
       m_delayedHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample * 2 + 1]);
       
       m_fitHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]); 
       m_delayedHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]);
     }
       }
     }
   }

◆ FitFailed()

bool ZDCPulseAnalyzer::FitFailed ( ) const

inline

Definition at line 566 of file ZDCPulseAnalyzer.h.

566 {return m_fitFailed;}

◆ fitMinimumAmplitude()

bool ZDCPulseAnalyzer::fitMinimumAmplitude ( ) const

inline

Definition at line 573 of file ZDCPulseAnalyzer.h.

573 {return m_fitMinAmp;}

◆ getADCPeakHG()

float ZDCPulseAnalyzer::getADCPeakHG ( ) const

inline

Definition at line 661 of file ZDCPulseAnalyzer.h.

661 {return m_ADCPeakHG;}

◆ getADCPeakLG()

float ZDCPulseAnalyzer::getADCPeakLG ( ) const

inline

Definition at line 662 of file ZDCPulseAnalyzer.h.

662 {return m_ADCPeakLG;}

◆ GetAmpError()

float ZDCPulseAnalyzer::GetAmpError ( ) const

inline

Definition at line 600 of file ZDCPulseAnalyzer.h.

600 {return m_ampError;}

◆ GetAmplitude()

float ZDCPulseAnalyzer::GetAmplitude ( ) const

inline

Definition at line 599 of file ZDCPulseAnalyzer.h.

599 {return m_amplitude;}

◆ getAmplitudeCorrection()

double ZDCPulseAnalyzer::getAmplitudeCorrection ( bool highGain )

private

Definition at line 523 of file ZDCPulseAnalyzer.cxx.

 {
   double amplCorrFactor  = 1;
   
   // If we have FADC correction and we aren't applying it per-sample, do so here 
   //
   if (m_haveFADCCorrections && !m_FADCCorrPerSample) {
     double fadcCorr = highGain ? m_FADCCorrHG->Interpolate(m_fitAmplitude) : m_FADCCorrLG->Interpolate(m_fitAmplitude);
     amplCorrFactor *= fadcCorr;
   }
  
   double amplCorr = m_fitAmplitude * amplCorrFactor;
   
   // If we have a non-linear correction, apply it here   
   //   We apply it as an inverse correction - i.e. we divide by a correction
   //     term tha is a sum of coefficients times the ADC minus a reference
   //     to a power. The lowest power is 1, the highest is deteremined by
   //     the number of provided coefficients 
  
   if (m_haveNonlinCorr) {
     float invNLCorr = 1.0;
     float nlPolyArg = (amplCorr - m_nonLinCorrRefADC) / m_nonLinCorrRefScale;
     
     if (highGain) {
       for (size_t power = 1; power <= m_nonLinCorrParamsHG.size(); power++) {
           invNLCorr += m_nonLinCorrParamsHG[power - 1]*pow(nlPolyArg, power);
       }
     }
     else {
       for (size_t power = 1; power <= m_nonLinCorrParamsLG.size(); power++) {
           invNLCorr += m_nonLinCorrParamsLG[power - 1]*pow(nlPolyArg, power);
       }
     }
  
     amplCorrFactor /= invNLCorr;  
   }
   
   return amplCorrFactor;
 }

◆ GetAmpNoNonLin()

float ZDCPulseAnalyzer::GetAmpNoNonLin ( ) const

inline

Definition at line 598 of file ZDCPulseAnalyzer.h.

598 {return m_ampNoNonLin;}

◆ GetBkgdMaxFraction()

float ZDCPulseAnalyzer::GetBkgdMaxFraction ( ) const

inline

Definition at line 678 of file ZDCPulseAnalyzer.h.

678 {return m_bkgdMaxFraction;}

◆ GetChisq()

float ZDCPulseAnalyzer::GetChisq ( ) const

inline

Definition at line 588 of file ZDCPulseAnalyzer.h.

588 {return m_fitChisq;}

◆ GetCombinedGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetCombinedGraph ( bool forceLG = false ) const

Definition at line 2049 of file ZDCPulseAnalyzer.cxx.

 {
   //
   // We defer filling the histogram if we don't have a pulse until the histogram is requested
   //
   GetHistogramPtr(LGRefit);
  
   TH1* hist_p = nullptr, *delayedHist_p = nullptr;
   if (LGRefit) {
     hist_p = m_fitHistLGRefit.get();
     delayedHist_p = m_delayedHistLGRefit.get();
   }
   else {
     hist_p = m_fitHist.get();
     delayedHist_p = m_delayedHist.get();
   }
   
   std::shared_ptr<TGraphErrors> theGraph = std::make_shared<TGraphErrors>(TGraphErrors(2 * m_Nsample));
   size_t npts = 0;
  
   for (int ipt = 0; ipt < hist_p->GetNbinsX(); ipt++) {
     theGraph->SetPoint(npts, hist_p->GetBinCenter(ipt + 1), hist_p->GetBinContent(ipt + 1));
     theGraph->SetPointError(npts++, 0, hist_p->GetBinError(ipt + 1));
   }
  
   for (int iDelayPt = 0; iDelayPt < delayedHist_p->GetNbinsX(); iDelayPt++) {
     theGraph->SetPoint(npts, delayedHist_p->GetBinCenter(iDelayPt + 1), delayedHist_p->GetBinContent(iDelayPt + 1) - m_delayedBaselineShift);
     theGraph->SetPointError(npts++, 0, delayedHist_p->GetBinError(iDelayPt + 1));
   }
   if (m_havePulse) {
     TF1* func_p = static_cast<TF1*>(hist_p->GetListOfFunctions()->Last());
     if (func_p) {
       theGraph->GetListOfFunctions()->Add(new TF1(*func_p));
       hist_p->GetListOfFunctions()->SetOwner (false);
     }
   }
   theGraph->SetName(( std::string(hist_p->GetName()) + "combinaed").c_str());
  
   theGraph->SetMarkerStyle(20);
   theGraph->SetMarkerColor(1);
  
   return theGraph;
 }

◆ GetdelayBS()

float ZDCPulseAnalyzer::GetdelayBS ( ) const

inline

Definition at line 670 of file ZDCPulseAnalyzer.h.

670 {return m_delayedBaselineShift;}

◆ GetDelayedBaselineCorr()

float ZDCPulseAnalyzer::GetDelayedBaselineCorr ( ) const

inline

Definition at line 681 of file ZDCPulseAnalyzer.h.

681 {return m_baselineCorr;}

◆ GetDelayedBaselineShiftFit()

float ZDCPulseAnalyzer::GetDelayedBaselineShiftFit ( ) const

inline

Definition at line 680 of file ZDCPulseAnalyzer.h.

680 {return m_delayedBaselineShift;}

◆ GetFitAmplitude()

float ZDCPulseAnalyzer::GetFitAmplitude ( ) const

inline

Definition at line 583 of file ZDCPulseAnalyzer.h.

583 {return m_fitAmplitude;}

◆ GetFitExpAmp()

float ZDCPulseAnalyzer::GetFitExpAmp ( ) const

inline

Definition at line 595 of file ZDCPulseAnalyzer.h.

595 {return m_fitExpAmp;}

◆ GetFitPostAmp()

float ZDCPulseAnalyzer::GetFitPostAmp ( ) const

inline

Definition at line 594 of file ZDCPulseAnalyzer.h.

594 {return m_postAmplitude;}

◆ GetFitPostT0()

float ZDCPulseAnalyzer::GetFitPostT0 ( ) const

inline

Definition at line 593 of file ZDCPulseAnalyzer.h.

593 {return m_fitPostT0;}

◆ GetFitPreAmp()

float ZDCPulseAnalyzer::GetFitPreAmp ( ) const

inline

Definition at line 592 of file ZDCPulseAnalyzer.h.

592 {return m_preAmplitude;}

◆ GetFitPreT0()

float ZDCPulseAnalyzer::GetFitPreT0 ( ) const

inline

Definition at line 591 of file ZDCPulseAnalyzer.h.

591 {return m_fitPreT0;}

◆ GetFitPulls()

std::vector< float > ZDCPulseAnalyzer::GetFitPulls ( bool forceLG = false ) const

Definition at line 486 of file ZDCPulseAnalyzer.cxx.

 {
   //
   // If there was no pulse for this event, return an empty vector (see reset() method)
   //
   if (!m_havePulse) {
     return m_fitPulls;
   }
  
   //
   // The combined (delayed+undelayed) pulse fitting fills out m_fitPulls directly
   //
   if (m_useDelayed) {
     return m_fitPulls;
   }
   else {
     //
     // When not using combined fitting, We don't have the pre-calculated pulls. Calculate them on the fly. 
     //
     std::vector<float> pulls(m_Nsample, -100);
     
     const TH1* dataHist_p = refitLG ? m_fitHistLGRefit.get() : m_fitHist.get();
     const TF1* fit_p = static_cast<const TF1*>(dataHist_p->GetListOfFunctions()->Last());
     
     for (size_t ibin = 0; ibin < m_Nsample ; ibin++) {
       float t = dataHist_p->GetBinCenter(ibin + 1);
       float fitVal = fit_p->Eval(t);
       float histVal = dataHist_p->GetBinContent(ibin + 1);
       float histErr = dataHist_p->GetBinError(ibin + 1);
       float pull = (histVal - fitVal)/histErr;
       pulls[ibin] = pull;
     }
  
     return pulls;
   }
 }

◆ GetFitT0()

float ZDCPulseAnalyzer::GetFitT0 ( ) const

inline

Definition at line 584 of file ZDCPulseAnalyzer.h.

584 {return m_fitTime;}

◆ GetFitTau1()

float ZDCPulseAnalyzer::GetFitTau1 ( ) const

inline

Definition at line 589 of file ZDCPulseAnalyzer.h.

589 {return m_fitTau1;}

◆ GetFitTau2()

float ZDCPulseAnalyzer::GetFitTau2 ( ) const

inline

Definition at line 590 of file ZDCPulseAnalyzer.h.

590 {return m_fitTau2;}

◆ GetFitTMax()

float ZDCPulseAnalyzer::GetFitTMax ( ) const

inline

Definition at line 667 of file ZDCPulseAnalyzer.h.

667 {return m_fitTMax;}

◆ GetFitTMin()

float ZDCPulseAnalyzer::GetFitTMin ( ) const

inline

Definition at line 668 of file ZDCPulseAnalyzer.h.

668 {return m_fitTMin;}

◆ GetGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetGraph ( bool forceLG = false ) const

Definition at line 2094 of file ZDCPulseAnalyzer.cxx.

 {
   //
   // We defer filling the histogram if we don't have a pulse until the histogram is requested
   //
   const TH1* hist_p = GetHistogramPtr(forceLG);
  
   std::shared_ptr<TGraphErrors> theGraph = std::make_shared<TGraphErrors>(TGraphErrors(m_Nsample));
   size_t npts = 0;
  
   for (int ipt = 0; ipt < hist_p->GetNbinsX(); ipt++) {
     theGraph->SetPoint(npts, hist_p->GetBinCenter(ipt + 1), hist_p->GetBinContent(ipt + 1));
     theGraph->SetPointError(npts++, 0, hist_p->GetBinError(ipt + 1));
   }
  
   TF1* func_p = static_cast<TF1*>(hist_p->GetListOfFunctions()->Last());
   theGraph->GetListOfFunctions()->Add(func_p);
   theGraph->SetName(( std::string(hist_p->GetName()) + "not_combinaed").c_str());
  
   theGraph->SetMarkerStyle(20);
   theGraph->SetMarkerColor(1);
  
   return theGraph;
 }

◆ GetHistogramPtr()

const TH1* ZDCPulseAnalyzer::GetHistogramPtr ( bool refitLG = false ) const

inline

Definition at line 683 of file ZDCPulseAnalyzer.h.

   {
     //
     // We defer filling the histogram if we don't have a pulse until the histogram is requested
     //
     if (!m_havePulse) {
       FillHistogram(refitLG);
     }
     
     return refitLG ? m_fitHistLGRefit.get() : m_fitHist.get();
   }

◆ getLGMode()

unsigned int ZDCPulseAnalyzer::getLGMode ( ) const

inline

Definition at line 479 of file ZDCPulseAnalyzer.h.

479 {return m_LGMode;}

◆ getMaxADCHG()

float ZDCPulseAnalyzer::getMaxADCHG ( ) const

inline

Definition at line 640 of file ZDCPulseAnalyzer.h.

640 {return m_maxADCHG;}

◆ getMaxADCLG()

float ZDCPulseAnalyzer::getMaxADCLG ( ) const

inline

Definition at line 641 of file ZDCPulseAnalyzer.h.

641 {return m_maxADCLG;}

◆ getMaxADCSampleHG()

int ZDCPulseAnalyzer::getMaxADCSampleHG ( ) const

inline

Definition at line 655 of file ZDCPulseAnalyzer.h.

655 {return m_maxADCSampleHG;}

◆ getMaxADCSampleLG()

int ZDCPulseAnalyzer::getMaxADCSampleLG ( ) const

inline

Definition at line 658 of file ZDCPulseAnalyzer.h.

658 {return m_maxADCSampleLG;}

◆ getMaxADCSub()

float ZDCPulseAnalyzer::getMaxADCSub ( ) const

inline

Definition at line 645 of file ZDCPulseAnalyzer.h.

                              {
     float maxADCNosub = m_useLowGain ? m_maxADCLG : m_maxADCHG;
     return maxADCNosub - m_pedestal - m_preSample;
   }

◆ GetMaxDelta()

float ZDCPulseAnalyzer::GetMaxDelta ( ) const

inline

Definition at line 664 of file ZDCPulseAnalyzer.h.

664 {return m_maxDelta;}

◆ getMinADCHG()

float ZDCPulseAnalyzer::getMinADCHG ( ) const

inline

Definition at line 642 of file ZDCPulseAnalyzer.h.

642 {return m_minADCHG;}

◆ getMinADCLG()

float ZDCPulseAnalyzer::getMinADCLG ( ) const

inline

Definition at line 643 of file ZDCPulseAnalyzer.h.

643 {return m_minADCLG;}

◆ getMinADCSampleHG()

int ZDCPulseAnalyzer::getMinADCSampleHG ( ) const

inline

Definition at line 656 of file ZDCPulseAnalyzer.h.

656 {return m_minADCSampleHG;}

◆ getMinADCSampleLG()

int ZDCPulseAnalyzer::getMinADCSampleLG ( ) const

inline

Definition at line 659 of file ZDCPulseAnalyzer.h.

659 {return m_minADCSampleLG;}

◆ getMinADCSub()

float ZDCPulseAnalyzer::getMinADCSub ( ) const

inline

Definition at line 650 of file ZDCPulseAnalyzer.h.

                              {
     float minADCNosub = m_useLowGain ? m_minADCLG : m_minADCHG;
     return minADCNosub - m_pedestal - m_preSample;
   }

◆ GetMinDelta()

float ZDCPulseAnalyzer::GetMinDelta ( ) const

inline

Definition at line 665 of file ZDCPulseAnalyzer.h.

665 {return m_minDelta;}

◆ GetMinDeriv2nd()

float ZDCPulseAnalyzer::GetMinDeriv2nd ( ) const

inline

Definition at line 672 of file ZDCPulseAnalyzer.h.

672 {return m_minDeriv2nd;}

◆ GetMinDeriv2ndIndex()

float ZDCPulseAnalyzer::GetMinDeriv2ndIndex ( ) const

inline

Definition at line 673 of file ZDCPulseAnalyzer.h.

673 {return m_minDeriv2ndIndex;}

◆ GetPreExpAmp()

float ZDCPulseAnalyzer::GetPreExpAmp ( ) const

inline

Definition at line 601 of file ZDCPulseAnalyzer.h.

601 {return m_expAmplitude;}

◆ getPresample()

float ZDCPulseAnalyzer::getPresample ( ) const

inline

Definition at line 639 of file ZDCPulseAnalyzer.h.

639 {return m_preSample;}

◆ GetPreSampleAmp()

float ZDCPulseAnalyzer::GetPreSampleAmp ( ) const

inline

Definition at line 677 of file ZDCPulseAnalyzer.h.

677 {return m_preSampleAmp;}

◆ getRefitLGAmp()

float ZDCPulseAnalyzer::getRefitLGAmp ( ) const

inline

Definition at line 603 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGAmpl;
     else return 0;
   }

◆ getRefitLGAmpCorr()

float ZDCPulseAnalyzer::getRefitLGAmpCorr ( ) const

inline

Definition at line 615 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGAmplCorr;
     else return 0;
   }

◆ getRefitLGChisq()

float ZDCPulseAnalyzer::getRefitLGChisq ( ) const

inline

Definition at line 621 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGChisq;
     else return 0;
   }

◆ getRefitLGFitAmp()

float ZDCPulseAnalyzer::getRefitLGFitAmp ( ) const

inline

Definition at line 609 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGFitAmpl;
     else return 0;
   }

◆ getRefitLGTime()

float ZDCPulseAnalyzer::getRefitLGTime ( ) const

inline

Definition at line 627 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGTime;
     else return 0;
   }

◆ getRefitLGTimeSub()

float ZDCPulseAnalyzer::getRefitLGTimeSub ( ) const

inline

Definition at line 633 of file ZDCPulseAnalyzer.h.

   {
     if (m_evtLGRefit) return m_refitLGTimeSub;
     else return 0;
   }

◆ GetSamplesDeriv2nd()

const std::vector<float>& ZDCPulseAnalyzer::GetSamplesDeriv2nd ( ) const

inline

Definition at line 705 of file ZDCPulseAnalyzer.h.

705 {return m_samplesDeriv2nd;}

◆ GetSamplesSub()

const std::vector<float>& ZDCPulseAnalyzer::GetSamplesSub ( ) const

inline

Definition at line 704 of file ZDCPulseAnalyzer.h.

704 {return m_samplesSub;}

◆ GetStatusMask()

unsigned int ZDCPulseAnalyzer::GetStatusMask ( ) const

Definition at line 2020 of file ZDCPulseAnalyzer.cxx.

 {
   unsigned int statusMask = 0;
  
   if (HavePulse())  statusMask |= 1 << PulseBit;
   if (UseLowGain()) statusMask |= 1 << LowGainBit;
   if (Failed())     statusMask |= 1 << FailBit;
   if (HGOverflow()) statusMask |= 1 << HGOverflowBit;
  
   if (HGUnderflow())       statusMask |= 1 << HGUnderflowBit;
   if (PSHGOverUnderflow()) statusMask |= 1 << PSHGOverUnderflowBit;
   if (LGOverflow())        statusMask |= 1 << LGOverflowBit;
   if (LGUnderflow())       statusMask |= 1 << LGUnderflowBit;
  
   if (PrePulse())  statusMask |= 1 << PrePulseBit;
   if (PostPulse()) statusMask |= 1 << PostPulseBit;
   if (FitFailed()) statusMask |= 1 << FitFailedBit;
   if (BadChisq())  statusMask |= 1 << BadChisqBit;
  
   if (BadT0())          statusMask |= 1 << BadT0Bit;
   if (ExcludeEarlyLG()) statusMask |= 1 << ExcludeEarlyLGBit;
   if (ExcludeLateLG())  statusMask |= 1 << ExcludeLateLGBit;
   if (preExpTail())     statusMask |= 1 << preExpTailBit;
   if (fitMinimumAmplitude()) statusMask |= 1 << FitMinAmpBit;
   if (repassPulse()) statusMask |= 1 << RepassPulseBit;
  
   return statusMask;
 }

◆ GetT0Corr()

float ZDCPulseAnalyzer::GetT0Corr ( ) const

inline

Definition at line 586 of file ZDCPulseAnalyzer.h.

586 {return m_fitTimeCorr;}

◆ GetT0Sub()

float ZDCPulseAnalyzer::GetT0Sub ( ) const

inline

Definition at line 585 of file ZDCPulseAnalyzer.h.

585 {return m_fitTimeSub;}

◆ getTimeSig()

float ZDCPulseAnalyzer::getTimeSig ( ) const

inline

Definition at line 587 of file ZDCPulseAnalyzer.h.

587 {return m_timeSig;}

◆ HaveData()

bool ZDCPulseAnalyzer::HaveData ( ) const

inline

Definition at line 549 of file ZDCPulseAnalyzer.h.

549 {return m_haveData;}

◆ HavePulse()

bool ZDCPulseAnalyzer::HavePulse ( ) const

inline

Definition at line 554 of file ZDCPulseAnalyzer.h.

554 {return m_havePulse;}

◆ HGOverflow()

bool ZDCPulseAnalyzer::HGOverflow ( ) const

inline

Definition at line 557 of file ZDCPulseAnalyzer.h.

557 {return m_HGOverflow;}

◆ HGUnderflow()

bool ZDCPulseAnalyzer::HGUnderflow ( ) const

inline

Definition at line 559 of file ZDCPulseAnalyzer.h.

559 {return m_HGUnderflow;}

◆ LGOverflow()

bool ZDCPulseAnalyzer::LGOverflow ( ) const

inline

Definition at line 561 of file ZDCPulseAnalyzer.h.

561 {return m_LGOverflow;}

◆ LGUnderflow()

bool ZDCPulseAnalyzer::LGUnderflow ( ) const

inline

Definition at line 562 of file ZDCPulseAnalyzer.h.

562 {return m_LGUnderflow;}

◆ LoadAndAnalyzeData() [1/2]

bool ZDCPulseAnalyzer::LoadAndAnalyzeData	(	const std::vector< float > &	ADCSamplesHG,
		const std::vector< float > &	ADCSamplesLG
	)

Definition at line 656 of file ZDCPulseAnalyzer.cxx.

 {
   if (m_useDelayed) {
     (*m_msgFunc_p)(ZDCMsg::Fatal, "ZDCPulseAnalyzer::LoadAndAnalyzeData:: Wrong LoadAndAnalyzeData called -- expecting both delayed and undelayed samples");
   }
  
   if (!m_initializedFits) SetupFitFunctions();
  
   // Clear any transient data
   //
   Reset(false);
  
   // Make sure we have the right number of samples. Should never fail. necessry?
   //
   if (ADCSamplesHG.size() != m_Nsample || ADCSamplesLG.size() != m_Nsample) {
     m_fail = true;
     return false;
   }
  
   m_ADCSamplesHG = ADCSamplesHG;
   m_ADCSamplesLG = ADCSamplesLG;
   
   return DoAnalysis(false);
 }

◆ LoadAndAnalyzeData() [2/2]

bool ZDCPulseAnalyzer::LoadAndAnalyzeData	(	const std::vector< float > &	ADCSamplesHG,
		const std::vector< float > &	ADCSamplesLG,
		const std::vector< float > &	ADCSamplesHGDelayed,
		const std::vector< float > &	ADCSamplesLGDelayed
	)

Definition at line 681 of file ZDCPulseAnalyzer.cxx.

 {
   if (!m_useDelayed) {
     (*m_msgFunc_p)(ZDCMsg::Fatal, "ZDCPulseAnalyzer::LoadAndAnalyzeData:: Wrong LoadAndAnalyzeData called -- expecting only undelayed samples");
   }
  
   if (!m_initializedFits) SetupFitFunctions();
  
   // Clear any transient data
   //
   Reset();
  
   // Make sure we have the right number of samples. Should never fail. necessry?
   //
   if (ADCSamplesHG.size() != m_Nsample || ADCSamplesLG.size() != m_Nsample ||
       ADCSamplesHGDelayed.size() != m_Nsample || ADCSamplesLGDelayed.size() != m_Nsample) {
     m_fail = true;
     return false;
   }
  
   m_ADCSamplesHG.reserve(m_Nsample*2);
   m_ADCSamplesLG.reserve(m_Nsample*2);
   
   // Now do pedestal subtraction and check for overflows
   //
   for (size_t isample = 0; isample < m_Nsample; isample++) {
     float ADCHG = ADCSamplesHG[isample];
     float ADCLG = ADCSamplesLG[isample];
  
     float ADCHGDelay = ADCSamplesHGDelayed[isample] - m_delayedPedestalDiff;
     float ADCLGDelay = ADCSamplesLGDelayed[isample] - m_delayedPedestalDiff;
  
     if (m_delayedDeltaT > 0) {
       m_ADCSamplesHG.push_back(ADCHG);
       m_ADCSamplesHG.push_back(ADCHGDelay);
       
       m_ADCSamplesLG.push_back(ADCLG);
       m_ADCSamplesLG.push_back(ADCLGDelay);
     }
     else {
       m_ADCSamplesHG.push_back(ADCHGDelay);
       m_ADCSamplesHG.push_back(ADCHG);
       
       m_ADCSamplesLG.push_back(ADCLGDelay);
       m_ADCSamplesLG.push_back(ADCLG);
     }
   }
     
   return DoAnalysis(false);
 }

◆ MakeCombinedFitter()

std::unique_ptr< TFitter > ZDCPulseAnalyzer::MakeCombinedFitter ( TF1 * func )

staticprivate

Definition at line 1901 of file ZDCPulseAnalyzer.cxx.

 {
   TVirtualFitter::SetDefaultFitter("Minuit");
  
   size_t nFitParams = func->GetNpar() + 1;
   std::unique_ptr<TFitter> fitter = std::make_unique<TFitter>(nFitParams);
  
   fitter->GetMinuit()->fISW[4] = -1;
   fitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
  
   for (size_t ipar = 0; ipar < nFitParams - 1; ipar++) {
     double parLimitLow, parLimitHigh;
  
     func->GetParLimits(ipar, parLimitLow, parLimitHigh);
     if (std::abs(parLimitHigh / parLimitLow - 1) < 1e-6) {
       double value   = func->GetParameter(ipar);
       double lowLim  = std::min(value * 0.99, value * 1.01);
       double highLim = std::max(value * 0.99, value * 1.01);
  
       fitter->SetParameter(ipar + 1, func->GetParName(ipar), func->GetParameter(ipar), 0.01, lowLim, highLim);
       fitter->FixParameter(ipar + 1);
     }
     else {
       double value = func->GetParameter(ipar);
       if (value >= parLimitHigh)     value = parLimitHigh * 0.99;
       else if (value <= parLimitLow) value = parLimitLow * 1.01;
  
       double step = std::min((parLimitHigh - parLimitLow)/100., (value - parLimitLow)/100.);
       
       fitter->SetParameter(ipar + 1, func->GetParName(ipar), value, step, parLimitLow, parLimitHigh);
     }
   }
  
   fitter->SetFCN(ZDCPulseAnalyzer::CombinedPulsesFCN);
  
   return fitter;
 }

◆ obtainDelayedBaselineCorr()

float ZDCPulseAnalyzer::obtainDelayedBaselineCorr ( const std::vector< float > & samples )

staticprivate

Definition at line 2173 of file ZDCPulseAnalyzer.cxx.

 {
   const unsigned int nsamples = samples.size();
   
   std::vector<float> derivVec = CalculateDerivative(samples, 2);
   std::vector<float> deriv2ndVec = Calculate2ndDerivative(samples, 2);
  
   // Now step through and check even and odd samples values for 2nd derivative and derivative 
   //  we start with index 2 since the 2nd derivative calculation has 2 initial zeros with nstep = 2
   //
   float minScore = 1.0e9;
   unsigned int minIndex = 0;
   
   for (unsigned int idx = 2; idx < nsamples - 1; idx++) {
     float deriv = derivVec[idx];
     float prevDeriv = derivVec[idx - 1];
  
     float derivDiff = deriv - prevDeriv;
     
     float deriv2nd = deriv2ndVec[idx];
     if (idx > nsamples - 2) deriv2nd = deriv2ndVec[idx - 1];
     
     // Calculate a score based on the actual derivatives (squared) and 2nd derivatives (squared)
     //   and the slope differences (squared). The relative weights are not adjustable for now
     //
     float score = (deriv*deriv + 2*derivDiff*derivDiff +
            0.5*deriv2nd*deriv2nd);
  
     if (score < minScore) {
       minScore = score;
       minIndex = idx;
     }
   }
  
   // We use four samples, two each of "even" and "odd".
   // Because of the way the above analysis is done, we can always
   // Go back one even and one odd sample and forward one odd sample.
   //
   //if minIndex is < 2 or >samples.size() the result is undefined; prevent this:
   if (minIndex<2 or (minIndex+1) >=nsamples){
     throw std::out_of_range("minIndex out of range in ZDCPulseAnalyzer::obtainDelayedBaselineCorr");
   }
   float sample0 = samples[minIndex - 2];
   float sample1 = samples[minIndex - 1];
   float sample2 = samples[minIndex];
   float sample3 = samples[minIndex + 1];
  
   // Possibility -- implement logarithmic interpolation for large 2nd derivative?
   //
   float baselineCorr = (0.5 * (sample1 - sample0 + sample3 - sample2) -
             0.25 * (sample3 - sample1 + sample2 - sample0));
  
   if (minIndex % 2 != 0) baselineCorr =-baselineCorr;
  
   return baselineCorr;
 }

◆ PostPulse()

bool ZDCPulseAnalyzer::PostPulse ( ) const

inline

Definition at line 565 of file ZDCPulseAnalyzer.h.

565 {return m_postPulse;}

◆ preExpTail()

bool ZDCPulseAnalyzer::preExpTail ( ) const

inline

Definition at line 572 of file ZDCPulseAnalyzer.h.

572 {return m_preExpTail;}

◆ prepareLGRefit()

void ZDCPulseAnalyzer::prepareLGRefit	(	const std::vector< float > &	samplesLG,
		const std::vector< float > &	samplesSig,
		const std::vector< bool > &	useSamples
	)

private

Definition at line 1442 of file ZDCPulseAnalyzer.cxx.

 {
   m_samplesLGRefit.clear();
   m_samplesSigLGRefit.clear();
  
   float presampleLG = m_ADCSamplesLGSub[m_usedPresampIdx];
     
   // Do the presample subtraction
   //
   for (unsigned int idx = 0; idx < samplesLG.size(); idx++) {
     m_samplesLGRefit.push_back(samplesLG[idx] - presampleLG);
  
     if (useSamples[idx]) {
       m_samplesSigLGRefit.push_back(samplesSig[idx]);
     }
     else {
       m_samplesSigLGRefit.push_back(0);
     }
   }
 }

◆ PrePulse()

bool ZDCPulseAnalyzer::PrePulse ( ) const

inline

Definition at line 564 of file ZDCPulseAnalyzer.h.

564 {return m_prePulse;}

◆ PSHGOverUnderflow()

bool ZDCPulseAnalyzer::PSHGOverUnderflow ( ) const

inline

Definition at line 560 of file ZDCPulseAnalyzer.h.

560 {return m_PSHGOverUnderflow;}

◆ QuietFits()

static bool ZDCPulseAnalyzer::QuietFits ( )

inlinestatic

Definition at line 447 of file ZDCPulseAnalyzer.h.

447 {return s_quietFits;}

◆ ReanalyzeData()

bool ZDCPulseAnalyzer::ReanalyzeData ( )

Definition at line 733 of file ZDCPulseAnalyzer.cxx.

 {
   Reset(true);
  
   bool result = DoAnalysis(true);
   if (result && HavePulse()) {
     m_repassPulse = true;
   }
  
   return result;
 }

◆ repassPulse()

bool ZDCPulseAnalyzer::repassPulse ( ) const

inline

Definition at line 574 of file ZDCPulseAnalyzer.h.

574 {return m_repassPulse;}

◆ Reset()

void ZDCPulseAnalyzer::Reset ( bool reanalyze = false )

private

Definition at line 218 of file ZDCPulseAnalyzer.cxx.

 {
   if (!repass) {
     m_haveData  = false;
  
     m_useLowGain = false;
     m_fail       = false;
     m_HGOverflow = false;
  
     m_HGUnderflow       = false;
     m_PSHGOverUnderflow = false;
     m_LGOverflow        = false;
     m_LGUnderflow       = false;
  
     m_ExcludeEarly = false;
     m_ExcludeLate  = false;
  
     m_adjTimeRangeEvent = false;
     m_backToHG_pre      = false;
     m_fixPrePulse       = false;
  
     m_minADCLG = -1;
     m_maxADCLG = -1;
     m_minADCHG = -1;
     m_maxADCHG = -1;
     
     m_minADCSampleHG = -1;
     m_maxADCSampleHG = -1;
     m_minADCSampleLG = -1;
     m_maxADCSampleLG = -1;
  
     m_ADCPeakHG = -1;
     m_ADCPeakLG = -1;
     
     int sampleVecSize = m_Nsample;
     if (m_useDelayed) sampleVecSize *= 2;
  
     m_ADCSamplesHG.clear();
     m_ADCSamplesLG.clear();
     
     m_ADCSamplesHGSub.clear();
     m_ADCSamplesLGSub.clear();
  
     m_ADCSSampSigHG.assign(sampleVecSize, m_noiseSigHG);
     m_ADCSSampSigLG.assign(sampleVecSize, m_noiseSigLG); 
  
     m_minSampleEvt = 0;
     m_maxSampleEvt = (m_useDelayed ? 2 * m_Nsample - 1 : m_Nsample - 1);
  
     m_usedPresampIdx = 0;
  
     m_fitTMax = m_defaultFitTMax;
     m_fitTMin = m_defaultFitTMin;
  
     m_lastHGOverFlowSample  = -999;
     m_firstHGOverFlowSample = 999;
   }
  
   
   m_defaultT0Max = m_deltaTSample * (m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 0.5);
   m_defaultT0Min = m_deltaTSample * (m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance - 0.5);
  
   if (m_initializedFits) {
     m_defaultFitWrapper ->SetT0Range(m_defaultT0Min, m_defaultT0Max);
     m_prePulseFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
     m_preExpFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
   }
   
   // -----------------------
   // Statuses
   //
   m_havePulse  = false;
   
   m_prePulse  = false;
   m_postPulse = false;
   m_fitFailed = false;
   m_badChisq  = false;
  
   m_badT0        = false;
   m_preExpTail   = false;
   m_repassPulse = false;
  
   m_fitMinAmp = false;
   m_evtLGRefit = false;
   
  
   // -----------------------
  
   m_delayedBaselineShift = 0;
  
   m_fitAmplitude = 0;
   m_ampNoNonLin = 0;
   m_fitTime      = -100;
   m_fitTimeSub   = -100;
   m_fitTimeCorr  = -100;
   m_fitTCorr2nd  = -100;
  
   m_fitPreT0   = -100;
   m_fitPreAmp  = -100;
   m_fitPostT0  = -100;
   m_fitPostAmp = -100;
   m_fitExpAmp  = -100;
  
   m_minDeriv2ndSig = -10;
   m_preExpSig = -10;
   m_prePulseSig = -10;
  
   m_fitChisq = 0;
  
   m_amplitude       = 0;
   m_ampError        = 0;
   m_preSampleAmp    = 0;
   m_preAmplitude    = 0;
   m_postAmplitude   = 0;
   m_expAmplitude    = 0;
   m_bkgdMaxFraction = 0;
  
   m_refitLGAmpl = 0;
   m_refitLGAmpError = 0;
   m_refitLGChisq = 0;
   m_refitLGTime = -100;
   m_refitLGTimeSub = -100;
     
   m_initialPrePulseT0  = -10;
   m_initialPrePulseAmp = 5;
  
   m_initialPostPulseT0  = 100;
  
   m_initialExpAmp = 0;
   m_fitPostT0lo   = 0;
  
   m_fitPulls.clear();
   
   m_samplesSub.clear();
   m_samplesDeriv2nd.clear();
 }

◆ ScanAndSubtractSamples()

bool ZDCPulseAnalyzer::ScanAndSubtractSamples ( )

private

Definition at line 745 of file ZDCPulseAnalyzer.cxx.

 {
   //
   // Dump samples to verbose output
   //
   bool doDump = (*m_msgFunc_p)(ZDCMsg::Verbose, "Dumping all samples before subtraction: ");
   if (doDump) {
     std::ostringstream dumpStringHG;
     dumpStringHG << "HG: ";
     for (auto val : m_ADCSamplesHG) {
       dumpStringHG << std::setw(4) << val << " ";
     }
     
     (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringHG.str().c_str());
     
     
     // Now low gain
     //
     std::ostringstream dumpStringLG;
     dumpStringLG << "LG: " << std::setw(4) << std::setfill(' ');
     for (auto val : m_ADCSamplesLG) {
       dumpStringLG <<  std::setw(4) << val << " ";
     }
  
     (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringLG.str().c_str());
   }
   
   m_NSamplesAna = m_ADCSamplesHG.size();
  
   m_ADCSamplesHGSub.assign(m_NSamplesAna, 0);
   m_ADCSamplesLGSub.assign(m_NSamplesAna, 0);
  
   m_useSampleHG.assign(m_NSamplesAna, true);
   m_useSampleLG.assign(m_NSamplesAna, true);
  
   // Now do pedestal subtraction and check for overflows
   //
   m_minADCHG = m_HGOverflowADC;
   m_minADCLG = m_LGOverflowADC;
  
   m_maxADCHG = 0;
   m_maxADCLG = 0;
  
   for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
     float ADCHG = m_ADCSamplesHG[isample];
     float ADCLG = m_ADCSamplesLG[isample];
  
     //
     // We always pedestal subtract even if the sample isn't going to be used in analysis
     //  basically for diagnostics
     //
     m_ADCSamplesHGSub[isample] = ADCHG - m_pedestal;
     m_ADCSamplesLGSub[isample] = ADCLG - m_pedestal;
  
     if (ADCHG > m_maxADCHG) {
       m_maxADCHG = ADCHG;
       m_maxADCSampleHG = isample;
     }
     else if (ADCHG < m_minADCHG) {
       m_minADCHG = ADCHG;
       m_minADCSampleHG = isample;
     }
          
     if (ADCLG > m_maxADCLG) {
       m_maxADCLG = ADCLG;
       m_maxADCSampleLG = isample;
     }
     else if (ADCLG < m_minADCLG) {
       m_minADCLG = ADCLG;
       m_minADCSampleLG = isample;
     }
  
     if (m_useSampleHG[isample]) {
       if (m_enablePreExcl) {
     if (ADCHG > m_preExclHGADCThresh && isample < m_maxSamplesPreExcl) {
       m_useSampleHG[isample] = false;
       continue;
     }
       }
  
       if (m_enablePostExcl) {
     if (ADCHG > m_postExclHGADCThresh && isample >= m_NSamplesAna - m_maxSamplesPostExcl) {
       m_useSampleHG[isample] = false;
       continue;
     }
       }
  
       // If we get here, we've passed the above filters on the sample
       //
       if (ADCHG > m_HGOverflowADC) {
     m_HGOverflow = true;
     
     if (isample == m_preSampleIdx) m_PSHGOverUnderflow = true;
  
     // Note: the implementation of the explicit pre- and post- sample exclusion should make this
     //   code obselete but before removing it we first need to validate the pre- and post-exclusion
     //
     if ((int) isample > m_lastHGOverFlowSample)  m_lastHGOverFlowSample  = isample;
     if ((int) isample < m_firstHGOverFlowSample) m_firstHGOverFlowSample = isample;
       }
       else if (ADCHG < m_HGUnderflowADC) {
     m_HGUnderflow = true;
     
     if (isample == m_preSampleIdx) m_PSHGOverUnderflow  = true;
       }
     }
  
     // Now the low gain sample
     //
     if (m_useSampleLG[isample]) {
       if (m_enablePreExcl) {
     if (ADCLG > m_preExclLGADCThresh && isample <= m_maxSamplesPreExcl) {
       m_useSampleLG[isample] = false;
       continue;
     }
       }
       
       if (m_enablePostExcl) {
     if (ADCLG > m_postExclLGADCThresh && isample >= m_NSamplesAna - m_maxSamplesPostExcl) {
       m_useSampleLG[isample] = false;
       m_ExcludeLate = true;
       continue;
     }
       }
  
       if (ADCLG > m_LGOverflowADC) {
     m_LGOverflow = true;
     m_fail = true;
     m_amplitude = m_LGOverflowADC * m_gainFactorLG; // Give a vale here even though we know it's wrong because
     //   the user may not check the return value and we know that
     //   amplitude is bigger than this
       }
       
       if (ADCLG == 0) {
     m_LGUnderflow = true;
     m_fail = true;
       }
     }
   }
  
   if (doDump) {
     (*m_msgFunc_p)(ZDCMsg::Verbose, "Dump of useSamples: ");
     
     std::ostringstream dumpStringUseHG;
     dumpStringUseHG << "HG: ";
     for (auto val : m_useSampleHG) {
       dumpStringUseHG  << val << " ";
     }
     (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringUseHG.str().c_str());
     
     std::ostringstream dumpStringUseLG;
     dumpStringUseLG << "LG: ";
     for (auto val : m_useSampleLG) {
       dumpStringUseLG  << val << " ";
     }
     (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringUseLG.str().c_str());
   }
  
   // This ugly code should be obseleted by the introduction of the better, pre- and post-sample exclusion but
   //   that code still has to be fully validated.
   //
   // See if we can still use high gain even in the case of HG overflow if the overflow results from
   //   the first few samples or the last few samples
   //
   if (m_HGOverflow && !m_HGUnderflow) {
     if (m_lastHGOverFlowSample < 2 && m_lastHGOverFlowSample > -1) {
       m_HGOverflow = false;
       m_minSampleEvt = m_lastHGOverFlowSample + 1;
       m_adjTimeRangeEvent = true;
       m_backToHG_pre = true;
       m_ExcludeEarly = true;
     }
     else if (m_firstHGOverFlowSample < static_cast<int>(m_NSamplesAna) && m_firstHGOverFlowSample >= static_cast<int>(m_NSamplesAna - 2) ) {
       m_maxSampleEvt = m_firstHGOverFlowSample - 1;
       m_HGOverflow = false;
       m_adjTimeRangeEvent = true;
       m_ExcludeLate = true;
     }
   }
  
   (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + ": ScanAndSubtractSamples done");
  
   return true;
 }

◆ set2ndDerivStep()

void ZDCPulseAnalyzer::set2ndDerivStep ( size_t step )

inline

Definition at line 481 of file ZDCPulseAnalyzer.h.

481 {m_2ndDerivStep = step;}

◆ SetADCOverUnderflowValues()

void ZDCPulseAnalyzer::SetADCOverUnderflowValues	(	int	HGOverflowADC,
		int	HGUnderflowADC,
		int	LGOverflowADC
	)

Definition at line 402 of file ZDCPulseAnalyzer.cxx.

 {
   m_HGOverflowADC  = HGOverflowADC;
   m_LGOverflowADC  = LGOverflowADC;
   m_HGUnderflowADC = HGUnderflowADC;
 }

◆ SetCutValues()

void ZDCPulseAnalyzer::SetCutValues	(	float	chisqDivAmpCutHG,
		float	chisqDivAmpCutLG,
		float	deltaT0MinHG,
		float	deltaT0MaxHG,
		float	deltaT0MinLG,
		float	deltaT0MaxLG
	)

Definition at line 409 of file ZDCPulseAnalyzer.cxx.

 {
   m_chisqDivAmpCutHG = chisqDivAmpCutHG;
   m_chisqDivAmpCutLG = chisqDivAmpCutLG;
  
   m_T0CutLowHG = deltaT0MinHG;
   m_T0CutLowLG = deltaT0MinLG;
  
   m_T0CutHighHG = deltaT0MaxHG;
   m_T0CutHighLG = deltaT0MaxLG;
 }

◆ SetDefaults()

void ZDCPulseAnalyzer::SetDefaults ( )

private

Definition at line 151 of file ZDCPulseAnalyzer.cxx.

 {
   m_LGMode = LGModeNormal;
   
   m_nominalTau1 = 4;
   m_nominalTau2 = 21;
  
   m_fixTau1 = false;
   m_fixTau2 = false;
  
   m_HGOverflowADC  = 900;
   m_HGUnderflowADC = 20;
   m_LGOverflowADC  = 1000;
  
   // Default values for the gain factors uswed to match low and high gain
   //
   m_gainFactorLG = m_gainHG;
   m_gainFactorHG = 1;
  
   m_2ndDerivStep = 1;
  
   m_noiseSigHG = 1;
   m_noiseSigLG = 1;
  
   m_timeCutMode = 0;
   m_chisqDivAmpCutLG = 100;
   m_chisqDivAmpCutHG = 100;
  
   m_T0CutLowLG = m_tmin;
   m_T0CutLowHG = m_tmin;
  
   m_T0CutHighLG = m_tmax;
   m_T0CutHighHG = m_tmax;
  
   m_LGT0CorrParams.assign(4, 0);
   m_HGT0CorrParams.assign(4, 0);
  
   m_defaultFitTMax = m_tmax;
   m_defaultFitTMin = m_tmin;
   
   m_fitAmpMinHG = 1;
   m_fitAmpMinLG = 1;
  
   m_fitAmpMaxHG = 1500;
   m_fitAmpMaxLG = 1500;
  
   m_postPulse = false;
   m_prePulse = false;
  
   m_initialPrePulseT0  = -10;
   m_initialPrePulseAmp = 5;
  
   m_initialPostPulseT0  = 100;
  
   m_initialExpAmp = 0;
   m_fitPostT0lo   = 0;
  
   m_useDelayed = false;
   m_enablePreExcl = false;
   m_enablePostExcl = false;
   
   m_timingCorrMode = NoTimingCorr;
   m_haveNonlinCorr = false;
   
   m_fitOptions = "s";
 }

◆ SetFitMinMaxAmp()

void ZDCPulseAnalyzer::SetFitMinMaxAmp	(	float	minAmpHG,
		float	minAmpLG,
		float	maxAmpHG,
		float	maxAmpLG
	)

Definition at line 361 of file ZDCPulseAnalyzer.cxx.

 {
   m_fitAmpMinHG = minAmpHG;
   m_fitAmpMinLG = minAmpLG;
  
   m_fitAmpMaxHG = maxAmpHG;
   m_fitAmpMaxLG = maxAmpLG;
 }

◆ SetFitOPtions()

void ZDCPulseAnalyzer::SetFitOPtions ( const std::string & fitOptions )

inline

Definition at line 444 of file ZDCPulseAnalyzer.h.

444 { m_fitOptions = fitOptions;}

◆ SetFitTimeMax()

void ZDCPulseAnalyzer::SetFitTimeMax ( float tmax )

Definition at line 388 of file ZDCPulseAnalyzer.cxx.

 {
   if (tmax < m_tmin) {
     (*m_msgFunc_p)(ZDCMsg::Error, ("ZDCPulseAnalyzer::SetFitTimeMax:: invalid FitTimeMax: " + std::to_string(tmax)));
     return;
   }
  
   m_defaultFitTMax = std::min(tmax, m_defaultFitTMax);
  
   (*m_msgFunc_p)(ZDCMsg::Verbose, ("Setting FitTMax to " + std::to_string(m_defaultFitTMax)));
  
   if (m_initializedFits) SetupFitFunctions();
 }

◆ SetGainFactorsHGLG()

void ZDCPulseAnalyzer::SetGainFactorsHGLG	(	float	gainFactorHG,
		float	gainFactorLG
	)

Definition at line 355 of file ZDCPulseAnalyzer.cxx.

 {
   m_gainFactorHG = gainFactorHG;
   m_gainFactorLG = gainFactorLG;
 }

◆ setLGMode()

void ZDCPulseAnalyzer::setLGMode ( unsigned int mode )

inline

Definition at line 478 of file ZDCPulseAnalyzer.h.

478 {m_LGMode = mode;}

◆ SetNoiseSigmas()

void ZDCPulseAnalyzer::SetNoiseSigmas	(	float	noiseSigHG,
		float	noiseSigLG
	)

inline

Definition at line 487 of file ZDCPulseAnalyzer.h.

   {
     m_noiseSigHG = noiseSigHG;
     m_noiseSigLG = noiseSigLG;
   }

◆ SetNonlinCorrParams()

void ZDCPulseAnalyzer::SetNonlinCorrParams	(	float	refADC,
		float	refScale,
		const std::vector< float > &	paramsHG,
		const std::vector< float > &	paramsLG
	)

inline

Definition at line 516 of file ZDCPulseAnalyzer.h.

   {
     std::string HGParamsStr = "HG coefficients = ", LGParamsStr = "LG coefficients = ";
  
     for (auto val : paramsHG) {HGParamsStr += std::to_string(val) + " ";}
     for (auto val : paramsLG) {LGParamsStr += std::to_string(val) + " ";}
     
     (*m_msgFunc_p)(ZDCMsg::Info, ("Setting non-linear parameters for module: " + m_tag + ", reference ADC = " +
                   std::to_string(refADC) + ", reference scale = " + std::to_string(refScale)));
  
     (*m_msgFunc_p)(ZDCMsg::Info, HGParamsStr);
     (*m_msgFunc_p)(ZDCMsg::Info, LGParamsStr);
  
     m_nonLinCorrRefADC = refADC;
     m_nonLinCorrRefScale = refScale;
     m_nonLinCorrParamsHG = paramsHG;
     m_nonLinCorrParamsLG = paramsLG;
     m_haveNonlinCorr = true;
   }

◆ SetPeak2ndDerivMinTolerance()

void ZDCPulseAnalyzer::SetPeak2ndDerivMinTolerance ( size_t tolerance )

inline

Definition at line 473 of file ZDCPulseAnalyzer.h.

                                                      {
     m_peak2ndDerivMinTolerance = tolerance;
     m_initializedFits = false;
   }

◆ SetQuietFits()

static void ZDCPulseAnalyzer::SetQuietFits ( bool quiet )

inlinestatic

Definition at line 445 of file ZDCPulseAnalyzer.h.

445 {s_quietFits = quiet;}

◆ SetSaveFitFunc()

static void ZDCPulseAnalyzer::SetSaveFitFunc ( bool save )

inlinestatic

Definition at line 446 of file ZDCPulseAnalyzer.h.

446 {s_saveFitFunc = save;}

◆ SetTauT0Values()

void ZDCPulseAnalyzer::SetTauT0Values	(	bool	fixTau1,
		bool	fixTau2,
		float	tau1,
		float	tau2,
		float	t0HG,
		float	t0LG
	)

Definition at line 370 of file ZDCPulseAnalyzer.cxx.

 {
   m_fixTau1     = fixTau1;
   m_fixTau2     = fixTau2;
   m_nominalTau1 = tau1;
   m_nominalTau2 = tau2;
  
   m_nominalT0HG = t0HG;
   m_nominalT0LG = t0LG;
  
   std::ostringstream ostrm;
   ostrm << "ZDCPulseAnalyzer::SetTauT0Values:: m_fixTau1=" << m_fixTau1 << "  m_fixTau2=" << m_fixTau2 << "  m_nominalTau1=" << m_nominalTau1 << "  m_nominalTau2=" << m_nominalTau2 << "  m_nominalT0HG=" << m_nominalT0HG << "  m_nominalT0LG=" << m_nominalT0LG;
  
   (*m_msgFunc_p)(ZDCMsg::Info, ostrm.str());
  
   m_initializedFits = false;
 }

◆ SetTimingCorrParams()

void ZDCPulseAnalyzer::SetTimingCorrParams	(	TimingCorrMode	mode,
		float	refADC,
		float	refScale,
		const std::vector< float > &	HGT0CorrParams,
		const std::vector< float > &	LGT0CorrParams
	)

inline

Definition at line 501 of file ZDCPulseAnalyzer.h.

   {
     m_timingCorrMode = mode;
     if (mode != NoTimingCorr) {
       m_timingCorrRefADC = refADC;
       m_timingCorrScale = refScale;
  
       m_HGT0CorrParams = HGT0CorrParams;
       m_LGT0CorrParams = LGT0CorrParams;
     }
   }

◆ SetupFitFunctions()

void ZDCPulseAnalyzer::SetupFitFunctions ( )

private

Definition at line 563 of file ZDCPulseAnalyzer.cxx.

 {
   float prePulseTMin = 0;
   float prePulseTMax = prePulseTMin + m_deltaTSample * (m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance);
  
   if (m_fitFunction == "FermiExp") {
     if (!m_fixTau1 || !m_fixTau2) {
       //
       // Use the variable tau version of the expFermiFit
       //
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
     }
     else {
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
     }
  
     m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, m_nominalTau2, false));
     m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else if (m_fitFunction == "FermiExpRun3") {
     if (!m_fixTau1 || !m_fixTau2) {
       //
       // Use the variable tau version of the expFermiFit
       //
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTausRun3(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
     }
     else {
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
     }
  
     m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
     m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else if (m_fitFunction == "FermiExpLHCf") {
     //
     // Use the variable tau version of the expFermiFit
     //
     m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTausLHCf(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2,
                                                   m_nominalTau1, m_nominalTau2));
  
     m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiLHCfPreExp>(new ZDCFitExpFermiLHCfPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
     
     m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiLHCfPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else if (m_fitFunction == "FermiExpLinear") {
     if (!m_fixTau1 || !m_fixTau2) {
       //
       // Use the variable tau version of the expFermiFit
       //
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
     }
     else {
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
     }
  
     m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
     m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiLinearPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else if (m_fitFunction == "ComplexPrePulse") {
     if (!m_fixTau1 || !m_fixTau2) {
       //
       // Use the variable tau version of the expFermiFit
       //
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
     }
     else {
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
     }
  
     m_prePulseFitWrapper  = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitComplexPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else if (m_fitFunction == "GeneralPulse") {
     if (!m_fixTau1 || !m_fixTau2) {
       //
       // Use the variable tau version of the expFermiFit
       //
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
     }
     else {
       m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
     }
  
     m_prePulseFitWrapper  = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitGeneralPulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
   }
   else {
     (*m_msgFunc_p)(ZDCMsg::Fatal, "Wrong fit function type: " + m_fitFunction);
   }
  
   m_prePulseFitWrapper->SetPrePulseT0Range(prePulseTMin, prePulseTMax);
   
   m_initializedFits = true;
 }

◆ UpdateFitterTimeLimits()

void ZDCPulseAnalyzer::UpdateFitterTimeLimits	(	TFitter *	fitter,
		ZDCFitWrapper *	wrapper,
		bool	prePulse
	)

private

Definition at line 1939 of file ZDCPulseAnalyzer.cxx.

 {
   double parLimitLow, parLimitHigh;
  
   auto func_p = wrapper->GetWrapperTF1();
   func_p->GetParLimits(1, parLimitLow, parLimitHigh);
  
   fitter->SetParameter(2, func_p->GetParName(1), func_p->GetParameter(1), 0.01, parLimitLow, parLimitHigh);
  
   if (prePulse) {
     unsigned int parIndex = static_cast<ZDCPrePulseFitWrapper*>(wrapper)->GetPreT0ParIndex();
  
     func_p->GetParLimits(parIndex, parLimitLow, parLimitHigh);
     fitter->SetParameter(parIndex + 1, func_p->GetParName(parIndex), func_p->GetParameter(parIndex), 0.01, parLimitLow, parLimitHigh);
   }
 }

◆ UseLowGain()

bool ZDCPulseAnalyzer::UseLowGain ( ) const

inline

Definition at line 555 of file ZDCPulseAnalyzer.h.

555 {return m_useLowGain;}

Member Data Documentation

◆ m_2ndDerivStep

size_t ZDCPulseAnalyzer::m_2ndDerivStep {1}

private

Definition at line 89 of file ZDCPulseAnalyzer.h.

◆ m_ADCPeakHG

float ZDCPulseAnalyzer::m_ADCPeakHG {}

private

Definition at line 263 of file ZDCPulseAnalyzer.h.

◆ m_ADCPeakLG

float ZDCPulseAnalyzer::m_ADCPeakLG {}

private

Definition at line 264 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHG

private

Definition at line 326 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesHGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHGSub

private

Definition at line 328 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLG

private

Definition at line 327 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesLGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLGSub

private

Definition at line 329 of file ZDCPulseAnalyzer.h.

◆ m_ADCSSampSigHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigHG

private

Definition at line 334 of file ZDCPulseAnalyzer.h.

◆ m_ADCSSampSigLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigLG

private

Definition at line 335 of file ZDCPulseAnalyzer.h.

◆ m_adjTimeRangeEvent

bool ZDCPulseAnalyzer::m_adjTimeRangeEvent {}

private

Definition at line 195 of file ZDCPulseAnalyzer.h.

◆ m_ampError

float ZDCPulseAnalyzer::m_ampError {}

private

Definition at line 305 of file ZDCPulseAnalyzer.h.

◆ m_amplitude

float ZDCPulseAnalyzer::m_amplitude {}

private

Definition at line 303 of file ZDCPulseAnalyzer.h.

◆ m_ampNoNonLin

float ZDCPulseAnalyzer::m_ampNoNonLin {}

private

Definition at line 304 of file ZDCPulseAnalyzer.h.

◆ m_backToHG_pre

bool ZDCPulseAnalyzer::m_backToHG_pre {}

private

Definition at line 245 of file ZDCPulseAnalyzer.h.

◆ m_badChisq

bool ZDCPulseAnalyzer::m_badChisq {}

private

Definition at line 232 of file ZDCPulseAnalyzer.h.

◆ m_badT0

bool ZDCPulseAnalyzer::m_badT0 {}

private

Definition at line 234 of file ZDCPulseAnalyzer.h.

◆ m_baselineCorr

float ZDCPulseAnalyzer::m_baselineCorr {}

private

Definition at line 246 of file ZDCPulseAnalyzer.h.

◆ m_bkgdMaxFraction

float ZDCPulseAnalyzer::m_bkgdMaxFraction {}

private

Definition at line 310 of file ZDCPulseAnalyzer.h.

◆ m_chisqDivAmpCutHG

float ZDCPulseAnalyzer::m_chisqDivAmpCutHG {}

private

Definition at line 131 of file ZDCPulseAnalyzer.h.

◆ m_chisqDivAmpCutLG

float ZDCPulseAnalyzer::m_chisqDivAmpCutLG {}

private

Definition at line 130 of file ZDCPulseAnalyzer.h.

◆ m_defaultCombinedFitter

std::unique_ptr<TFitter> ZDCPulseAnalyzer::m_defaultCombinedFitter

private

Definition at line 209 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitTMax

float ZDCPulseAnalyzer::m_defaultFitTMax {}

private

Definition at line 127 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitTMin

float ZDCPulseAnalyzer::m_defaultFitTMin {}

private

Definition at line 128 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitWrapper

std::unique_ptr<ZDCFitWrapper> ZDCPulseAnalyzer::m_defaultFitWrapper

private

Definition at line 189 of file ZDCPulseAnalyzer.h.

◆ m_defaultT0Max

float ZDCPulseAnalyzer::m_defaultT0Max {}

private

Definition at line 144 of file ZDCPulseAnalyzer.h.

◆ m_defaultT0Min

float ZDCPulseAnalyzer::m_defaultT0Min {}

private

Definition at line 145 of file ZDCPulseAnalyzer.h.

◆ m_delayedBaselineShift

float ZDCPulseAnalyzer::m_delayedBaselineShift {}

private

Definition at line 311 of file ZDCPulseAnalyzer.h.

◆ m_delayedDeltaT

float ZDCPulseAnalyzer::m_delayedDeltaT {}

private

Definition at line 203 of file ZDCPulseAnalyzer.h.

◆ m_delayedHist

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_delayedHist

mutableprivate

Definition at line 205 of file ZDCPulseAnalyzer.h.

◆ m_delayedHistLGRefit

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_delayedHistLGRefit

mutableprivate

Definition at line 206 of file ZDCPulseAnalyzer.h.

◆ m_delayedPedestalDiff

float ZDCPulseAnalyzer::m_delayedPedestalDiff {}

private

Definition at line 204 of file ZDCPulseAnalyzer.h.

◆ m_deltaTSample

float ZDCPulseAnalyzer::m_deltaTSample {}

private

Definition at line 81 of file ZDCPulseAnalyzer.h.

◆ m_enablePostExcl

bool ZDCPulseAnalyzer::m_enablePostExcl {false}

private

Definition at line 160 of file ZDCPulseAnalyzer.h.

◆ m_enablePreExcl

bool ZDCPulseAnalyzer::m_enablePreExcl {false}

private

Definition at line 155 of file ZDCPulseAnalyzer.h.

◆ m_enableRepass

bool ZDCPulseAnalyzer::m_enableRepass {false}

private

Definition at line 97 of file ZDCPulseAnalyzer.h.

◆ m_evtLGRefit

bool ZDCPulseAnalyzer::m_evtLGRefit {false}

private

Definition at line 313 of file ZDCPulseAnalyzer.h.

◆ m_ExcludeEarly

bool ZDCPulseAnalyzer::m_ExcludeEarly {}

private

Definition at line 235 of file ZDCPulseAnalyzer.h.

◆ m_ExcludeLate

bool ZDCPulseAnalyzer::m_ExcludeLate {}

private

Definition at line 236 of file ZDCPulseAnalyzer.h.

◆ m_expAmplitude

float ZDCPulseAnalyzer::m_expAmplitude {}

private

Definition at line 309 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrHG

std::unique_ptr<const TH1> ZDCPulseAnalyzer::m_FADCCorrHG {}

private

Definition at line 180 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrLG

std::unique_ptr<const TH1> ZDCPulseAnalyzer::m_FADCCorrLG {}

private

Definition at line 181 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrPerSample

bool ZDCPulseAnalyzer::m_FADCCorrPerSample {false}

private

Definition at line 179 of file ZDCPulseAnalyzer.h.

◆ m_fail

bool ZDCPulseAnalyzer::m_fail {}

private

Definition at line 221 of file ZDCPulseAnalyzer.h.

◆ m_firstHGOverFlowSample

int ZDCPulseAnalyzer::m_firstHGOverFlowSample {-1}

private

Definition at line 323 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpError

float ZDCPulseAnalyzer::m_fitAmpError {}

private

Definition at line 288 of file ZDCPulseAnalyzer.h.

◆ m_fitAmplitude

float ZDCPulseAnalyzer::m_fitAmplitude {}

private

Definition at line 287 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMaxHG

float ZDCPulseAnalyzer::m_fitAmpMaxHG {}

private

Definition at line 150 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMaxLG

float ZDCPulseAnalyzer::m_fitAmpMaxLG {}

private

Definition at line 151 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMinHG

float ZDCPulseAnalyzer::m_fitAmpMinHG {}

private

Definition at line 147 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMinLG

float ZDCPulseAnalyzer::m_fitAmpMinLG {}

private

Definition at line 148 of file ZDCPulseAnalyzer.h.

◆ m_fitChisq

float ZDCPulseAnalyzer::m_fitChisq {}

private

Definition at line 296 of file ZDCPulseAnalyzer.h.

◆ m_fitExpAmp

float ZDCPulseAnalyzer::m_fitExpAmp {}

private

Definition at line 302 of file ZDCPulseAnalyzer.h.

◆ m_fitFailed

bool ZDCPulseAnalyzer::m_fitFailed {}

private

Definition at line 231 of file ZDCPulseAnalyzer.h.

◆ m_fitFunction

std::string ZDCPulseAnalyzer::m_fitFunction

private

Definition at line 88 of file ZDCPulseAnalyzer.h.

◆ m_fitHist

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_fitHist

mutableprivate

Definition at line 185 of file ZDCPulseAnalyzer.h.

◆ m_fitHistLGRefit

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_fitHistLGRefit

mutableprivate

Definition at line 186 of file ZDCPulseAnalyzer.h.

◆ m_fitMinAmp

bool ZDCPulseAnalyzer::m_fitMinAmp {}

private

Definition at line 240 of file ZDCPulseAnalyzer.h.

◆ m_fitNDoF

float ZDCPulseAnalyzer::m_fitNDoF {}

private

Definition at line 297 of file ZDCPulseAnalyzer.h.

◆ m_fitOptions

std::string ZDCPulseAnalyzer::m_fitOptions

private

Definition at line 113 of file ZDCPulseAnalyzer.h.

◆ m_fitPostAmp

float ZDCPulseAnalyzer::m_fitPostAmp {}

private

Definition at line 301 of file ZDCPulseAnalyzer.h.

◆ m_fitPostT0

float ZDCPulseAnalyzer::m_fitPostT0 {}

private

Definition at line 300 of file ZDCPulseAnalyzer.h.

◆ m_fitPostT0lo

float ZDCPulseAnalyzer::m_fitPostT0lo {}

private

Definition at line 276 of file ZDCPulseAnalyzer.h.

◆ m_fitPreAmp

float ZDCPulseAnalyzer::m_fitPreAmp {}

private

Definition at line 299 of file ZDCPulseAnalyzer.h.

◆ m_fitPreT0

float ZDCPulseAnalyzer::m_fitPreT0 {}

private

Definition at line 298 of file ZDCPulseAnalyzer.h.

◆ m_fitPulls

std::vector<float> ZDCPulseAnalyzer::m_fitPulls

private

Definition at line 350 of file ZDCPulseAnalyzer.h.

◆ m_fitTau1

float ZDCPulseAnalyzer::m_fitTau1 {}

private

Definition at line 294 of file ZDCPulseAnalyzer.h.

◆ m_fitTau2

float ZDCPulseAnalyzer::m_fitTau2 {}

private

Definition at line 295 of file ZDCPulseAnalyzer.h.

◆ m_fitTCorr2nd

float ZDCPulseAnalyzer::m_fitTCorr2nd {}

private

Definition at line 293 of file ZDCPulseAnalyzer.h.

◆ m_fitTime

float ZDCPulseAnalyzer::m_fitTime {}

private

Definition at line 289 of file ZDCPulseAnalyzer.h.

◆ m_fitTimeCorr

float ZDCPulseAnalyzer::m_fitTimeCorr {}

private

Definition at line 291 of file ZDCPulseAnalyzer.h.

◆ m_fitTimeSub

float ZDCPulseAnalyzer::m_fitTimeSub {}

private

Definition at line 290 of file ZDCPulseAnalyzer.h.

◆ m_fitTMax

float ZDCPulseAnalyzer::m_fitTMax {}

private

Definition at line 273 of file ZDCPulseAnalyzer.h.

◆ m_fitTMin

float ZDCPulseAnalyzer::m_fitTMin {}

private

Definition at line 274 of file ZDCPulseAnalyzer.h.

◆ m_fixPrePulse

bool ZDCPulseAnalyzer::m_fixPrePulse {}

private

Definition at line 239 of file ZDCPulseAnalyzer.h.

◆ m_fixTau1

bool ZDCPulseAnalyzer::m_fixTau1 {}

private

Definition at line 124 of file ZDCPulseAnalyzer.h.

◆ m_fixTau2

bool ZDCPulseAnalyzer::m_fixTau2 {}

private

Definition at line 125 of file ZDCPulseAnalyzer.h.

◆ m_gainFactorHG

float ZDCPulseAnalyzer::m_gainFactorHG {}

private

Definition at line 103 of file ZDCPulseAnalyzer.h.

◆ m_gainFactorLG

float ZDCPulseAnalyzer::m_gainFactorLG {}

private

Definition at line 104 of file ZDCPulseAnalyzer.h.

◆ m_gainHG

float ZDCPulseAnalyzer::m_gainHG {}

private

Definition at line 83 of file ZDCPulseAnalyzer.h.

◆ m_haveData

bool ZDCPulseAnalyzer::m_haveData {}

private

Definition at line 217 of file ZDCPulseAnalyzer.h.

◆ m_haveFADCCorrections

bool ZDCPulseAnalyzer::m_haveFADCCorrections {false}

private

Definition at line 178 of file ZDCPulseAnalyzer.h.

◆ m_haveNonlinCorr

bool ZDCPulseAnalyzer::m_haveNonlinCorr {false}

private

Definition at line 172 of file ZDCPulseAnalyzer.h.

◆ m_havePulse

bool ZDCPulseAnalyzer::m_havePulse {}

private

Definition at line 219 of file ZDCPulseAnalyzer.h.

◆ m_HGOverflow

bool ZDCPulseAnalyzer::m_HGOverflow {}

private

Definition at line 222 of file ZDCPulseAnalyzer.h.

◆ m_HGOverflowADC

int ZDCPulseAnalyzer::m_HGOverflowADC {}

private

Definition at line 114 of file ZDCPulseAnalyzer.h.

◆ m_HGT0CorrParams

std::vector<float> ZDCPulseAnalyzer::m_HGT0CorrParams

private

Definition at line 170 of file ZDCPulseAnalyzer.h.

◆ m_HGUnderflow

bool ZDCPulseAnalyzer::m_HGUnderflow {}

private

Definition at line 224 of file ZDCPulseAnalyzer.h.

◆ m_HGUnderflowADC

int ZDCPulseAnalyzer::m_HGUnderflowADC {}

private

Definition at line 115 of file ZDCPulseAnalyzer.h.

◆ m_initialExpAmp

float ZDCPulseAnalyzer::m_initialExpAmp {}

private

Definition at line 269 of file ZDCPulseAnalyzer.h.

◆ m_initializedFits

bool ZDCPulseAnalyzer::m_initializedFits {false}

private

Definition at line 188 of file ZDCPulseAnalyzer.h.

◆ m_initialPostPulseT0

float ZDCPulseAnalyzer::m_initialPostPulseT0 {}

private

Definition at line 285 of file ZDCPulseAnalyzer.h.

◆ m_initialPrePulseAmp

float ZDCPulseAnalyzer::m_initialPrePulseAmp {}

private

Definition at line 283 of file ZDCPulseAnalyzer.h.

◆ m_initialPrePulseT0

float ZDCPulseAnalyzer::m_initialPrePulseT0 {}

private

Definition at line 282 of file ZDCPulseAnalyzer.h.

◆ m_lastHGOverFlowSample

int ZDCPulseAnalyzer::m_lastHGOverFlowSample {-1}

private

Definition at line 322 of file ZDCPulseAnalyzer.h.

◆ m_LGMode

unsigned int ZDCPulseAnalyzer::m_LGMode {LGModeNormal}

private

Definition at line 84 of file ZDCPulseAnalyzer.h.

◆ m_LGOverflow

bool ZDCPulseAnalyzer::m_LGOverflow {}

private

Definition at line 226 of file ZDCPulseAnalyzer.h.

◆ m_LGOverflowADC

int ZDCPulseAnalyzer::m_LGOverflowADC {}

private

Definition at line 116 of file ZDCPulseAnalyzer.h.

◆ m_LGT0CorrParams

std::vector<float> ZDCPulseAnalyzer::m_LGT0CorrParams

private

Definition at line 169 of file ZDCPulseAnalyzer.h.

◆ m_LGUnderflow

bool ZDCPulseAnalyzer::m_LGUnderflow {}

private

Definition at line 227 of file ZDCPulseAnalyzer.h.

◆ m_maxADCHG

float ZDCPulseAnalyzer::m_maxADCHG {}

private

Definition at line 254 of file ZDCPulseAnalyzer.h.

◆ m_maxADCLG

float ZDCPulseAnalyzer::m_maxADCLG {}

private

Definition at line 258 of file ZDCPulseAnalyzer.h.

◆ m_maxADCSampleHG

int ZDCPulseAnalyzer::m_maxADCSampleHG

private

Definition at line 256 of file ZDCPulseAnalyzer.h.

◆ m_maxADCSampleLG

int ZDCPulseAnalyzer::m_maxADCSampleLG

private

Definition at line 261 of file ZDCPulseAnalyzer.h.

◆ m_maxDelta

float ZDCPulseAnalyzer::m_maxDelta {}

private

Definition at line 266 of file ZDCPulseAnalyzer.h.

◆ m_maxSampleEvt

unsigned int ZDCPulseAnalyzer::m_maxSampleEvt {}

private

Definition at line 198 of file ZDCPulseAnalyzer.h.

◆ m_maxSamplesPostExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPostExcl {0}

private

Definition at line 163 of file ZDCPulseAnalyzer.h.

◆ m_maxSamplesPreExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPreExcl {0}

private

Definition at line 156 of file ZDCPulseAnalyzer.h.

◆ m_minADCHG

float ZDCPulseAnalyzer::m_minADCHG {}

private

Definition at line 253 of file ZDCPulseAnalyzer.h.

◆ m_minADCLG

float ZDCPulseAnalyzer::m_minADCLG {}

private

Definition at line 259 of file ZDCPulseAnalyzer.h.

◆ m_minADCSampleHG

int ZDCPulseAnalyzer::m_minADCSampleHG

private

Definition at line 255 of file ZDCPulseAnalyzer.h.

◆ m_minADCSampleLG

int ZDCPulseAnalyzer::m_minADCSampleLG

private

Definition at line 260 of file ZDCPulseAnalyzer.h.

◆ m_minDelta

float ZDCPulseAnalyzer::m_minDelta {}

private

Definition at line 267 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2nd

float ZDCPulseAnalyzer::m_minDeriv2nd {}

private

Definition at line 270 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2ndIndex

int ZDCPulseAnalyzer::m_minDeriv2ndIndex {}

private

Definition at line 271 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2ndSig

float ZDCPulseAnalyzer::m_minDeriv2ndSig

private

Definition at line 278 of file ZDCPulseAnalyzer.h.

◆ m_minSampleEvt

unsigned int ZDCPulseAnalyzer::m_minSampleEvt {}

private

Definition at line 197 of file ZDCPulseAnalyzer.h.

◆ m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCPulseAnalyzer::m_msgFunc_p {}

private

Definition at line 77 of file ZDCPulseAnalyzer.h.

◆ m_noiseSigHG

float ZDCPulseAnalyzer::m_noiseSigHG {}

private

Definition at line 108 of file ZDCPulseAnalyzer.h.

◆ m_noiseSigLG

float ZDCPulseAnalyzer::m_noiseSigLG {}

private

Definition at line 109 of file ZDCPulseAnalyzer.h.

◆ m_nominalT0HG

float ZDCPulseAnalyzer::m_nominalT0HG {}

private

Definition at line 118 of file ZDCPulseAnalyzer.h.

◆ m_nominalT0LG

float ZDCPulseAnalyzer::m_nominalT0LG {}

private

Definition at line 119 of file ZDCPulseAnalyzer.h.

◆ m_nominalTau1

float ZDCPulseAnalyzer::m_nominalTau1 {}

private

Definition at line 121 of file ZDCPulseAnalyzer.h.

◆ m_nominalTau2

float ZDCPulseAnalyzer::m_nominalTau2 {}

private

Definition at line 122 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrParamsHG

std::vector<float> ZDCPulseAnalyzer::m_nonLinCorrParamsHG

private

Definition at line 175 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrParamsLG

std::vector<float> ZDCPulseAnalyzer::m_nonLinCorrParamsLG

private

Definition at line 176 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrRefADC

float ZDCPulseAnalyzer::m_nonLinCorrRefADC {500}

private

Definition at line 173 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrRefScale

float ZDCPulseAnalyzer::m_nonLinCorrRefScale {100}

private

Definition at line 174 of file ZDCPulseAnalyzer.h.

◆ m_Nsample

unsigned int ZDCPulseAnalyzer::m_Nsample {}

private

Definition at line 79 of file ZDCPulseAnalyzer.h.

◆ m_NSamplesAna

unsigned int ZDCPulseAnalyzer::m_NSamplesAna {0}

private

Definition at line 325 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinRepassHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassHG {}

private

Definition at line 99 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinRepassLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassLG {}

private

Definition at line 98 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinSample

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinSample {}

private

Definition at line 90 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinThreshHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshHG {}

private

Definition at line 93 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinThreshLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshLG {}

private

Definition at line 92 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinTolerance

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinTolerance {1}

private

Definition at line 91 of file ZDCPulseAnalyzer.h.

◆ m_pedestal

int ZDCPulseAnalyzer::m_pedestal {}

private

Definition at line 82 of file ZDCPulseAnalyzer.h.

◆ m_postAmplitude

float ZDCPulseAnalyzer::m_postAmplitude {}

private

Definition at line 308 of file ZDCPulseAnalyzer.h.

◆ m_postExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclHGADCThresh {0}

private

Definition at line 161 of file ZDCPulseAnalyzer.h.

◆ m_postExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclLGADCThresh {0}

private

Definition at line 162 of file ZDCPulseAnalyzer.h.

◆ m_postPulse

bool ZDCPulseAnalyzer::m_postPulse {}

private

Definition at line 230 of file ZDCPulseAnalyzer.h.

◆ m_preAmplitude

float ZDCPulseAnalyzer::m_preAmplitude {}

private

Definition at line 307 of file ZDCPulseAnalyzer.h.

◆ m_preExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclHGADCThresh {0}

private

Definition at line 157 of file ZDCPulseAnalyzer.h.

◆ m_preExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclLGADCThresh {0}

private

Definition at line 158 of file ZDCPulseAnalyzer.h.

◆ m_preExpFitWrapper

std::unique_ptr<ZDCPreExpFitWrapper> ZDCPulseAnalyzer::m_preExpFitWrapper

private

Definition at line 191 of file ZDCPulseAnalyzer.h.

◆ m_preExpSig

float ZDCPulseAnalyzer::m_preExpSig

private

Definition at line 279 of file ZDCPulseAnalyzer.h.

◆ m_preExpTail

bool ZDCPulseAnalyzer::m_preExpTail {}

private

Definition at line 237 of file ZDCPulseAnalyzer.h.

◆ m_prePulse

bool ZDCPulseAnalyzer::m_prePulse {}

private

Definition at line 229 of file ZDCPulseAnalyzer.h.

◆ m_prePulseCombinedFitter

std::unique_ptr<TFitter> ZDCPulseAnalyzer::m_prePulseCombinedFitter

private

Definition at line 208 of file ZDCPulseAnalyzer.h.

◆ m_prePulseFitWrapper

std::unique_ptr<ZDCPrePulseFitWrapper> ZDCPulseAnalyzer::m_prePulseFitWrapper

private

Definition at line 190 of file ZDCPulseAnalyzer.h.

◆ m_prePulseSig

float ZDCPulseAnalyzer::m_prePulseSig

private

Definition at line 280 of file ZDCPulseAnalyzer.h.

◆ m_preSample

float ZDCPulseAnalyzer::m_preSample {}

private

Definition at line 251 of file ZDCPulseAnalyzer.h.

◆ m_preSampleAmp

float ZDCPulseAnalyzer::m_preSampleAmp {}

private

Definition at line 306 of file ZDCPulseAnalyzer.h.

◆ m_preSampleIdx

unsigned int ZDCPulseAnalyzer::m_preSampleIdx {}

private

Definition at line 80 of file ZDCPulseAnalyzer.h.

◆ m_PSHGOverUnderflow

bool ZDCPulseAnalyzer::m_PSHGOverUnderflow {}

private

Definition at line 225 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmpError

float ZDCPulseAnalyzer::m_refitLGAmpError {0}

private

Definition at line 317 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmpl

float ZDCPulseAnalyzer::m_refitLGAmpl {0}

private

Definition at line 314 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmplCorr

float ZDCPulseAnalyzer::m_refitLGAmplCorr {0}

private

Definition at line 316 of file ZDCPulseAnalyzer.h.

◆ m_refitLGChisq

float ZDCPulseAnalyzer::m_refitLGChisq {0}

private

Definition at line 318 of file ZDCPulseAnalyzer.h.

◆ m_refitLGFitAmpl

float ZDCPulseAnalyzer::m_refitLGFitAmpl {0}

private

Definition at line 315 of file ZDCPulseAnalyzer.h.

◆ m_refitLGTime

float ZDCPulseAnalyzer::m_refitLGTime {0}

private

Definition at line 319 of file ZDCPulseAnalyzer.h.

◆ m_refitLGTimeSub

float ZDCPulseAnalyzer::m_refitLGTimeSub {0}

private

Definition at line 320 of file ZDCPulseAnalyzer.h.

◆ m_repassPulse

bool ZDCPulseAnalyzer::m_repassPulse {}

private

Definition at line 241 of file ZDCPulseAnalyzer.h.

◆ m_samplesDeriv2nd

std::vector<float> ZDCPulseAnalyzer::m_samplesDeriv2nd

private

Definition at line 343 of file ZDCPulseAnalyzer.h.

◆ m_samplesLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesLGRefit

private

Definition at line 340 of file ZDCPulseAnalyzer.h.

◆ m_samplesSig

std::vector<float> ZDCPulseAnalyzer::m_samplesSig

private

Definition at line 338 of file ZDCPulseAnalyzer.h.

◆ m_samplesSigLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesSigLGRefit

private

Definition at line 341 of file ZDCPulseAnalyzer.h.

◆ m_samplesSub

std::vector<float> ZDCPulseAnalyzer::m_samplesSub

private

Definition at line 337 of file ZDCPulseAnalyzer.h.

◆ m_T0CutHighHG

float ZDCPulseAnalyzer::m_T0CutHighHG {}

private

Definition at line 137 of file ZDCPulseAnalyzer.h.

◆ m_T0CutHighLG

float ZDCPulseAnalyzer::m_T0CutHighLG {}

private

Definition at line 134 of file ZDCPulseAnalyzer.h.

◆ m_T0CutLowHG

float ZDCPulseAnalyzer::m_T0CutLowHG {}

private

Definition at line 136 of file ZDCPulseAnalyzer.h.

◆ m_T0CutLowLG

float ZDCPulseAnalyzer::m_T0CutLowLG {}

private

Definition at line 133 of file ZDCPulseAnalyzer.h.

◆ m_t0CutSig

float ZDCPulseAnalyzer::m_t0CutSig {}

private

Definition at line 141 of file ZDCPulseAnalyzer.h.

◆ m_tag

std::string ZDCPulseAnalyzer::m_tag

private

Definition at line 78 of file ZDCPulseAnalyzer.h.

◆ m_timeCutMode

unsigned int ZDCPulseAnalyzer::m_timeCutMode {0}

private

Definition at line 142 of file ZDCPulseAnalyzer.h.

◆ m_timeResFuncHG_p

std::unique_ptr<const TF1> ZDCPulseAnalyzer::m_timeResFuncHG_p {}

private

Definition at line 139 of file ZDCPulseAnalyzer.h.

◆ m_timeResFuncLG_p

std::unique_ptr<const TF1> ZDCPulseAnalyzer::m_timeResFuncLG_p {}

private

Definition at line 140 of file ZDCPulseAnalyzer.h.

◆ m_timeSig

float ZDCPulseAnalyzer::m_timeSig {}

private

Definition at line 292 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrMode

unsigned int ZDCPulseAnalyzer::m_timingCorrMode {NoTimingCorr}

private

Definition at line 166 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrRefADC

float ZDCPulseAnalyzer::m_timingCorrRefADC {500}

private

Definition at line 167 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrScale

float ZDCPulseAnalyzer::m_timingCorrScale {100}

private

Definition at line 168 of file ZDCPulseAnalyzer.h.

◆ m_tmax

float ZDCPulseAnalyzer::m_tmax {}

private

Definition at line 86 of file ZDCPulseAnalyzer.h.

◆ m_tmin

float ZDCPulseAnalyzer::m_tmin {}

private

Definition at line 85 of file ZDCPulseAnalyzer.h.

◆ m_useDelayed

bool ZDCPulseAnalyzer::m_useDelayed {false}

private

Definition at line 95 of file ZDCPulseAnalyzer.h.

◆ m_usedPresampIdx

int ZDCPulseAnalyzer::m_usedPresampIdx {}

private

Definition at line 250 of file ZDCPulseAnalyzer.h.

◆ m_useFixedBaseline

bool ZDCPulseAnalyzer::m_useFixedBaseline {}

private

Definition at line 202 of file ZDCPulseAnalyzer.h.

◆ m_useLowGain

bool ZDCPulseAnalyzer::m_useLowGain {}

private

Definition at line 220 of file ZDCPulseAnalyzer.h.

◆ m_useSampleHG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleHG

private

Definition at line 332 of file ZDCPulseAnalyzer.h.

◆ m_useSampleLG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleLG

private

Definition at line 331 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitFunc

TF1 * ZDCPulseAnalyzer::s_combinedFitFunc = nullptr

staticprivate

Definition at line 70 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitTMax

float ZDCPulseAnalyzer::s_combinedFitTMax = 1000

staticprivate

Definition at line 71 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitTMin

float ZDCPulseAnalyzer::s_combinedFitTMin = -0.5

staticprivate

Definition at line 72 of file ZDCPulseAnalyzer.h.

◆ s_delayedFitHist

TH1 * ZDCPulseAnalyzer::s_delayedFitHist = nullptr

staticprivate

Definition at line 69 of file ZDCPulseAnalyzer.h.

◆ s_pullValues

std::vector< float > ZDCPulseAnalyzer::s_pullValues

staticprivate

Definition at line 73 of file ZDCPulseAnalyzer.h.

◆ s_quietFits

bool ZDCPulseAnalyzer::s_quietFits = true

staticprivate

Definition at line 66 of file ZDCPulseAnalyzer.h.

◆ s_saveFitFunc

bool ZDCPulseAnalyzer::s_saveFitFunc = false

staticprivate

Definition at line 67 of file ZDCPulseAnalyzer.h.

◆ s_undelayedFitHist

TH1 * ZDCPulseAnalyzer::s_undelayedFitHist = nullptr

staticprivate

Definition at line 68 of file ZDCPulseAnalyzer.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ SampleCIter

Member Enumeration Documentation

◆ anonymous enum

◆ LowGainMode

◆ TimingCorrMode

Constructor & Destructor Documentation

◆ ZDCPulseAnalyzer()

◆ ~ZDCPulseAnalyzer()

Member Function Documentation

◆ AnalyzeData()

◆ ArmSumInclude()

◆ BadChisq()

◆ BadT0()

◆ Calculate2ndDerivative()

◆ CalculateDerivative()

◆ CombinedPulsesFCN()

◆ disableFADCCorrections()

◆ DoAnalysis()

◆ DoFit()

◆ DoFitCombined()

◆ dump()

◆ dumpSetting()

◆ dumpTF1()

◆ enableDelayed()

◆ enableFADCCorrections()

◆ enablePostExclusion()

◆ enablePreExclusion()

◆ enableRepass()

◆ enableTimeSigCut()

◆ ExcludeEarlyLG()

◆ ExcludeLateLG()

◆ Failed()

◆ FillHistogram()

◆ FitFailed()

◆ fitMinimumAmplitude()

◆ getADCPeakHG()

◆ getADCPeakLG()

◆ GetAmpError()

◆ GetAmplitude()

◆ getAmplitudeCorrection()

◆ GetAmpNoNonLin()

◆ GetBkgdMaxFraction()

◆ GetChisq()

◆ GetCombinedGraph()

◆ GetdelayBS()

◆ GetDelayedBaselineCorr()

◆ GetDelayedBaselineShiftFit()

◆ GetFitAmplitude()

◆ GetFitExpAmp()

◆ GetFitPostAmp()

◆ GetFitPostT0()

◆ GetFitPreAmp()

◆ GetFitPreT0()

◆ GetFitPulls()

◆ GetFitT0()

◆ GetFitTau1()

◆ GetFitTau2()

◆ GetFitTMax()

◆ GetFitTMin()

◆ GetGraph()

◆ GetHistogramPtr()

◆ getLGMode()

◆ getMaxADCHG()

◆ getMaxADCLG()

◆ getMaxADCSampleHG()

◆ getMaxADCSampleLG()

◆ getMaxADCSub()

◆ GetMaxDelta()

◆ getMinADCHG()

◆ getMinADCLG()