ZDCPulseAnalyzer Class Reference

#include <ZDCPulseAnalyzer.h>

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 , FailSigCutBit = 19 ,   UnderFlowExclusionBit = 20 , N_STATUS_BITS }
enum	LowGainMode { LGModeNormal = 0 , LGModeForceLG , LGModeRefitLG }
enum	TimingCorrMode { NoTimingCorr = 0 , TimingCorrLin , TimingCorrLog }
using	JSON = ZDCJSONConfig::JSON

Public Member Functions
	ZDCPulseAnalyzer (ZDCMsg::MessageFunctionPtr msgFunc_p, const std::string &tag, int Nsample, float deltaTSample, size_t preSampleIdx, int pedestal, const std::string &fitFunction, int peak2ndDerivMinSample, float peak2DerivMinThreshHG, float peak2DerivMinThreshLG)
	ZDCPulseAnalyzer (ZDCMsg::MessageFunctionPtr msgFunc_p, const JSON &configJSON)
	~ZDCPulseAnalyzer ()
void	setFitOPtions (const std::string &fitOptions)
void	saveFitFunc (bool save)
bool	quietFits () const
void	setQuietFits ()
void	setUnquietFits ()
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	setPerSampleNoiseSigmas (const std::vector< float > &sigmaHG, const std::vector< float > &sigmaLG)
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	SetTimeCuts (float deltaT0MinHG, float deltaT0MaxHG, float deltaT0MinLG, float deltaT0MaxLG)
void	SetChisqCuts (float chisqDivAmpCutHG, float chisqDivAmpScaleHG, float chisqDivAmpOffsetHG, float chisqDivAmpPowerHG, float chisqDivAmpCutLG, float chisqDivAmpScaleLG, float chisqDivAmpOffsetLG, float chisqDivAmpPowerLG)
void	SetNoiseSigmas (float noiseSigHG, float noiseSigLG)
void	SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)
void	SetFitMinMaxAmp (float minAmpHG, float minAmpLG, float maxAmpHG, float maxAmpLG)
void	setMinimumSignificance (float sigMinHG, float sigMinLG)
void	SetTauT0Values (bool fixTau1, bool fixTau2, float tau1, float tau2, float t0HG, float t0LG)
void	enablePostPulseCheck (unsigned int postPulseSampleDelta, float postPulseDerivMinSig, float postPulseAbsDer2ndMinSig, float minMainDer2ndRatio)
void	disablePostPulseCheck ()
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
bool	failSigCut () const
bool	underflowExclusion () const
float	GetFitAmplitude () const
float	GetFitT0 () const
float	GetT0Sub () const
float	GetT0Corr () const
float	getTimeSig () const
float	GetChisq () const
float	GetChisqRatio () 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
const std::vector< float > &	GetShapeParameters () const
float	getRefitLGAmp () const
float	getRefitLGFitAmp () const
float	getRefitLGAmpCorr () const
float	getRefitLGChisq () const
float	getRefitLGChisqRatio () 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)
std::shared_ptr< TGraphErrors >	GetCombinedGraph (bool forceLG=false)
std::shared_ptr< TGraphErrors >	GetGraph (bool forceLG=false)
std::vector< float >	GetFitPulls (bool forceLG=false) const
void	dump () const
void	dumpConfiguration () const
void	dumpTF1 (const TF1 *) const
const std::vector< float > &	GetSamplesSub () const
const std::vector< float > &	GetSamplesDeriv2nd () const

Static Public Attributes
static const ZDCJSONConfig::JSONParamList	JSONConfigParams

Private Types
typedef std::vector< float >::const_iterator	SampleCIter
using	ChisqCutLambdatype = std::function<bool(float,float,float, float&)>

Private Member Functions
void	initialize ()
void	reset (bool reanalyze=false)
void	setDefaults ()
std::pair< bool, std::string >	ValidateJSONConfig (const JSON &config)
std::pair< bool, std::string >	ConfigFromJSON (const JSON &config)
void	SetupFitFunctions ()
bool	DoAnalysis (bool repass)
bool	ScanAndSubtractSamples ()
bool	AnalyzeData (size_t nSamples, size_t preSample, const std::vector< float > &samples, const std::vector< float > &samplesNoise, const std::vector< bool > &useSamples, float peak2ndDerivMinThresh, const std::vector< float > &toCorrParams, ChisqCutLambdatype chisqCutLambda, float minT0Corr, float maxT0Corr)
double	getAmplitudeCorrection (bool highGain)
void	prepareLGRefit (const std::vector< float > &samplesLG, const std::vector< float > &samplesNoise, const std::vector< bool > &useSamples)
void	FillHistogram (bool refitLG)
void	checkTF1Limits (TF1 *func)
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::pair< std::vector< float >, std::vector< float > >	calculate2ndDerivative (const std::vector< float > &inputData, const std::vector< float > &inputNoise, 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_freqMHz {}
float	m_deltaTSample {}
int	m_pedestal {}
unsigned int	m_LGMode {LGModeNormal}
float	m_tmin {}
float	m_tmax {}
bool	m_quietFits {true}
bool	m_saveFitFunc {false}
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 {}
bool	m_havePerSampleNoiseHG {false}
bool	m_havePerSampleNoiseLG {false}
std::vector< float >	m_setPerSampleNoiseHG
std::vector< float >	m_setPerSampleNoiseLG
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_chisqDivAmpScaleLG {}
float	m_chisqDivAmpScaleHG {}
float	m_chisqDivAmpOffsetLG {}
float	m_chisqDivAmpOffsetHG {}
float	m_chisqDivAmpPowerLG {}
float	m_chisqDivAmpPowerHG {}
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_haveSignifCuts {false}
float	m_sigMinHG {}
float	m_sigMinLG {}
bool	m_doPostPulseCheck {false}
unsigned int	m_postPulseDelta {0}
float	m_postPulseDerivMinSig {}
float	m_postPulseAbsDer2ndMinSig {}
float	m_postPulseMainMinDer2ndRatio {}
unsigned int	m_prePulseDelta {0}
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}
bool	m_enableUnderflowExclHG {false}
bool	m_enableUnderflowExclLG {false}
unsigned int	m_underFlowExclSamplesPreHG {0}
unsigned int	m_underFlowExclSamplesPostHG {0}
unsigned int	m_underFlowExclSamplesPreLG {0}
unsigned int	m_underFlowExclSamplesPostLG {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}
std::string	m_fadcCorrFileName
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_initialized {false}
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 {false}
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 {false}
bool	m_havePulse {false}
bool	m_useLowGain {false}
bool	m_fail {false}
bool	m_HGOverflow {false}
bool	m_HGUnderflow {false}
bool	m_PSHGOverUnderflow {false}
bool	m_LGOverflow {false}
bool	m_LGUnderflow {false}
bool	m_prePulse {false}
bool	m_postPulse {false}
bool	m_fitFailed {false}
bool	m_badChisq {false}
bool	m_badT0 {false}
bool	m_ExcludeEarly {false}
bool	m_ExcludeLate {false}
bool	m_preExpTail {false}
bool	m_fixPrePulse {false}
bool	m_fitMinAmp {false}
bool	m_repassPulse {false}
bool	m_failSigCut {false}
bool	m_underflowExclusion {false}
bool	m_backToHG_pre {false}
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_chisqRatio {}
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 {}
std::vector< float >	m_shapeParameters
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_refitLGChisqRatio {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< float >	m_sampleNoiseHG
std::vector< float >	m_sampleNoiseLG
std::vector< bool >	m_useSampleLG
std::vector< bool >	m_useSampleHG
std::vector< float >	m_ADCSSampNoiseHG
std::vector< float >	m_ADCSSampNoiseLG
std::vector< float >	m_samplesSub
std::vector< float >	m_samplesNoise
std::vector< float >	m_samplesLGRefit
std::vector< float >	m_samplesNoiseLGRefit
std::vector< float >	m_samplesDeriv2nd
std::vector< float >	m_samplesDeriv2ndErr
std::vector< float >	m_fitPulls

Static Private Attributes
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

ChisqCutLambdatype

using ZDCPulseAnalyzer::ChisqCutLambdatype = std::function<bool(float,float,float, float&)>

private

Definition at line 424 of file ZDCPulseAnalyzer.h.

JSON

using ZDCPulseAnalyzer::JSON = ZDCJSONConfig::JSON

Definition at line 26 of file ZDCPulseAnalyzer.h.

SampleCIter

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

private

Definition at line 74 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
FailSigCutBit
UnderFlowExclusionBit
N_STATUS_BITS

Definition at line 28 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, // 0x40000
    FailSigCutBit         = 19, // 0x80000
    UnderFlowExclusionBit = 20, // 0x100000
        N_STATUS_BITS
       };

LowGainMode

enum ZDCPulseAnalyzer::LowGainMode

Enumerator
LGModeNormal
LGModeForceLG
LGModeRefitLG

Definition at line 56 of file ZDCPulseAnalyzer.h.

                   {
    LGModeNormal = 0,
    LGModeForceLG,
    LGModeRefitLG
  };

TimingCorrMode

enum ZDCPulseAnalyzer::TimingCorrMode

Enumerator
NoTimingCorr
TimingCorrLin
TimingCorrLog

Definition at line 62 of file ZDCPulseAnalyzer.h.

{NoTimingCorr = 0, TimingCorrLin, TimingCorrLog};

Constructor & Destructor Documentation

ZDCPulseAnalyzer() [1/2]

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

Definition at line 158 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_fitFunction(fitFunction),
  m_peak2ndDerivMinSample(peak2ndDerivMinSample),
  m_peak2ndDerivMinThreshLG(std::abs(peak2ndDerivMinThreshLG)),
  m_peak2ndDerivMinThreshHG(std::abs(peak2ndDerivMinThreshHG))
{
  // Create the histogram used for fitting
  //
  m_tmin = -deltaTSample / 2;
  m_tmax = m_tmin + ((float) Nsample) * deltaTSample;
  m_defaultFitTMax = m_tmax;
  m_freqMHz = 1000./m_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() [2/2]

ZDCPulseAnalyzer::ZDCPulseAnalyzer	(	ZDCMsg::MessageFunctionPtr	msgFunc_p,
		const JSON &	configJSON )

Definition at line 190 of file ZDCPulseAnalyzer.cxx.

                                                                                             :
  m_msgFunc_p(std::move(msgFunc_p))
{
  setDefaults();
 
  // auto [result, resultString] = ValidateJSONConfig(configJSON);
  // (*m_msgFunc_p)(ZDCMsg::Debug, "ValidateJSON produced result: " + resultString);
 
  auto [result2, resultString2] = ConfigFromJSON(configJSON);
  (*m_msgFunc_p)(ZDCMsg::Debug, "ConfigFromJSON produced result: "+ resultString2);
 
  dumpConfiguration();
  
  // Create the histogram used for fitting
  //
  if (m_freqMHz >1.e-6)  m_deltaTSample = 1000./m_freqMHz;
  m_tmin = -m_deltaTSample / 2;
  m_tmax = m_tmin + ((float)m_Nsample) * m_deltaTSample;
  m_defaultFitTMax = m_tmax;
 
  std::string histName = "ZDCFitHist" + m_tag;
  std::string histNameLGRefit = "ZDCFitHist" + m_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);
  
  if(m_useDelayed) {
    enableDelayed(m_delayedDeltaT, m_delayedPedestalDiff, false);
  }
 
  reset();
}

~ZDCPulseAnalyzer()

ZDCPulseAnalyzer::~ZDCPulseAnalyzer ( )

inline

Definition at line 515 of file ZDCPulseAnalyzer.h.

{}

Member Function Documentation

AnalyzeData()

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

private

Definition at line 1294 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_samplesNoise = samplesNoise;
      
  //
  // 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
  //
  auto deriv2ndResult  = calculate2ndDerivative(m_samplesSub, m_samplesNoise, m_2ndDerivStep);
  m_samplesDeriv2nd = deriv2ndResult.first;
  m_samplesDeriv2ndErr = deriv2ndResult.second;
    
  // 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_minDeriv2ndIndex = std::distance(m_samplesDeriv2nd.cbegin(), minDeriv2ndIter);
  m_minDeriv2ndSig = -m_minDeriv2nd/m_samplesDeriv2ndErr[m_minDeriv2ndIndex];
 
  m_havePulse = false;
 
  // If the second derivative is greater than the threshold, we may have a pulse
  //
  if (std::abs(m_minDeriv2nd) >= peak2ndDerivMinThresh) {
    //
    // Check that we have found a real maximum
    //
    auto deltaLeft = m_samplesSub[m_minDeriv2ndIndex] - m_samplesSub[m_minDeriv2ndIndex - 1];
    auto deltaLeft2 = m_samplesSub[m_minDeriv2ndIndex-1] - m_samplesSub[m_minDeriv2ndIndex - 2];
    auto deltaRight = m_samplesSub[m_minDeriv2ndIndex] - m_samplesSub[m_minDeriv2ndIndex + 1];
    auto deltaRight2 = m_samplesSub[m_minDeriv2ndIndex+1] - m_samplesSub[m_minDeriv2ndIndex + 2];
    
    if ((deltaLeft2 > 0 || deltaLeft > 0) && (deltaRight2 > 0 || deltaRight > 0)) {
      m_havePulse = true;
    }
    else {
      // In the case that a fluctuation made the most negative 2nd derivative not at the real peak
      //  check the 2nd derivative at the nominal peak position.
      //
      if (std::abs(m_samplesDeriv2nd[m_peak2ndDerivMinSample]) > peak2ndDerivMinThresh) {
    m_minDeriv2ndIndex = m_peak2ndDerivMinSample;
 
    // Now we re-do the check
    //
    deltaLeft = m_samplesSub[m_minDeriv2ndIndex] - m_samplesSub[m_minDeriv2ndIndex - 1];
    deltaLeft2 = m_samplesSub[m_minDeriv2ndIndex-1] - m_samplesSub[m_minDeriv2ndIndex - 2];
    deltaRight = m_samplesSub[m_minDeriv2ndIndex] - m_samplesSub[m_minDeriv2ndIndex + 1];
    deltaRight2 = m_samplesSub[m_minDeriv2ndIndex+1] - m_samplesSub[m_minDeriv2ndIndex + 2];
 
    if ((deltaLeft2 > 0 || deltaLeft > 0) && (deltaRight2 > 0 || deltaRight > 0)) {
      m_havePulse = true;
    }
      }
      else {
    (*m_msgFunc_p)(ZDCMsg::Info, ("ZDCPulseAnalyzer for " + m_tag + " found a fake maximum at sample " + std::to_string(m_minDeriv2ndIndex) ));
      }
    }
  }
  
  // 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 derivPresampleErr = std::sqrt(Sqr(m_samplesNoise[m_usedPresampIdx]) + Sqr(m_samplesNoise[m_usedPresampIdx+1]));
    float derivPresampleSig = m_samplesSub[m_usedPresampIdx+1]/derivPresampleErr;
    if (derivPresampleSig < -5) {
      m_preExpTail = true;
      m_preExpSig = derivPresampleSig;
    }
    
    for (unsigned int isample = m_usedPresampIdx; isample <= m_minDeriv2ndIndex - m_prePulseDelta; isample++) {
      if (!useSample[isample]) continue;
 
      float sampleSig = -m_samplesSub[isample]/m_samplesNoise[isample];
 
      // Compare the derivative significant to the 2nd derivative significance, 
      //   so we don't waste time dealing with small perturbations on large signals
      //
      if ((sampleSig > 5 && sampleSig > 0.02*m_minDeriv2ndSig) || sampleSig > 0.5*m_minDeriv2ndSig) {
    m_preExpTail = true;
 
    // std::cout << "Found preExpTail at sample " << isample << ", sampleSig = " << sampleSig
    //    << ", m_minDeriv2ndSig = " << m_minDeriv2ndSig << std::endl;
    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
      //
      double prePulseSig = -m_samplesDeriv2nd[isample]/(1e-6 + m_samplesDeriv2ndErr[isample]);
      //
      // apply a cut on the significance (as above) but without using division
      //
      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) {
      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);
    }
 
    // -----------------------------------------------------
    // Post pulse detection
    //
    if (m_doPostPulseCheck) {
      for (int isample = m_minDeriv2ndIndex + m_postPulseDelta; isample < (int) nSamples - 1; isample++) {
    if (!useSample[isample] || !useSample[isample +1]) continue;
      
    float deriv = m_samplesSub[isample + 1] - m_samplesSub[isample];
    float derivErr = std::sqrt(Sqr(m_samplesNoise[isample + 1]) + Sqr(m_samplesNoise[isample]));
 
    float deriv2nd = m_samplesDeriv2nd[isample];
    float deriv2ndErr = m_samplesDeriv2ndErr[isample];
    
    if (deriv > m_postPulseDerivMinSig*derivErr && std::abs(deriv2nd) > m_postPulseAbsDer2ndMinSig*deriv2ndErr) {
      m_postPulse = true;
      
      // 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
      //
      unsigned int delta = deriv2nd < 0 ? m_2ndDerivStep : m_2ndDerivStep - 1;
      m_maxSampleEvt = std::min<int>(isample - delta, m_maxSampleEvt);
 
      std::ostringstream msg;
      msg << "ZDCPulseAnalyzer for " << m_tag << " Found a post pulse at sample " << isample
          << " deriv = " << deriv << ", derivErr = " << derivErr
          << " deriv2nd = " << deriv2nd << ", deriv2ndErr = " << deriv2nd;
      (*m_msgFunc_p)(ZDCMsg::Debug, msg.str());
      m_adjTimeRangeEvent = true;
      
      break;
    }
      }
    }
  }
 
  
  // -----------------------------------------------------
 
  //  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 using lambda function
    //
    //    if (m_fitChisq/m_fitNDoF > 2 && m_fitChisq / (m_fitAmplitude + 1.0e-6) > maxChisqDivAmp) m_badChisq = true;
    if (!chisqCutLambda(m_fitChisq, m_fitAmplitude, m_fitNDoF, m_chisqRatio)) m_badChisq = true;  }
 
  return !m_fitFailed;
}

armSumInclude()

bool ZDCPulseAnalyzer::armSumInclude ( ) const

inline

Definition at line 669 of file ZDCPulseAnalyzer.h.

{return havePulse() && !(failed() || fitFailed() || badChisq() || badT0() || fitMinimumAmplitude() || LGOverflow() || LGUnderflow() || failSigCut());}

badChisq()

bool ZDCPulseAnalyzer::badChisq ( ) const

inline

Definition at line 661 of file ZDCPulseAnalyzer.h.

{return m_badChisq;}

badT0()

bool ZDCPulseAnalyzer::badT0 ( ) const

inline

Definition at line 663 of file ZDCPulseAnalyzer.h.

{return m_badT0;}

calculate2ndDerivative() [1/2]

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

staticprivate

Definition at line 2540 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 would 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);
  std::vector<float> resultsErr(vecSize, 0);
 
  unsigned int fillIndex = step;
  for (unsigned int sample = step; sample < nSamples - step; sample++) {
    float deriv2nd = inputData[sample + step] + inputData[sample - step] - 2*inputData[sample];
    float deriv2ndErr = std::sqrt(Sqr(inputNoise[sample + step]) + Sqr(inputNoise[sample - step]) + 2*Sqr(inputNoise[sample]));
 
    results[fillIndex] = deriv2nd;
    resultsErr[fillIndex++] = deriv2ndErr;
  }
 
  return {results, resultsErr};
}

calculate2ndDerivative() [2/2]

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

staticprivate

Definition at line 2520 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 would 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++) {
    auto 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 2499 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;
}

checkTF1Limits()

void ZDCPulseAnalyzer::checkTF1Limits ( TF1 * func )

private

Definition at line 2178 of file ZDCPulseAnalyzer.cxx.

{
  for (int ipar = 0; ipar < func->GetNpar(); ipar++) {
    double parLimitLow, parLimitHigh;
    
    func->GetParLimits(ipar, parLimitLow, parLimitHigh);
    
    (*m_msgFunc_p)(ZDCMsg::Debug, (
                  "ZDCPulseAnalyzer name=" + std::string(func->GetName())
                  + " ipar=" + std::to_string(ipar)
                  + " parLimitLow=" + std::to_string(parLimitLow)
                  + " parLimitHigh="+ std::to_string(parLimitHigh)
                  )
               );
    
    if (std::abs(parLimitHigh - parLimitLow) > (1e-6)*std::abs(parLimitLow)) {
      double value = func->GetParameter(ipar);
      if (value >= parLimitHigh) {
    value = parLimitHigh * 0.9;
      }
      else if (value <= parLimitLow) {
    value = parLimitLow + 0.1*std::abs(parLimitLow);
      }
      func->SetParameter(ipar, value);
    }
  }
}

CombinedPulsesFCN()

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

staticprivate

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

ConfigFromJSON()

std::pair< bool, std::string > ZDCPulseAnalyzer::ConfigFromJSON ( const JSON & config )

private

Definition at line 2692 of file ZDCPulseAnalyzer.cxx.

{
  bool result = true;
  std::string resultString = "success";
 
  for (auto [key, value] : config.items()) {
    //
    // Big if statement to process configuration parameters
    //
    if (key == "Nsample") m_Nsample = value;
    else if (key == "tag") m_tag = value;
    else if (key == "LGMode") m_LGMode = value;
    else if (key == "Nsample") m_Nsample = value;
    else if (key == "useDelayed") m_useDelayed = value;
    else if (key == "preSampleIdx") m_preSampleIdx = value;
    else if (key == "FADCFreqMHz") m_freqMHz = value;
    else if (key == "nominalPedestal") m_pedestal = value;
    else if (key == "fitFunction") m_fitFunction = value;
    else if (key == "peakSample") m_peak2ndDerivMinSample = value;
    else if (key == "peakTolerance") m_peak2ndDerivMinTolerance = value;
    else if (key == "2ndDerivThreshHG") m_peak2ndDerivMinThreshHG = value;
    else if (key == "2ndDerivThreshLG") m_peak2ndDerivMinThreshLG = value;
    else if (key == "2ndDerivStep") m_2ndDerivStep = value;
    else if (key == "HGOverflowADC") m_HGOverflowADC = value;
    else if (key == "HGUnderflowADC") m_HGUnderflowADC = value;
    else if (key == "LGOverflowADC") m_LGOverflowADC = value;
    else if (key == "nominalT0HG") m_nominalT0HG = value;
    else if (key == "nominalT0LG") m_nominalT0LG = value;
    else if (key == "nominalTau1") m_nominalTau1 = value;
    else if (key == "nominalTau2") m_nominalTau2 = value;
    else if (key == "fixTau1") m_fixTau1 = value;
    else if (key == "fixTau2") m_fixTau2 = value;
    else if (key == "T0CutsHG") {
      m_T0CutLowHG = value[0];
      m_T0CutHighHG = value[1];
    }
    else if (key == "T0CutsLG") {
      m_T0CutLowLG = value[0];
      m_T0CutHighLG = value[1];
      m_initializedFits = false;
    }
    else if (key == "chisqDivAmpCutHG") m_chisqDivAmpCutHG = value;
    else if (key == "chisqDivAmpCutLG") m_chisqDivAmpCutLG = value;
    else if (key == "chisqDivAmpOffsetHG") m_chisqDivAmpOffsetHG = value;
    else if (key == "chisqDivAmpScaleLG") m_chisqDivAmpScaleLG = value;
    else if (key == "chisqDivAmpScaleHG") m_chisqDivAmpScaleHG = value;
    else if (key == "chisqDivAmpOffsetLG") m_chisqDivAmpOffsetLG = value;
    else if (key == "chisqDivAmpPowerHG") m_chisqDivAmpPowerHG = value;
    else if (key == "chisqDivAmpPowerLG") m_chisqDivAmpPowerLG = value;
    else if (key == "gainFactorHG") m_gainFactorHG = value;
    else if (key == "gainFactorLG") m_gainFactorLG = value;
    else if (key == "noiseSigmaHG") m_noiseSigHG = value;
    else if (key == "noiseSigmaLG") m_noiseSigLG = value;
    else if (key == "perSampleNoiseSigmaHG") {
      m_havePerSampleNoiseHG = true;
      value.get_to(m_setPerSampleNoiseHG);
    }
    else if (key == "perSampleNoiseSigmaLG") {
      m_havePerSampleNoiseLG = true;
      value.get_to(m_setPerSampleNoiseLG);
      // m_setPerSampleNoiseLG.clear();
      
      // for (auto elem : value) {
      //    m_setPerSampleNoiseLG.push_back(elem);
      // }
    }
    else if (key == "fitTimeMax") {
      SetFitTimeMax(static_cast<float>(value));
    }
    else if (key == "enableRepass") m_enableRepass = value;
    else if (key == "Repass2ndDerivThreshHG")  m_peak2ndDerivMinRepassHG = value;
    else if (key == "Repass2ndDerivThreshLG")  m_peak2ndDerivMinRepassLG = value;
    else if (key == "fitAmpMinMaxHG") {
      m_fitAmpMinHG = value[0];
      m_fitAmpMaxHG = value[1];
    }
    else if (key == "fitAmpMinMaxLG") {
      m_fitAmpMinLG = value[0];
      m_fitAmpMaxLG = value[1];
    }
    else if (key == "quietFits") {
      m_quietFits = value;
    }
    else if (key == "enablePreExclusion") {
      m_enablePreExcl = true;
      m_maxSamplesPreExcl  = value[0];
      m_preExclHGADCThresh = value[1];
      m_preExclLGADCThresh = value[2];
    }
    else if (key == "enablePostExclusion") {
      m_enablePostExcl = true;
      m_maxSamplesPostExcl  = value[0];
      m_postExclHGADCThresh = value[1];
      m_postExclLGADCThresh = value[2];
    }
    else if (key == "enableUnderflowExclusionHG") {
      m_enableUnderflowExclHG = true;
      m_underFlowExclSamplesPreHG  = value[0];
      m_underFlowExclSamplesPostHG = value[1];
    }
    else if (key == "enableUnderflowExclusionLG") {
      m_enableUnderflowExclLG = true;
      m_underFlowExclSamplesPreLG  = value[0];
      m_underFlowExclSamplesPostLG = value[1];
    }
    else if (key == "ampMinSignifHGLG") {
      m_haveSignifCuts = true;
      m_sigMinHG = value[0];
      m_sigMinLG = value[1];
    }
    else if (key == "enableFADCCorrections") {
      auto fileNameJson = value["filename"];
      auto doPerSampleCorrJson = value["doPerSampleCorr"];
      
      if (fileNameJson.is_null() || doPerSampleCorrJson.is_null()) {
          result = false;
          resultString = "failure processing enableFADCCorrections object";
          break;
      }
      
      m_haveFADCCorrections = true;
      m_FADCCorrPerSample = doPerSampleCorrJson;
      m_fadcCorrFileName = fileNameJson;
    }
    else if(key =="useDelayed"){
      if(value){
        m_useDelayed = true;
      }
    } 
    else if (key == "delayDeltaT") m_delayedDeltaT = value;
    else if (key == "delayDefaultPedestalShift") m_delayedPedestalDiff = value;
    else if (key == "enableTimingCorrection") {
      m_timingCorrMode = value[0];
      m_timingCorrRefADC = value[1];
      m_timingCorrScale = value[2];
    }
    else if(key == "timeCorrCoeffHG"){
      for(int i = 0;auto coeff:value){
        m_HGT0CorrParams.at(i) = coeff;
        i++;
      }
    }
    else if(key == "timeCorrCoeffLG"){
      for(int i = 0;auto coeff:value){
        m_LGT0CorrParams.at(i) = coeff;
        i++;
      }
    }
    else if(key == "enableNLCorrection"){
      m_haveNonlinCorr = true;
      m_nonLinCorrRefADC = value[0];
      m_nonLinCorrRefScale = value[1];
      (*m_msgFunc_p)(
          ZDCMsg::Debug, ("Setting non-linear parameters" 
                         ", reference ADC = " + std::to_string(m_nonLinCorrRefADC) +
                         ", reference scale = " + std::to_string(m_nonLinCorrRefScale)));
    }
    else if(key == "HGNLCorrCoeffs"){
      std::string HGParamsStr = "HG coefficients = ";
       for (auto coeff : value) {
        m_nonLinCorrParamsHG.push_back(coeff);
        HGParamsStr += std::to_string(m_nonLinCorrParamsHG.back()) + " ";
      }
      (*m_msgFunc_p)(ZDCMsg::Debug, std::move(HGParamsStr));
    }
    else if(key == "LGNLCorrCoeffs"){
      std::string LGParamsStr = "LG coefficients = ";
      for(auto coeff:value){
        m_nonLinCorrParamsLG.push_back(coeff);
        LGParamsStr += std::to_string(m_nonLinCorrParamsLG.back()) + " ";
      }
      (*m_msgFunc_p)(ZDCMsg::Debug, std::move(LGParamsStr));
    }
    else {
      result = false;
      resultString = "unprocessed parameter";
      break;
    }
  }
 
  return {result, resultString};
}

disableFADCCorrections()

void ZDCPulseAnalyzer::disableFADCCorrections ( )

inline

Definition at line 634 of file ZDCPulseAnalyzer.h.

{m_haveFADCCorrections = false;}

disablePostPulseCheck()

void ZDCPulseAnalyzer::disablePostPulseCheck ( )

inline

Definition at line 591 of file ZDCPulseAnalyzer.h.

{m_doPostPulseCheck = false;}

DoAnalysis()

bool ZDCPulseAnalyzer::DoAnalysis ( bool repass )

private

Definition at line 1163 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 ");
 
    auto chisqCutLambda = [cut = m_chisqDivAmpCutLG,
               scale =  m_chisqDivAmpScaleLG,
               offset = m_chisqDivAmpOffsetLG,
               power = m_chisqDivAmpPowerLG]
      (float chisq, float amp, unsigned int fitNDoF, float& ratio)->bool
    {
      // Avoid a spurious FPE from clang.
      CXXUTILS_TRAPPING_FP;
      if (amp < 1e-6) return true;
      ratio = chisq /(scale* (std::pow(amp/1000 + offset, power)));
      if (chisq/fitNDoF > 2 && ratio > cut) return false;
      else return true;
    };
    
    bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesLGSub, m_sampleNoiseLG, m_useSampleLG,
                  deriv2ndThreshLG, m_LGT0CorrParams, chisqCutLambda, 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 ");
    auto chisqCutLambda = [cut = m_chisqDivAmpCutHG,
               scale =   m_chisqDivAmpScaleHG,
               offset = m_chisqDivAmpOffsetHG,
               power = m_chisqDivAmpPowerHG, tag = m_tag]
      (float chisq, float amp, unsigned int fitNDoF, float& ratio)->bool
    {
      // Avoid a spurious FPE from clang.
      CXXUTILS_TRAPPING_FP;
      if (amp < 1e-6) return true;
      ratio = chisq /(scale*(std::pow(amp/1000 + offset, power)));
      if (chisq/float(fitNDoF) > 2 && ratio > cut) return false;
      else return true;
    };
    
    bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesHGSub, m_sampleNoiseHG, m_useSampleHG,
                  deriv2ndThreshHG, m_HGT0CorrParams, chisqCutLambda, 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_sampleNoiseLG, 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 1709 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 (m_quietFits) {
    options += "Q";
  }
 
  bool fitFailed = false;
 
  //  dumpTF1(fitWrapper->GetWrapperTF1RawPtr());
  checkTF1Limits(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 && m_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;
    }
 
    if (m_haveSignifCuts) {
      float sigMinCut = fitLG ? m_sigMinLG : m_sigMinHG;
 
      if (m_fitAmpError > 1e-6) {
    if (m_fitAmplitude/m_fitAmpError < sigMinCut) m_failSigCut = true;
      }
    }
 
    if (!m_fitFailed) {
      unsigned int numPars = fitWrapper->GetNumShapeParameters();
      m_shapeParameters.assign(numPars, 0);
      
      for (size_t ipar = 0; ipar < numPars; ipar++) {
    m_shapeParameters[ipar] = fitWrapper->GetShapeParameter(ipar);
      }
    }
  }
  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 1895 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 (m_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;
  }
 
  // Check that the amplitude passes minimum significance requirement
  //
  float sigMinCut = fitLG ? m_sigMinLG : m_sigMinHG;
  if (m_fitAmpError > 1e-6) {
    if (m_fitAmplitude/m_fitAmpError < sigMinCut) m_failSigCut = true;
  }
 
  if (!m_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 (m_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();
 
    if (!m_fitFailed) {
      unsigned int numPars = fitWrapper->GetNumShapeParameters();
      m_shapeParameters.assign(numPars, 0);
      
      for (size_t ipar = 0; ipar < numPars; ipar++) {
    m_shapeParameters[ipar] = fitWrapper->GetShapeParameter(ipar);
      }
    }
  }
  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 2261 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)));
}

dumpConfiguration()

void ZDCPulseAnalyzer::dumpConfiguration

(

)

const

Definition at line 2308 of file ZDCPulseAnalyzer.cxx.

{
  std::ostringstream ostrStream;
  (*m_msgFunc_p)(ZDCMsg::Info, ("\n ZDCPulserAnalyzer:: ======================================================================="));
  (*m_msgFunc_p)(ZDCMsg::Info, ("ZDCPulserAnalyzer:: settings for instance: " + m_tag));
 
  ostrStream << "Nsample = " << m_Nsample << " at frequency " << m_freqMHz << " MHz, preSample index = "
         << m_preSampleIdx <<  ", nominal pedestal = " << m_pedestal;
    
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  ostrStream << "LG mode = " << m_LGMode << ", gainFactor HG = " << m_gainFactorHG << ", gainFactor LG = " << m_gainFactorLG << ", noise sigma HG = " <<  m_noiseSigHG << ", noiseSigLG = " << m_noiseSigLG;
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  if (m_havePerSampleNoiseHG) {
    ostrStream << "Using per-sample noise sigmas for high gain, values = ";
    for (auto sig : m_setPerSampleNoiseHG) {ostrStream << sig << ", ";}
    ostrStream << "end";
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
  if (m_havePerSampleNoiseLG) {
    ostrStream << "Using per-sample noise sigmas for low gain, values = ";
    for (auto sig : m_setPerSampleNoiseLG) {ostrStream << sig << ", ";}
    ostrStream << "end";
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
  ostrStream << "peak sample = " << m_peak2ndDerivMinSample <<  ", tolerance = " << m_peak2ndDerivMinTolerance
         << ", 2ndDerivThresh HG, LG = " << m_peak2ndDerivMinThreshHG <<  ", " << m_peak2ndDerivMinThreshLG
         << ", 2nd deriv step = " << m_2ndDerivStep;
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  if (m_useDelayed) {
    ostrStream << "using delayed samples with delta T = " << m_delayedDeltaT << ", and default pedestalDiff == "
           << m_delayedPedestalDiff;
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
  ostrStream <<"Fit function = " << m_fitFunction <<  "fixTau1 = " << m_fixTau1 <<  ", fixTau2 = " << m_fixTau2
         << ", nominalTau1 = " << m_nominalTau1 << ", nominalTau2 = " << m_nominalTau2 << "\n"
         << ", nominalT0HG = " << m_nominalT0HG << ",  nominalT0LG = " << m_nominalT0LG
             << ", t0Cuts HG = [" << m_T0CutLowHG << ", " << m_T0CutHighHG << "], t0Cuts LG = ["
         << m_T0CutLowLG << ", " << m_T0CutHighLG << "]";
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  ostrStream << "HGOverflowADC = " << m_HGOverflowADC << ",  HGUnderflowADC = " << m_HGUnderflowADC
         << ",  LGOverflowADC = "<< m_LGOverflowADC;
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  ostrStream << "chisqDivAmpCutHG = " << m_chisqDivAmpCutHG << ",  chisqDivAmpCutLG=" << m_chisqDivAmpCutLG
         << ", chisqDivAmpOffsetHG = " << m_chisqDivAmpOffsetHG << ", chisqDivAmpOffsetLG = " << m_chisqDivAmpOffsetLG
         << ", chisqDivAmpPowerHG = " << m_chisqDivAmpPowerHG << ", chisqDivAmpPowerLG = " << m_chisqDivAmpPowerLG;
  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
 
  if ( m_enableRepass) {
    ostrStream << "Repass enabled with peak2ndDerivMinRepassHG = " << m_peak2ndDerivMinRepassHG << ", peak2ndDerivMinRepassLG = " << m_peak2ndDerivMinRepassLG;
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
  if (m_enablePreExcl) {
    ostrStream << "Pre-exclusion enabled for up to " << m_maxSamplesPreExcl << ", samples with ADC threshold HG = "
           << m_preExclHGADCThresh << ", LG = " << m_preExclLGADCThresh;
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
  if (m_enablePostExcl) {
    ostrStream << "Post-exclusion enabled for up to " << m_maxSamplesPostExcl << ", samples with ADC threshold HG = "
           << m_postExclHGADCThresh << ", LG = " << m_postExclLGADCThresh;
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
  if (m_enableUnderflowExclHG) {
    ostrStream << "High gain Underflow pre- and post-exclusion enabled for up to " << m_underFlowExclSamplesPreHG
           << ", and " << m_underFlowExclSamplesPostHG << " samples, respectively";
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
  if (m_enableUnderflowExclLG) {
    ostrStream << "Low gain Underflow pre- and post-exclusion enabled for up to " << m_underFlowExclSamplesPreLG
           << ", and " << m_underFlowExclSamplesPostLG << " samples, respectively";
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
  if (m_haveSignifCuts) {
    ostrStream << "Minimum significance cuts applied: HG min. sig. = " << m_sigMinHG << ", LG min. sig. " << m_sigMinLG;
    (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
  }
 
}

dumpTF1()

void ZDCPulseAnalyzer::dumpTF1

(

const TF1 *

func

)

const

Definition at line 2289 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 226 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);
}

enableFADCCorrections()

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

Definition at line 644 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 540 of file ZDCPulseAnalyzer.h.

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

enablePostPulseCheck()

void ZDCPulseAnalyzer::enablePostPulseCheck	(	unsigned int	postPulseSampleDelta,
		float	postPulseDerivMinSig,
		float	postPulseAbsDer2ndMinSig,
		float	minMainDer2ndRatio )

Definition at line 253 of file ZDCPulseAnalyzer.cxx.

{
  m_doPostPulseCheck = true;
  m_postPulseDelta = postPulseSampleDelta;
  m_postPulseDerivMinSig = postPulseDerivMinSig;
  m_postPulseAbsDer2ndMinSig = postPulseAbsDer2ndMinSig;
  m_postPulseMainMinDer2ndRatio = minMainDer2ndRatio;
}

enablePreExclusion()

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

inline

Definition at line 532 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 246 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 615 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 664 of file ZDCPulseAnalyzer.h.

{return m_ExcludeEarly;}

excludeLateLG()

bool ZDCPulseAnalyzer::excludeLateLG ( ) const

inline

Definition at line 665 of file ZDCPulseAnalyzer.h.

{return m_ExcludeLate;}

failed()

bool ZDCPulseAnalyzer::failed ( ) const

inline

Definition at line 650 of file ZDCPulseAnalyzer.h.

{return m_fail;}

failSigCut()

bool ZDCPulseAnalyzer::failSigCut ( ) const

inline

Definition at line 670 of file ZDCPulseAnalyzer.h.

{return m_failSigCut;}

FillHistogram()

void ZDCPulseAnalyzer::FillHistogram ( bool refitLG )

inlineprivate

Definition at line 450 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_samplesNoise[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_samplesNoiseLGRefit[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_samplesNoise[isample]); 
      m_delayedHist->SetBinError(isample + 1, m_samplesNoise[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_samplesNoiseLGRefit[isample]); 
      m_delayedHistLGRefit->SetBinError(isample + 1, m_samplesNoiseLGRefit[isample]);
    }
      }
    }
  }

fitFailed()

bool ZDCPulseAnalyzer::fitFailed ( ) const

inline

Definition at line 660 of file ZDCPulseAnalyzer.h.

{return m_fitFailed;}

fitMinimumAmplitude()

bool ZDCPulseAnalyzer::fitMinimumAmplitude ( ) const

inline

Definition at line 667 of file ZDCPulseAnalyzer.h.

{return m_fitMinAmp;}

getADCPeakHG()

float ZDCPulseAnalyzer::getADCPeakHG ( ) const

inline

Definition at line 766 of file ZDCPulseAnalyzer.h.

{return m_ADCPeakHG;}

getADCPeakLG()

float ZDCPulseAnalyzer::getADCPeakLG ( ) const

inline

Definition at line 767 of file ZDCPulseAnalyzer.h.

{return m_ADCPeakLG;}

GetAmpError()

float ZDCPulseAnalyzer::GetAmpError ( ) const

inline

Definition at line 697 of file ZDCPulseAnalyzer.h.

{return m_ampError;}

GetAmplitude()

float ZDCPulseAnalyzer::GetAmplitude ( ) const

inline

Definition at line 696 of file ZDCPulseAnalyzer.h.

{return m_amplitude;}

getAmplitudeCorrection()

double ZDCPulseAnalyzer::getAmplitudeCorrection ( bool highGain )

private

Definition at line 715 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 695 of file ZDCPulseAnalyzer.h.

{return m_ampNoNonLin;}

GetBkgdMaxFraction()

float ZDCPulseAnalyzer::GetBkgdMaxFraction ( ) const

inline

Definition at line 783 of file ZDCPulseAnalyzer.h.

{return m_bkgdMaxFraction;}

GetChisq()

float ZDCPulseAnalyzer::GetChisq ( ) const

inline

Definition at line 684 of file ZDCPulseAnalyzer.h.

{return m_fitChisq;}

GetChisqRatio()

float ZDCPulseAnalyzer::GetChisqRatio ( ) const

inline

Definition at line 685 of file ZDCPulseAnalyzer.h.

{return m_chisqRatio;}

GetCombinedGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetCombinedGraph

(

bool

forceLG = false

)

Definition at line 2428 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 775 of file ZDCPulseAnalyzer.h.

{return m_delayedBaselineShift;}

GetDelayedBaselineCorr()

float ZDCPulseAnalyzer::GetDelayedBaselineCorr ( ) const

inline

Definition at line 786 of file ZDCPulseAnalyzer.h.

{return m_baselineCorr;}

GetDelayedBaselineShiftFit()

float ZDCPulseAnalyzer::GetDelayedBaselineShiftFit ( ) const

inline

Definition at line 785 of file ZDCPulseAnalyzer.h.

{return m_delayedBaselineShift;}

GetFitAmplitude()

float ZDCPulseAnalyzer::GetFitAmplitude ( ) const

inline

Definition at line 679 of file ZDCPulseAnalyzer.h.

{return m_fitAmplitude;}

GetFitExpAmp()

float ZDCPulseAnalyzer::GetFitExpAmp ( ) const

inline

Definition at line 692 of file ZDCPulseAnalyzer.h.

{return m_fitExpAmp;}

GetFitPostAmp()

float ZDCPulseAnalyzer::GetFitPostAmp ( ) const

inline

Definition at line 691 of file ZDCPulseAnalyzer.h.

{return m_postAmplitude;}

GetFitPostT0()

float ZDCPulseAnalyzer::GetFitPostT0 ( ) const

inline

Definition at line 690 of file ZDCPulseAnalyzer.h.

{return m_fitPostT0;}

GetFitPreAmp()

float ZDCPulseAnalyzer::GetFitPreAmp ( ) const

inline

Definition at line 689 of file ZDCPulseAnalyzer.h.

{return m_preAmplitude;}

GetFitPreT0()

float ZDCPulseAnalyzer::GetFitPreT0 ( ) const

inline

Definition at line 688 of file ZDCPulseAnalyzer.h.

{return m_fitPreT0;}

GetFitPulls()

std::vector< float > ZDCPulseAnalyzer::GetFitPulls

(

bool

forceLG = false

)

const

Definition at line 678 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 680 of file ZDCPulseAnalyzer.h.

{return m_fitTime;}

GetFitTau1()

float ZDCPulseAnalyzer::GetFitTau1 ( ) const

inline

Definition at line 686 of file ZDCPulseAnalyzer.h.

{return m_fitTau1;}

GetFitTau2()

float ZDCPulseAnalyzer::GetFitTau2 ( ) const

inline

Definition at line 687 of file ZDCPulseAnalyzer.h.

{return m_fitTau2;}

GetFitTMax()

float ZDCPulseAnalyzer::GetFitTMax ( ) const

inline

Definition at line 772 of file ZDCPulseAnalyzer.h.

{return m_fitTMax;}

GetFitTMin()

float ZDCPulseAnalyzer::GetFitTMin ( ) const

inline

Definition at line 773 of file ZDCPulseAnalyzer.h.

{return m_fitTMin;}

GetGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetGraph

(

bool

forceLG = false

)

Definition at line 2473 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 )

inline

Definition at line 788 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 562 of file ZDCPulseAnalyzer.h.

{return m_LGMode;}

getMaxADCHG()

float ZDCPulseAnalyzer::getMaxADCHG ( ) const

inline

Definition at line 745 of file ZDCPulseAnalyzer.h.

{return m_maxADCHG;}

getMaxADCLG()

float ZDCPulseAnalyzer::getMaxADCLG ( ) const

inline

Definition at line 746 of file ZDCPulseAnalyzer.h.

{return m_maxADCLG;}

getMaxADCSampleHG()

int ZDCPulseAnalyzer::getMaxADCSampleHG ( ) const

inline

Definition at line 760 of file ZDCPulseAnalyzer.h.

{return m_maxADCSampleHG;}

getMaxADCSampleLG()

int ZDCPulseAnalyzer::getMaxADCSampleLG ( ) const

inline

Definition at line 763 of file ZDCPulseAnalyzer.h.

{return m_maxADCSampleLG;}

getMaxADCSub()

float ZDCPulseAnalyzer::getMaxADCSub ( ) const

inline

Definition at line 750 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 769 of file ZDCPulseAnalyzer.h.

{return m_maxDelta;}

getMinADCHG()

float ZDCPulseAnalyzer::getMinADCHG ( ) const

inline

Definition at line 747 of file ZDCPulseAnalyzer.h.

{return m_minADCHG;}

getMinADCLG()

float ZDCPulseAnalyzer::getMinADCLG ( ) const

inline

Definition at line 748 of file ZDCPulseAnalyzer.h.

{return m_minADCLG;}

getMinADCSampleHG()

int ZDCPulseAnalyzer::getMinADCSampleHG ( ) const

inline

Definition at line 761 of file ZDCPulseAnalyzer.h.

{return m_minADCSampleHG;}

getMinADCSampleLG()

int ZDCPulseAnalyzer::getMinADCSampleLG ( ) const

inline

Definition at line 764 of file ZDCPulseAnalyzer.h.

{return m_minADCSampleLG;}

getMinADCSub()

float ZDCPulseAnalyzer::getMinADCSub ( ) const

inline

Definition at line 755 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 770 of file ZDCPulseAnalyzer.h.

{return m_minDelta;}

GetMinDeriv2nd()

float ZDCPulseAnalyzer::GetMinDeriv2nd ( ) const

inline

Definition at line 777 of file ZDCPulseAnalyzer.h.

{return m_minDeriv2nd;}

GetMinDeriv2ndIndex()

float ZDCPulseAnalyzer::GetMinDeriv2ndIndex ( ) const

inline

Definition at line 778 of file ZDCPulseAnalyzer.h.

{return m_minDeriv2ndIndex;}

GetPreExpAmp()

float ZDCPulseAnalyzer::GetPreExpAmp ( ) const

inline

Definition at line 698 of file ZDCPulseAnalyzer.h.

{return m_expAmplitude;}

getPresample()

float ZDCPulseAnalyzer::getPresample ( ) const

inline

Definition at line 744 of file ZDCPulseAnalyzer.h.

{return m_preSample;}

GetPreSampleAmp()

float ZDCPulseAnalyzer::GetPreSampleAmp ( ) const

inline

Definition at line 782 of file ZDCPulseAnalyzer.h.

{return m_preSampleAmp;}

getRefitLGAmp()

float ZDCPulseAnalyzer::getRefitLGAmp ( ) const

inline

Definition at line 702 of file ZDCPulseAnalyzer.h.

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

getRefitLGAmpCorr()

float ZDCPulseAnalyzer::getRefitLGAmpCorr ( ) const

inline

Definition at line 714 of file ZDCPulseAnalyzer.h.

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

getRefitLGChisq()

float ZDCPulseAnalyzer::getRefitLGChisq ( ) const

inline

Definition at line 720 of file ZDCPulseAnalyzer.h.

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

getRefitLGChisqRatio()

float ZDCPulseAnalyzer::getRefitLGChisqRatio ( ) const

inline

Definition at line 726 of file ZDCPulseAnalyzer.h.

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

getRefitLGFitAmp()

float ZDCPulseAnalyzer::getRefitLGFitAmp ( ) const

inline

Definition at line 708 of file ZDCPulseAnalyzer.h.

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

getRefitLGTime()

float ZDCPulseAnalyzer::getRefitLGTime ( ) const

inline

Definition at line 732 of file ZDCPulseAnalyzer.h.

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

getRefitLGTimeSub()

float ZDCPulseAnalyzer::getRefitLGTimeSub ( ) const

inline

Definition at line 738 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 810 of file ZDCPulseAnalyzer.h.

{return m_samplesDeriv2nd;}

GetSamplesSub()

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

inline

Definition at line 809 of file ZDCPulseAnalyzer.h.

{return m_samplesSub;}

GetShapeParameters()

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

inline

Definition at line 700 of file ZDCPulseAnalyzer.h.

{return m_shapeParameters;}

GetStatusMask()

unsigned int ZDCPulseAnalyzer::GetStatusMask

(

)

const

Definition at line 2396 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;
  if (armSumInclude()) statusMask |= 1 << ArmSumIncludeBit;
  if (failSigCut()) statusMask |= 1 << FailSigCutBit;
  if (underflowExclusion()) statusMask |= 1<<UnderFlowExclusionBit;
 
  return statusMask;
}

GetT0Corr()

float ZDCPulseAnalyzer::GetT0Corr ( ) const

inline

Definition at line 682 of file ZDCPulseAnalyzer.h.

{return m_fitTimeCorr;}

GetT0Sub()

float ZDCPulseAnalyzer::GetT0Sub ( ) const

inline

Definition at line 681 of file ZDCPulseAnalyzer.h.

{return m_fitTimeSub;}

getTimeSig()

float ZDCPulseAnalyzer::getTimeSig ( ) const

inline

Definition at line 683 of file ZDCPulseAnalyzer.h.

{return m_timeSig;}

HaveData()

bool ZDCPulseAnalyzer::HaveData ( ) const

inline

Definition at line 643 of file ZDCPulseAnalyzer.h.

{return m_haveData;}

havePulse()

bool ZDCPulseAnalyzer::havePulse ( ) const

inline

Definition at line 648 of file ZDCPulseAnalyzer.h.

{return m_havePulse;}

HGOverflow()

bool ZDCPulseAnalyzer::HGOverflow ( ) const

inline

Definition at line 651 of file ZDCPulseAnalyzer.h.

{return m_HGOverflow;}

HGUnderflow()

bool ZDCPulseAnalyzer::HGUnderflow ( ) const

inline

Definition at line 653 of file ZDCPulseAnalyzer.h.

{return m_HGUnderflow;}

initialize()

void ZDCPulseAnalyzer::initialize ( )

private

Definition at line 345 of file ZDCPulseAnalyzer.cxx.

{
  m_NSamplesAna  = m_Nsample*(m_useDelayed ? 2 : 1);
  
  m_ADCSamplesHGSub.reserve(m_NSamplesAna);
  m_ADCSamplesLGSub.reserve(m_NSamplesAna);
  m_ADCSSampNoiseHG.reserve(m_NSamplesAna);
  m_ADCSSampNoiseLG.reserve(m_NSamplesAna); 
  m_samplesSub.reserve(m_NSamplesAna);
  m_samplesNoise.reserve(m_NSamplesAna);
 
  m_initialized = true;
}

LGOverflow()

bool ZDCPulseAnalyzer::LGOverflow ( ) const

inline

Definition at line 655 of file ZDCPulseAnalyzer.h.

{return m_LGOverflow;}

LGUnderflow()

bool ZDCPulseAnalyzer::LGUnderflow ( ) const

inline

Definition at line 656 of file ZDCPulseAnalyzer.h.

{return m_LGUnderflow;}

LoadAndAnalyzeData() [1/2]

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

Definition at line 860 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_initialized) initialize();
  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 886 of file ZDCPulseAnalyzer.cxx.

{
  if (!m_useDelayed) {
    (*m_msgFunc_p)(ZDCMsg::Fatal, "ZDCPulseAnalyzer::LoadAndAnalyzeData:: Wrong LoadAndAnalyzeData called -- expecting only undelayed samples");
  }
 
  if (!m_initialized) initialize();
  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;
  }
 
  // +++ BAC Mar 22, 2026
  // Trying to rationalize the initialization/handling of transient data. These line should not be necessary. Thus commented
  // ---
  //
  // 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 2206 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) < (1e-6)*std::abs(parLimitLow)) {
      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 2576 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 659 of file ZDCPulseAnalyzer.h.

{return m_postPulse;}

preExpTail()

bool ZDCPulseAnalyzer::preExpTail ( ) const

inline

Definition at line 666 of file ZDCPulseAnalyzer.h.

{return m_preExpTail;}

prepareLGRefit()

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

private

Definition at line 1686 of file ZDCPulseAnalyzer.cxx.

{
  m_samplesLGRefit.clear();
  m_samplesNoiseLGRefit.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_samplesNoiseLGRefit.push_back(samplesNoise[idx]);
    }
    else {
      m_samplesNoiseLGRefit.push_back(0);
    }
  }
}

prePulse()

bool ZDCPulseAnalyzer::prePulse ( ) const

inline

Definition at line 658 of file ZDCPulseAnalyzer.h.

{return m_prePulse;}

PSHGOverUnderflow()

bool ZDCPulseAnalyzer::PSHGOverUnderflow ( ) const

inline

Definition at line 654 of file ZDCPulseAnalyzer.h.

{return m_PSHGOverUnderflow;}

quietFits()

bool ZDCPulseAnalyzer::quietFits ( ) const

inline

Definition at line 520 of file ZDCPulseAnalyzer.h.

{return m_quietFits;}

ReanalyzeData()

bool ZDCPulseAnalyzer::ReanalyzeData

(

)

Definition at line 943 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 668 of file ZDCPulseAnalyzer.h.

{return m_repassPulse;}

reset()

void ZDCPulseAnalyzer::reset ( bool reanalyze = false )

private

Definition at line 359 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_underflowExclusion = 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;
    
    m_ADCSamplesHGSub.assign(m_NSamplesAna, 0);
    m_ADCSamplesLGSub.assign(m_NSamplesAna, 0);
    
    m_useSampleHG.assign(m_NSamplesAna, true);
    m_useSampleLG.assign(m_NSamplesAna, true);
 
    if (m_havePerSampleNoiseHG) {
      m_sampleNoiseHG = m_setPerSampleNoiseHG;
    }
    else {
      m_sampleNoiseHG.assign(m_NSamplesAna, m_noiseSigHG);
    }
    
    if (m_havePerSampleNoiseLG) {
      m_sampleNoiseLG = m_setPerSampleNoiseLG;
    }
    else {
      m_sampleNoiseLG.assign(m_NSamplesAna, 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_fitPulls.assign(m_NSamplesAna, 0);
  }
 
  
  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_failSigCut = 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_chisqRatio = 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();
}

saveFitFunc()

void ZDCPulseAnalyzer::saveFitFunc ( bool save )

inline

Definition at line 518 of file ZDCPulseAnalyzer.h.

{m_saveFitFunc = save;}

ScanAndSubtractSamples()

bool ZDCPulseAnalyzer::ScanAndSubtractSamples ( )

private

Definition at line 955 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());
  }
 
  // 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 we have the per-sample FADC correction, we apply it after pedestal correction
    //   since we analyze the FADC response after baseline (~ same as pedestal) subtraction
    //
    if (m_haveFADCCorrections && m_FADCCorrPerSample) {
      double fadcCorrHG = m_FADCCorrHG->Interpolate(m_ADCSamplesHGSub[isample]);
      double fadcCorrLG = m_FADCCorrLG->Interpolate(m_ADCSamplesLGSub[isample]);
 
      m_ADCSamplesHGSub[isample] *= fadcCorrHG;
      m_ADCSamplesLGSub[isample] *= fadcCorrLG;
 
      if (doDump) {
    std::ostringstream dumpString;
    dumpString << "After FADC correction, sample " << isample << ", HG ADC = " << m_ADCSamplesHGSub[isample]
           << ", LG ADC = " << m_ADCSamplesLGSub[isample] << std::endl;
    (*m_msgFunc_p)(ZDCMsg::Verbose, dumpString.str().c_str());
      }
    }
 
    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) {
    if (m_enableUnderflowExclHG && (isample < m_underFlowExclSamplesPreHG ||
                    isample >= m_NSamplesAna - m_underFlowExclSamplesPostHG)) {
      m_useSampleHG[isample] = false;
      m_underflowExclusion = true;
    }
    else {
      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) {
    if (m_enableUnderflowExclLG && (isample < m_underFlowExclSamplesPreLG ||
                    isample >= m_NSamplesAna - m_underFlowExclSamplesPostLG)) {
      m_underflowExclusion = true;
      m_useSampleLG[isample] = false;
    }
    else {
      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;
    }
  }
 
  return true;
}

set2ndDerivStep()

void ZDCPulseAnalyzer::set2ndDerivStep ( size_t step )

inline

Definition at line 564 of file ZDCPulseAnalyzer.h.

{m_2ndDerivStep = step;}

SetADCOverUnderflowValues()

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

Definition at line 561 of file ZDCPulseAnalyzer.cxx.

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

SetChisqCuts()

void ZDCPulseAnalyzer::SetChisqCuts	(	float	chisqDivAmpCutHG,
		float	chisqDivAmpScaleHG,
		float	chisqDivAmpOffsetHG,
		float	chisqDivAmpPowerHG,
		float	chisqDivAmpCutLG,
		float	chisqDivAmpScaleLG,
		float	chisqDivAmpOffsetLG,
		float	chisqDivAmpPowerLG )

Definition at line 601 of file ZDCPulseAnalyzer.cxx.

{
  m_chisqDivAmpCutHG = chisqDivAmpCutHG;
  m_chisqDivAmpScaleHG = chisqDivAmpScaleHG;
  m_chisqDivAmpOffsetHG = chisqDivAmpOffsetHG; 
  m_chisqDivAmpPowerHG = chisqDivAmpPowerHG;
 
  m_chisqDivAmpCutLG = chisqDivAmpCutLG;
  m_chisqDivAmpScaleLG = chisqDivAmpScaleLG;
  m_chisqDivAmpOffsetLG = chisqDivAmpOffsetLG; 
  m_chisqDivAmpPowerLG = chisqDivAmpPowerLG;
}

SetCutValues()

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

Definition at line 568 of file ZDCPulseAnalyzer.cxx.

{
  m_chisqDivAmpCutHG = chisqDivAmpCutHG;
  m_chisqDivAmpCutLG = chisqDivAmpCutLG;
 
  m_chisqDivAmpOffsetHG = 0;
  m_chisqDivAmpOffsetLG = 0;
 
  m_chisqDivAmpPowerHG = 1.0;
  m_chisqDivAmpPowerLG = 1.0;
 
  m_chisqDivAmpScaleHG = 1.0;
  m_chisqDivAmpScaleLG = 1.0;
 
  m_T0CutLowHG = deltaT0MinHG;
  m_T0CutLowLG = deltaT0MinLG;
 
  m_T0CutHighHG = deltaT0MaxHG;
  m_T0CutHighLG = deltaT0MaxLG;
}

setDefaults()

void ZDCPulseAnalyzer::setDefaults ( )

private

Definition at line 262 of file ZDCPulseAnalyzer.cxx.

{
  m_LGMode = LGModeNormal;
  
  m_nominalTau1 = 1.5;
  m_nominalTau2 = 5;
 
  m_fixTau1 = false;
  m_fixTau2 = false;
 
  m_HGOverflowADC  = 3500;
  m_HGUnderflowADC = 1;
  m_LGOverflowADC  = 3900;
 
  // Default values for the gain factors uswed to match low and high gain
  //
  m_gainFactorLG = 10;
  m_gainFactorHG = 1;
 
  m_2ndDerivStep = 1;
 
  m_noiseSigHG = 1;
  m_noiseSigLG = 1;
 
  m_sigMinLG = 0;
  m_sigMinHG = 0;
  
  m_timeCutMode = 0;
  m_chisqDivAmpCutLG = 100;
  m_chisqDivAmpCutHG = 100;
 
  m_chisqDivAmpOffsetLG = 1e-6;
  m_chisqDivAmpOffsetHG = 150;
 
  m_chisqDivAmpScaleLG = 1;
  m_chisqDivAmpScaleHG = 1;
 
  m_chisqDivAmpPowerLG = 1.2;
  m_chisqDivAmpPowerHG = 1.2;
 
  m_LGT0CorrParams.assign(6, 0);
  m_HGT0CorrParams.assign(6, 0);
 
  // m_defaultFitTMax = m_tmax;
  // m_defaultFitTMin = m_tmin;
  
  m_fitAmpMinHG = 1;
  m_fitAmpMinLG = 1;
 
  m_fitAmpMaxHG = 1500;
  m_fitAmpMaxLG = 1500;
 
  m_haveSignifCuts = false;
 
  m_peak2ndDerivMinTolerance = 1;
 
  m_doPostPulseCheck = true;
  m_postPulseDelta = 1;
  m_postPulseDerivMinSig = 5;
  m_postPulseAbsDer2ndMinSig = 5;
  m_postPulseMainMinDer2ndRatio = 0.05;
 
  m_prePulseDelta = 2;
  
  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_quietFits = true;
  m_saveFitFunc = false;
  m_fitOptions = "s";
}

SetFitMinMaxAmp()

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

Definition at line 522 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 517 of file ZDCPulseAnalyzer.h.

{ m_fitOptions = fitOptions;}

SetFitTimeMax()

void ZDCPulseAnalyzer::SetFitTimeMax

(

float

tmax

)

Definition at line 549 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);
 
  if (m_initializedFits) SetupFitFunctions();
}

SetGainFactorsHGLG()

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

Definition at line 516 of file ZDCPulseAnalyzer.cxx.

{
  m_gainFactorHG = gainFactorHG;
  m_gainFactorLG = gainFactorLG;
}

setLGMode()

void ZDCPulseAnalyzer::setLGMode ( unsigned int mode )

inline

Definition at line 561 of file ZDCPulseAnalyzer.h.

{m_LGMode = mode;}

setMinimumSignificance()

void ZDCPulseAnalyzer::setMinimumSignificance	(	float	sigMinHG,
		float	sigMinLG )

Definition at line 509 of file ZDCPulseAnalyzer.cxx.

{
  m_haveSignifCuts = true;
  m_sigMinHG = sigMinHG;
  m_sigMinLG = sigMinLG;
}

SetNoiseSigmas()

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

inline

Definition at line 576 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 610 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, std::move(HGParamsStr));
    (*m_msgFunc_p)(ZDCMsg::Info, std::move(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 548 of file ZDCPulseAnalyzer.h.

                                                     {
    m_peak2ndDerivMinTolerance = tolerance;
    m_initializedFits = false;
  }

setPerSampleNoiseSigmas()

void ZDCPulseAnalyzer::setPerSampleNoiseSigmas ( const std::vector< float > & sigmaHG, const std::vector< float > & sigmaLG )

inline

Definition at line 553 of file ZDCPulseAnalyzer.h.

  {
    m_setPerSampleNoiseHG =  sigmaHG;
    m_setPerSampleNoiseLG =  sigmaLG;
    m_havePerSampleNoiseHG = true;
    m_havePerSampleNoiseLG = true;
  }

setQuietFits()

void ZDCPulseAnalyzer::setQuietFits ( )

inline

Definition at line 521 of file ZDCPulseAnalyzer.h.

{m_quietFits = true;}

SetTauT0Values()

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

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

SetTimeCuts()

void ZDCPulseAnalyzer::SetTimeCuts	(	float	deltaT0MinHG,
		float	deltaT0MaxHG,
		float	deltaT0MinLG,
		float	deltaT0MaxLG )

Definition at line 591 of file ZDCPulseAnalyzer.cxx.

{
  m_T0CutLowHG = deltaT0MinHG;
  m_T0CutLowLG = deltaT0MinLG;
 
  m_T0CutHighHG = deltaT0MaxHG;
  m_T0CutHighLG = deltaT0MaxLG;
}

SetTimingCorrParams()

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

inline

Definition at line 595 of file ZDCPulseAnalyzer.h.

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

setUnquietFits()

void ZDCPulseAnalyzer::setUnquietFits ( )

inline

Definition at line 522 of file ZDCPulseAnalyzer.h.

{m_quietFits = false;}

SetupFitFunctions()

void ZDCPulseAnalyzer::SetupFitFunctions ( )

private

Definition at line 755 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 == "FermiExpInduct") {
    //
    // Use the variable tau version of the expFermiFit
    //
    m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTausInduct(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2,
                                                  m_nominalTau1, m_nominalTau2));
    m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiInductPreExp>(new ZDCFitExpFermiInductPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
 
    // We still have to implement the pre-pulse version of the new induct function For now, using old ("LHCf") version
    //
    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;
}

underflowExclusion()

bool ZDCPulseAnalyzer::underflowExclusion ( ) const

inline

Definition at line 671 of file ZDCPulseAnalyzer.h.

{return m_underflowExclusion;}

UpdateFitterTimeLimits()

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

private

Definition at line 2244 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 649 of file ZDCPulseAnalyzer.h.

{return m_useLowGain;}

ValidateJSONConfig()

std::pair< bool, std::string > ZDCPulseAnalyzer::ValidateJSONConfig ( const JSON & config )

private

Definition at line 2633 of file ZDCPulseAnalyzer.cxx.

{
  bool result = true;
  std::string resultString = "success";
 
  for (auto [key, descr] : JSONConfigParams) {
    auto iter = config.find(key);
    if (iter != config.end()) {
      //
      // Check type consistency
      //
      auto jsonType = iter.value().type();
      auto paramType = std::get<0>(descr);
      if (jsonType != paramType) {
    result = false;
    resultString = "Bad type for parameter " + key + ", type in JSON = " + std::to_string((unsigned int) jsonType) ;
    break;
      }
      
      size_t paramSize = std::get<1>(descr);
      size_t jsonSize = iter.value().size();
      if (jsonSize != paramSize) {
    result = false;
    resultString = "Bad length for parameter " + key + ", length in JSON = " + std::to_string(jsonSize) ;
    break;
      }
    }
    else {
      bool required = std::get<2>(descr);
      if (required) {
    result = false;
    resultString = "Missing required parameter " + key;
    break;
      }
    }
  }
 
  if (result) {
    //
    // Now check that the parameters in the JSON object are in the master list of parameters 
    //
    for (auto [key, value] : config.items()) {
      //
      // Look for this key in the list of allowed parameters. Yes, it's a slow 
      //   search but we only do it once at configuration time.
      //
      // bool found = false;
      auto iter = JSONConfigParams.find(key);
      if (iter == JSONConfigParams.end()) {
    result = false;
    resultString = "Unknown parameter, key = " + key;
    break;
      }
    }
  }
  
  return {result, resultString};
}

Member Data Documentation

JSONConfigParams

const ZDCJSONConfig::JSONParamList ZDCPulseAnalyzer::JSONConfigParams

static

Definition at line 33 of file ZDCPulseAnalyzer.h.

                   {
    LGModeNormal = 0,
    LGModeForceLG,
    LGModeRefitLG
  };
  
  enum TimingCorrMode {NoTimingCorr = 0, TimingCorrLin, TimingCorrLog};
 
  //
  // List of allowed JSON configuration parameters
  //
  //  For each parameter we have name, JSON value type, whether it can be set per channel, and whether it is required
  //
  //  if the type is -1, then there's no value, the presence of the parameter itself is a boolean -- i.e. enabling  
  //
  
  static const ZDCJSONConfig::JSONParamList JSONConfigParams;
private:
  typedef std::vector<float>::const_iterator SampleCIter;
 
  //  Static data
  //
  
  static TH1* s_undelayedFitHist;
  static TH1* s_delayedFitHist;
  static TF1* s_combinedFitFunc;
  static float s_combinedFitTMax;
  static float s_combinedFitTMin;
  static std::vector<float> s_pullValues;
 
  // Quantities provided/set in the constructor
  //
  ZDCMsg::MessageFunctionPtr m_msgFunc_p{};
  std::string m_tag{};
  unsigned int m_Nsample{};
  unsigned int m_preSampleIdx{};
  float m_freqMHz{};
  float m_deltaTSample{};
  int m_pedestal{};
  unsigned int m_LGMode{LGModeNormal};

m_2ndDerivStep

size_t ZDCPulseAnalyzer::m_2ndDerivStep {1}

private

Definition at line 103 of file ZDCPulseAnalyzer.h.

{1};

m_ADCPeakHG

float ZDCPulseAnalyzer::m_ADCPeakHG {}

private

Definition at line 313 of file ZDCPulseAnalyzer.h.

{};

m_ADCPeakLG

float ZDCPulseAnalyzer::m_ADCPeakLG {}

private

Definition at line 314 of file ZDCPulseAnalyzer.h.

{};

m_ADCSamplesHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHG

private

Definition at line 380 of file ZDCPulseAnalyzer.h.

m_ADCSamplesHGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHGSub

private

Definition at line 382 of file ZDCPulseAnalyzer.h.

m_ADCSamplesLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLG

private

Definition at line 381 of file ZDCPulseAnalyzer.h.

m_ADCSamplesLGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLGSub

private

Definition at line 383 of file ZDCPulseAnalyzer.h.

m_ADCSSampNoiseHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampNoiseHG

private

Definition at line 390 of file ZDCPulseAnalyzer.h.

m_ADCSSampNoiseLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampNoiseLG

private

Definition at line 391 of file ZDCPulseAnalyzer.h.

m_adjTimeRangeEvent

bool ZDCPulseAnalyzer::m_adjTimeRangeEvent {false}

private

Definition at line 243 of file ZDCPulseAnalyzer.h.

{false}; // indicates whether we adjust the time range for this specific event

m_ampError

float ZDCPulseAnalyzer::m_ampError {}

private

Definition at line 356 of file ZDCPulseAnalyzer.h.

{};

m_amplitude

float ZDCPulseAnalyzer::m_amplitude {}

private

Definition at line 354 of file ZDCPulseAnalyzer.h.

{};

m_ampNoNonLin

float ZDCPulseAnalyzer::m_ampNoNonLin {}

private

Definition at line 355 of file ZDCPulseAnalyzer.h.

{};

m_backToHG_pre

bool ZDCPulseAnalyzer::m_backToHG_pre {false}

private

Definition at line 295 of file ZDCPulseAnalyzer.h.

{false};

m_badChisq

bool ZDCPulseAnalyzer::m_badChisq {false}

private

Definition at line 280 of file ZDCPulseAnalyzer.h.

{false};

m_badT0

bool ZDCPulseAnalyzer::m_badT0 {false}

private

Definition at line 282 of file ZDCPulseAnalyzer.h.

{false};

m_baselineCorr

float ZDCPulseAnalyzer::m_baselineCorr {}

private

Definition at line 296 of file ZDCPulseAnalyzer.h.

{};

m_bkgdMaxFraction

float ZDCPulseAnalyzer::m_bkgdMaxFraction {}

private

Definition at line 361 of file ZDCPulseAnalyzer.h.

{};

m_chisqDivAmpCutHG

float ZDCPulseAnalyzer::m_chisqDivAmpCutHG {}

private

Definition at line 150 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpCutLG

float ZDCPulseAnalyzer::m_chisqDivAmpCutLG {}

private

Definition at line 149 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqDivAmpOffsetHG

float ZDCPulseAnalyzer::m_chisqDivAmpOffsetHG {}

private

Definition at line 154 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpOffsetLG

float ZDCPulseAnalyzer::m_chisqDivAmpOffsetLG {}

private

Definition at line 153 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqDivAmpPowerHG

float ZDCPulseAnalyzer::m_chisqDivAmpPowerHG {}

private

Definition at line 156 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpPowerLG

float ZDCPulseAnalyzer::m_chisqDivAmpPowerLG {}

private

Definition at line 155 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqDivAmpScaleHG

float ZDCPulseAnalyzer::m_chisqDivAmpScaleHG {}

private

Definition at line 152 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpScaleLG

float ZDCPulseAnalyzer::m_chisqDivAmpScaleLG {}

private

Definition at line 151 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqRatio

float ZDCPulseAnalyzer::m_chisqRatio {}

private

Definition at line 347 of file ZDCPulseAnalyzer.h.

{};

m_defaultCombinedFitter

std::unique_ptr<TFitter> ZDCPulseAnalyzer::m_defaultCombinedFitter {}

private

Definition at line 257 of file ZDCPulseAnalyzer.h.

{};

m_defaultFitTMax

float ZDCPulseAnalyzer::m_defaultFitTMax {}

private

Definition at line 146 of file ZDCPulseAnalyzer.h.

{};   // user-provided upper limit on samples to be included in fit

m_defaultFitTMin

float ZDCPulseAnalyzer::m_defaultFitTMin {}

private

Definition at line 147 of file ZDCPulseAnalyzer.h.

{};   // user-provided upper limit on samples to be included in fit

m_defaultFitWrapper

std::unique_ptr<ZDCFitWrapper> ZDCPulseAnalyzer::m_defaultFitWrapper {}

private

Definition at line 237 of file ZDCPulseAnalyzer.h.

{};

m_defaultT0Max

float ZDCPulseAnalyzer::m_defaultT0Max {}

private

Definition at line 169 of file ZDCPulseAnalyzer.h.

{};   // Upper limit on pulse t0

m_defaultT0Min

float ZDCPulseAnalyzer::m_defaultT0Min {}

private

Definition at line 170 of file ZDCPulseAnalyzer.h.

{};   // Lower limit on pulse t0

m_delayedBaselineShift

float ZDCPulseAnalyzer::m_delayedBaselineShift {}

private

Definition at line 362 of file ZDCPulseAnalyzer.h.

{};

m_delayedDeltaT

float ZDCPulseAnalyzer::m_delayedDeltaT {}

private

Definition at line 251 of file ZDCPulseAnalyzer.h.

{};

m_delayedHist

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_delayedHist {}

private

Definition at line 253 of file ZDCPulseAnalyzer.h.

{};

m_delayedHistLGRefit

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_delayedHistLGRefit {}

private

Definition at line 254 of file ZDCPulseAnalyzer.h.

{};

m_delayedPedestalDiff

float ZDCPulseAnalyzer::m_delayedPedestalDiff {}

private

Definition at line 252 of file ZDCPulseAnalyzer.h.

{};

m_deltaTSample

float ZDCPulseAnalyzer::m_deltaTSample {}

private

Definition at line 93 of file ZDCPulseAnalyzer.h.

{};

m_doPostPulseCheck

bool ZDCPulseAnalyzer::m_doPostPulseCheck {false}

private

Definition at line 184 of file ZDCPulseAnalyzer.h.

{false};

m_enablePostExcl

bool ZDCPulseAnalyzer::m_enablePostExcl {false}

private

Definition at line 199 of file ZDCPulseAnalyzer.h.

{false};

m_enablePreExcl

bool ZDCPulseAnalyzer::m_enablePreExcl {false}

private

Definition at line 194 of file ZDCPulseAnalyzer.h.

{false};

m_enableRepass

bool ZDCPulseAnalyzer::m_enableRepass {false}

private

Definition at line 111 of file ZDCPulseAnalyzer.h.

{false};

m_enableUnderflowExclHG

bool ZDCPulseAnalyzer::m_enableUnderflowExclHG {false}

private

Definition at line 204 of file ZDCPulseAnalyzer.h.

{false};

m_enableUnderflowExclLG

bool ZDCPulseAnalyzer::m_enableUnderflowExclLG {false}

private

Definition at line 205 of file ZDCPulseAnalyzer.h.

{false};

m_evtLGRefit

bool ZDCPulseAnalyzer::m_evtLGRefit {false}

private

Definition at line 366 of file ZDCPulseAnalyzer.h.

{false};

m_ExcludeEarly

bool ZDCPulseAnalyzer::m_ExcludeEarly {false}

private

Definition at line 283 of file ZDCPulseAnalyzer.h.

{false};

m_ExcludeLate

bool ZDCPulseAnalyzer::m_ExcludeLate {false}

private

Definition at line 284 of file ZDCPulseAnalyzer.h.

{false};

m_expAmplitude

float ZDCPulseAnalyzer::m_expAmplitude {}

private

Definition at line 360 of file ZDCPulseAnalyzer.h.

{};

m_fadcCorrFileName

std::string ZDCPulseAnalyzer::m_fadcCorrFileName

private

Definition at line 225 of file ZDCPulseAnalyzer.h.

m_FADCCorrHG

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

private

Definition at line 227 of file ZDCPulseAnalyzer.h.

{};

m_FADCCorrLG

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

private

Definition at line 228 of file ZDCPulseAnalyzer.h.

{};

m_FADCCorrPerSample

bool ZDCPulseAnalyzer::m_FADCCorrPerSample {false}

private

Definition at line 226 of file ZDCPulseAnalyzer.h.

{false};

m_fail

bool ZDCPulseAnalyzer::m_fail {false}

private

Definition at line 269 of file ZDCPulseAnalyzer.h.

{false};

m_failSigCut

bool ZDCPulseAnalyzer::m_failSigCut {false}

private

Definition at line 290 of file ZDCPulseAnalyzer.h.

{false};

m_firstHGOverFlowSample

int ZDCPulseAnalyzer::m_firstHGOverFlowSample {-1}

private

Definition at line 377 of file ZDCPulseAnalyzer.h.

{-1};

m_fitAmpError

float ZDCPulseAnalyzer::m_fitAmpError {}

private

Definition at line 338 of file ZDCPulseAnalyzer.h.

{};

m_fitAmplitude

float ZDCPulseAnalyzer::m_fitAmplitude {}

private

Definition at line 337 of file ZDCPulseAnalyzer.h.

{};

m_fitAmpMaxHG

float ZDCPulseAnalyzer::m_fitAmpMaxHG {}

private

Definition at line 175 of file ZDCPulseAnalyzer.h.

{};      // Minimum am`plitude in the fit

m_fitAmpMaxLG

float ZDCPulseAnalyzer::m_fitAmpMaxLG {}

private

Definition at line 176 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitAmpMinHG

float ZDCPulseAnalyzer::m_fitAmpMinHG {}

private

Definition at line 172 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitAmpMinLG

float ZDCPulseAnalyzer::m_fitAmpMinLG {}

private

Definition at line 173 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitChisq

float ZDCPulseAnalyzer::m_fitChisq {}

private

Definition at line 346 of file ZDCPulseAnalyzer.h.

{};

m_fitExpAmp

float ZDCPulseAnalyzer::m_fitExpAmp {}

private

Definition at line 353 of file ZDCPulseAnalyzer.h.

{};

m_fitFailed

bool ZDCPulseAnalyzer::m_fitFailed {false}

private

Definition at line 279 of file ZDCPulseAnalyzer.h.

{false};

m_fitFunction

std::string ZDCPulseAnalyzer::m_fitFunction

private

Definition at line 102 of file ZDCPulseAnalyzer.h.

m_fitHist

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_fitHist {}

private

Definition at line 232 of file ZDCPulseAnalyzer.h.

{};

m_fitHistLGRefit

std::unique_ptr<TH1> ZDCPulseAnalyzer::m_fitHistLGRefit {}

private

Definition at line 233 of file ZDCPulseAnalyzer.h.

{};

m_fitMinAmp

bool ZDCPulseAnalyzer::m_fitMinAmp {false}

private

Definition at line 288 of file ZDCPulseAnalyzer.h.

{false};

m_fitNDoF

float ZDCPulseAnalyzer::m_fitNDoF {}

private

Definition at line 348 of file ZDCPulseAnalyzer.h.

{};

m_fitOptions

std::string ZDCPulseAnalyzer::m_fitOptions {}

private

Definition at line 132 of file ZDCPulseAnalyzer.h.

{};

m_fitPostAmp

float ZDCPulseAnalyzer::m_fitPostAmp {}

private

Definition at line 352 of file ZDCPulseAnalyzer.h.

{};

m_fitPostT0

float ZDCPulseAnalyzer::m_fitPostT0 {}

private

Definition at line 351 of file ZDCPulseAnalyzer.h.

{};

m_fitPostT0lo

float ZDCPulseAnalyzer::m_fitPostT0lo {}

private

Definition at line 326 of file ZDCPulseAnalyzer.h.

{};      // use to assign lower bound of post pulse T0

m_fitPreAmp

float ZDCPulseAnalyzer::m_fitPreAmp {}

private

Definition at line 350 of file ZDCPulseAnalyzer.h.

{};

m_fitPreT0

float ZDCPulseAnalyzer::m_fitPreT0 {}

private

Definition at line 349 of file ZDCPulseAnalyzer.h.

{};

m_fitPulls

std::vector<float> ZDCPulseAnalyzer::m_fitPulls

private

Definition at line 407 of file ZDCPulseAnalyzer.h.

m_fitTau1

float ZDCPulseAnalyzer::m_fitTau1 {}

private

Definition at line 344 of file ZDCPulseAnalyzer.h.

{};

m_fitTau2

float ZDCPulseAnalyzer::m_fitTau2 {}

private

Definition at line 345 of file ZDCPulseAnalyzer.h.

{};

m_fitTCorr2nd

float ZDCPulseAnalyzer::m_fitTCorr2nd {}

private

Definition at line 343 of file ZDCPulseAnalyzer.h.

{};

m_fitTime

float ZDCPulseAnalyzer::m_fitTime {}

private

Definition at line 339 of file ZDCPulseAnalyzer.h.

{};

m_fitTimeCorr

float ZDCPulseAnalyzer::m_fitTimeCorr {}

private

Definition at line 341 of file ZDCPulseAnalyzer.h.

{};

m_fitTimeSub

float ZDCPulseAnalyzer::m_fitTimeSub {}

private

Definition at line 340 of file ZDCPulseAnalyzer.h.

{};

m_fitTMax

float ZDCPulseAnalyzer::m_fitTMax {}

private

Definition at line 323 of file ZDCPulseAnalyzer.h.

{};          // event-by-event specified fit tmax

m_fitTMin

float ZDCPulseAnalyzer::m_fitTMin {}

private

Definition at line 324 of file ZDCPulseAnalyzer.h.

{};          // event-by-event specified fit tmin

m_fixPrePulse

bool ZDCPulseAnalyzer::m_fixPrePulse {false}

private

Definition at line 287 of file ZDCPulseAnalyzer.h.

{false};

m_fixTau1

bool ZDCPulseAnalyzer::m_fixTau1 {}

private

Definition at line 143 of file ZDCPulseAnalyzer.h.

{};

m_fixTau2

bool ZDCPulseAnalyzer::m_fixTau2 {}

private

Definition at line 144 of file ZDCPulseAnalyzer.h.

{};

m_freqMHz

float ZDCPulseAnalyzer::m_freqMHz {}

private

Definition at line 92 of file ZDCPulseAnalyzer.h.

{};

m_gainFactorHG

float ZDCPulseAnalyzer::m_gainFactorHG {}

private

Definition at line 117 of file ZDCPulseAnalyzer.h.

{};

m_gainFactorLG

float ZDCPulseAnalyzer::m_gainFactorLG {}

private

Definition at line 118 of file ZDCPulseAnalyzer.h.

{};

m_haveData

bool ZDCPulseAnalyzer::m_haveData {false}

private

Definition at line 265 of file ZDCPulseAnalyzer.h.

{false};

m_haveFADCCorrections

bool ZDCPulseAnalyzer::m_haveFADCCorrections {false}

private

Definition at line 224 of file ZDCPulseAnalyzer.h.

{false};

m_haveNonlinCorr

bool ZDCPulseAnalyzer::m_haveNonlinCorr {false}

private

Definition at line 218 of file ZDCPulseAnalyzer.h.

{false};

m_havePerSampleNoiseHG

bool ZDCPulseAnalyzer::m_havePerSampleNoiseHG {false}

private

Definition at line 125 of file ZDCPulseAnalyzer.h.

{false};

m_havePerSampleNoiseLG

bool ZDCPulseAnalyzer::m_havePerSampleNoiseLG {false}

private

Definition at line 126 of file ZDCPulseAnalyzer.h.

{false};

m_havePulse

bool ZDCPulseAnalyzer::m_havePulse {false}

private

Definition at line 267 of file ZDCPulseAnalyzer.h.

{false};

m_haveSignifCuts

bool ZDCPulseAnalyzer::m_haveSignifCuts {false}

private

Definition at line 178 of file ZDCPulseAnalyzer.h.

{false};

m_HGOverflow

bool ZDCPulseAnalyzer::m_HGOverflow {false}

private

Definition at line 270 of file ZDCPulseAnalyzer.h.

{false};

m_HGOverflowADC

int ZDCPulseAnalyzer::m_HGOverflowADC {}

private

Definition at line 133 of file ZDCPulseAnalyzer.h.

{};

m_HGT0CorrParams

std::vector<float> ZDCPulseAnalyzer::m_HGT0CorrParams {}

private

Definition at line 216 of file ZDCPulseAnalyzer.h.

{}; // Parameters used to correct the fit HG times

m_HGUnderflow

bool ZDCPulseAnalyzer::m_HGUnderflow {false}

private

Definition at line 272 of file ZDCPulseAnalyzer.h.

{false};

m_HGUnderflowADC

int ZDCPulseAnalyzer::m_HGUnderflowADC {}

private

Definition at line 134 of file ZDCPulseAnalyzer.h.

{};

m_initialExpAmp

float ZDCPulseAnalyzer::m_initialExpAmp {}

private

Definition at line 319 of file ZDCPulseAnalyzer.h.

{};

m_initialized

bool ZDCPulseAnalyzer::m_initialized {false}

private

Definition at line 235 of file ZDCPulseAnalyzer.h.

{false};

m_initializedFits

bool ZDCPulseAnalyzer::m_initializedFits {false}

private

Definition at line 236 of file ZDCPulseAnalyzer.h.

{false};

m_initialPostPulseT0

float ZDCPulseAnalyzer::m_initialPostPulseT0 {}

private

Definition at line 335 of file ZDCPulseAnalyzer.h.

{};

m_initialPrePulseAmp

float ZDCPulseAnalyzer::m_initialPrePulseAmp {}

private

Definition at line 333 of file ZDCPulseAnalyzer.h.

{};

m_initialPrePulseT0

float ZDCPulseAnalyzer::m_initialPrePulseT0 {}

private

Definition at line 332 of file ZDCPulseAnalyzer.h.

{};

m_lastHGOverFlowSample

int ZDCPulseAnalyzer::m_lastHGOverFlowSample {-1}

private

Definition at line 376 of file ZDCPulseAnalyzer.h.

{-1};

m_LGMode

unsigned int ZDCPulseAnalyzer::m_LGMode {LGModeNormal}

private

Definition at line 95 of file ZDCPulseAnalyzer.h.

{LGModeNormal};

m_LGOverflow

bool ZDCPulseAnalyzer::m_LGOverflow {false}

private

Definition at line 274 of file ZDCPulseAnalyzer.h.

{false};

m_LGOverflowADC

int ZDCPulseAnalyzer::m_LGOverflowADC {}

private

Definition at line 135 of file ZDCPulseAnalyzer.h.

{};

m_LGT0CorrParams

std::vector<float> ZDCPulseAnalyzer::m_LGT0CorrParams {}

private

Definition at line 215 of file ZDCPulseAnalyzer.h.

{}; // Parameters used to correct the fit LG times

m_LGUnderflow

bool ZDCPulseAnalyzer::m_LGUnderflow {false}

private

Definition at line 275 of file ZDCPulseAnalyzer.h.

{false};

m_maxADCHG

float ZDCPulseAnalyzer::m_maxADCHG {}

private

Definition at line 304 of file ZDCPulseAnalyzer.h.

{};

m_maxADCLG

float ZDCPulseAnalyzer::m_maxADCLG {}

private

Definition at line 308 of file ZDCPulseAnalyzer.h.

{};

m_maxADCSampleHG

int ZDCPulseAnalyzer::m_maxADCSampleHG

private

Definition at line 306 of file ZDCPulseAnalyzer.h.

m_maxADCSampleLG

int ZDCPulseAnalyzer::m_maxADCSampleLG

private

Definition at line 311 of file ZDCPulseAnalyzer.h.

m_maxDelta

float ZDCPulseAnalyzer::m_maxDelta {}

private

Definition at line 316 of file ZDCPulseAnalyzer.h.

{};

m_maxSampleEvt

unsigned int ZDCPulseAnalyzer::m_maxSampleEvt {}

private

Definition at line 246 of file ZDCPulseAnalyzer.h.

{};

m_maxSamplesPostExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPostExcl {0}

private

Definition at line 202 of file ZDCPulseAnalyzer.h.

{0};

m_maxSamplesPreExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPreExcl {0}

private

Definition at line 195 of file ZDCPulseAnalyzer.h.

{0};

m_minADCHG

float ZDCPulseAnalyzer::m_minADCHG {}

private

Definition at line 303 of file ZDCPulseAnalyzer.h.

{};

m_minADCLG

float ZDCPulseAnalyzer::m_minADCLG {}

private

Definition at line 309 of file ZDCPulseAnalyzer.h.

{};

m_minADCSampleHG

int ZDCPulseAnalyzer::m_minADCSampleHG

private

Definition at line 305 of file ZDCPulseAnalyzer.h.

m_minADCSampleLG

int ZDCPulseAnalyzer::m_minADCSampleLG

private

Definition at line 310 of file ZDCPulseAnalyzer.h.

m_minDelta

float ZDCPulseAnalyzer::m_minDelta {}

private

Definition at line 317 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2nd

float ZDCPulseAnalyzer::m_minDeriv2nd {}

private

Definition at line 320 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2ndIndex

int ZDCPulseAnalyzer::m_minDeriv2ndIndex {}

private

Definition at line 321 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2ndSig

float ZDCPulseAnalyzer::m_minDeriv2ndSig

private

Definition at line 328 of file ZDCPulseAnalyzer.h.

m_minSampleEvt

unsigned int ZDCPulseAnalyzer::m_minSampleEvt {}

private

Definition at line 245 of file ZDCPulseAnalyzer.h.

{};

m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCPulseAnalyzer::m_msgFunc_p {}

private

Definition at line 88 of file ZDCPulseAnalyzer.h.

{};

m_noiseSigHG

float ZDCPulseAnalyzer::m_noiseSigHG {}

private

Definition at line 122 of file ZDCPulseAnalyzer.h.

{};

m_noiseSigLG

float ZDCPulseAnalyzer::m_noiseSigLG {}

private

Definition at line 123 of file ZDCPulseAnalyzer.h.

{};

m_nominalT0HG

float ZDCPulseAnalyzer::m_nominalT0HG {}

private

Definition at line 137 of file ZDCPulseAnalyzer.h.

{};

m_nominalT0LG

float ZDCPulseAnalyzer::m_nominalT0LG {}

private

Definition at line 138 of file ZDCPulseAnalyzer.h.

{};

m_nominalTau1

float ZDCPulseAnalyzer::m_nominalTau1 {}

private

Definition at line 140 of file ZDCPulseAnalyzer.h.

{};

m_nominalTau2

float ZDCPulseAnalyzer::m_nominalTau2 {}

private

Definition at line 141 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrParamsHG

std::vector<float> ZDCPulseAnalyzer::m_nonLinCorrParamsHG {}

private

Definition at line 221 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrParamsLG

std::vector<float> ZDCPulseAnalyzer::m_nonLinCorrParamsLG {}

private

Definition at line 222 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrRefADC

float ZDCPulseAnalyzer::m_nonLinCorrRefADC {500}

private

Definition at line 219 of file ZDCPulseAnalyzer.h.

{500};

m_nonLinCorrRefScale

float ZDCPulseAnalyzer::m_nonLinCorrRefScale {100}

private

Definition at line 220 of file ZDCPulseAnalyzer.h.

{100};

m_Nsample

unsigned int ZDCPulseAnalyzer::m_Nsample {}

private

Definition at line 90 of file ZDCPulseAnalyzer.h.

{};

m_NSamplesAna

unsigned int ZDCPulseAnalyzer::m_NSamplesAna {0}

private

Definition at line 379 of file ZDCPulseAnalyzer.h.

{0};

m_peak2ndDerivMinRepassHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassHG {}

private

Definition at line 113 of file ZDCPulseAnalyzer.h.

{};

m_peak2ndDerivMinRepassLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassLG {}

private

Definition at line 112 of file ZDCPulseAnalyzer.h.

{};

m_peak2ndDerivMinSample

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinSample {}

private

Definition at line 104 of file ZDCPulseAnalyzer.h.

{};

m_peak2ndDerivMinThreshHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshHG {}

private

Definition at line 107 of file ZDCPulseAnalyzer.h.

{};

m_peak2ndDerivMinThreshLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshLG {}

private

Definition at line 106 of file ZDCPulseAnalyzer.h.

{};

m_peak2ndDerivMinTolerance

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinTolerance {1}

private

Definition at line 105 of file ZDCPulseAnalyzer.h.

{1};

m_pedestal

int ZDCPulseAnalyzer::m_pedestal {}

private

Definition at line 94 of file ZDCPulseAnalyzer.h.

{};

m_postAmplitude

float ZDCPulseAnalyzer::m_postAmplitude {}

private

Definition at line 359 of file ZDCPulseAnalyzer.h.

{};

m_postExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclHGADCThresh {0}

private

Definition at line 200 of file ZDCPulseAnalyzer.h.

{0};

m_postExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclLGADCThresh {0}

private

Definition at line 201 of file ZDCPulseAnalyzer.h.

{0};

m_postPulse

bool ZDCPulseAnalyzer::m_postPulse {false}

private

Definition at line 278 of file ZDCPulseAnalyzer.h.

{false};

m_postPulseAbsDer2ndMinSig

float ZDCPulseAnalyzer::m_postPulseAbsDer2ndMinSig {}

private

Definition at line 187 of file ZDCPulseAnalyzer.h.

{};

m_postPulseDelta

unsigned int ZDCPulseAnalyzer::m_postPulseDelta {0}

private

Definition at line 185 of file ZDCPulseAnalyzer.h.

{0};

m_postPulseDerivMinSig

float ZDCPulseAnalyzer::m_postPulseDerivMinSig {}

private

Definition at line 186 of file ZDCPulseAnalyzer.h.

{};

m_postPulseMainMinDer2ndRatio

float ZDCPulseAnalyzer::m_postPulseMainMinDer2ndRatio {}

private

Definition at line 188 of file ZDCPulseAnalyzer.h.

{};

m_preAmplitude

float ZDCPulseAnalyzer::m_preAmplitude {}

private

Definition at line 358 of file ZDCPulseAnalyzer.h.

{};

m_preExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclHGADCThresh {0}

private

Definition at line 196 of file ZDCPulseAnalyzer.h.

{0};

m_preExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclLGADCThresh {0}

private

Definition at line 197 of file ZDCPulseAnalyzer.h.

{0};

m_preExpFitWrapper

std::unique_ptr<ZDCPreExpFitWrapper> ZDCPulseAnalyzer::m_preExpFitWrapper {}

private

Definition at line 239 of file ZDCPulseAnalyzer.h.

{};

m_preExpSig

float ZDCPulseAnalyzer::m_preExpSig

private

Definition at line 329 of file ZDCPulseAnalyzer.h.

m_preExpTail

bool ZDCPulseAnalyzer::m_preExpTail {false}

private

Definition at line 285 of file ZDCPulseAnalyzer.h.

{false};

m_prePulse

bool ZDCPulseAnalyzer::m_prePulse {false}

private

Definition at line 277 of file ZDCPulseAnalyzer.h.

{false};

m_prePulseCombinedFitter

std::unique_ptr<TFitter> ZDCPulseAnalyzer::m_prePulseCombinedFitter {}

private

Definition at line 256 of file ZDCPulseAnalyzer.h.

{};

m_prePulseDelta

unsigned int ZDCPulseAnalyzer::m_prePulseDelta {0}

private

Definition at line 190 of file ZDCPulseAnalyzer.h.

{0};

m_prePulseFitWrapper

std::unique_ptr<ZDCPrePulseFitWrapper> ZDCPulseAnalyzer::m_prePulseFitWrapper {}

private

Definition at line 238 of file ZDCPulseAnalyzer.h.

{};

m_prePulseSig

float ZDCPulseAnalyzer::m_prePulseSig

private

Definition at line 330 of file ZDCPulseAnalyzer.h.

m_preSample

float ZDCPulseAnalyzer::m_preSample {}

private

Definition at line 301 of file ZDCPulseAnalyzer.h.

{};

m_preSampleAmp

float ZDCPulseAnalyzer::m_preSampleAmp {}

private

Definition at line 357 of file ZDCPulseAnalyzer.h.

{};

m_preSampleIdx

unsigned int ZDCPulseAnalyzer::m_preSampleIdx {}

private

Definition at line 91 of file ZDCPulseAnalyzer.h.

{};

m_PSHGOverUnderflow

bool ZDCPulseAnalyzer::m_PSHGOverUnderflow {false}

private

Definition at line 273 of file ZDCPulseAnalyzer.h.

{false};

m_quietFits

bool ZDCPulseAnalyzer::m_quietFits {true}

private

Definition at line 99 of file ZDCPulseAnalyzer.h.

{true};

m_refitLGAmpError

float ZDCPulseAnalyzer::m_refitLGAmpError {0}

private

Definition at line 370 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGAmpl

float ZDCPulseAnalyzer::m_refitLGAmpl {0}

private

Definition at line 367 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGAmplCorr

float ZDCPulseAnalyzer::m_refitLGAmplCorr {0}

private

Definition at line 369 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGChisq

float ZDCPulseAnalyzer::m_refitLGChisq {0}

private

Definition at line 371 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGChisqRatio

float ZDCPulseAnalyzer::m_refitLGChisqRatio {0}

private

Definition at line 372 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGFitAmpl

float ZDCPulseAnalyzer::m_refitLGFitAmpl {0}

private

Definition at line 368 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGTime

float ZDCPulseAnalyzer::m_refitLGTime {0}

private

Definition at line 373 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGTimeSub

float ZDCPulseAnalyzer::m_refitLGTimeSub {0}

private

Definition at line 374 of file ZDCPulseAnalyzer.h.

{0};

m_repassPulse

bool ZDCPulseAnalyzer::m_repassPulse {false}

private

Definition at line 289 of file ZDCPulseAnalyzer.h.

{false};

m_sampleNoiseHG

std::vector<float> ZDCPulseAnalyzer::m_sampleNoiseHG

private

Definition at line 384 of file ZDCPulseAnalyzer.h.

m_sampleNoiseLG

std::vector<float> ZDCPulseAnalyzer::m_sampleNoiseLG

private

Definition at line 385 of file ZDCPulseAnalyzer.h.

m_samplesDeriv2nd

std::vector<float> ZDCPulseAnalyzer::m_samplesDeriv2nd

private

Definition at line 399 of file ZDCPulseAnalyzer.h.

m_samplesDeriv2ndErr

std::vector<float> ZDCPulseAnalyzer::m_samplesDeriv2ndErr

private

Definition at line 400 of file ZDCPulseAnalyzer.h.

m_samplesLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesLGRefit

private

Definition at line 396 of file ZDCPulseAnalyzer.h.

m_samplesNoise

std::vector<float> ZDCPulseAnalyzer::m_samplesNoise

private

Definition at line 394 of file ZDCPulseAnalyzer.h.

m_samplesNoiseLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesNoiseLGRefit

private

Definition at line 397 of file ZDCPulseAnalyzer.h.

m_samplesSub

std::vector<float> ZDCPulseAnalyzer::m_samplesSub

private

Definition at line 393 of file ZDCPulseAnalyzer.h.

m_saveFitFunc

bool ZDCPulseAnalyzer::m_saveFitFunc {false}

private

Definition at line 100 of file ZDCPulseAnalyzer.h.

{false};

m_setPerSampleNoiseHG

std::vector<float> ZDCPulseAnalyzer::m_setPerSampleNoiseHG

private

Definition at line 127 of file ZDCPulseAnalyzer.h.

m_setPerSampleNoiseLG

std::vector<float> ZDCPulseAnalyzer::m_setPerSampleNoiseLG

private

Definition at line 128 of file ZDCPulseAnalyzer.h.

m_shapeParameters

std::vector<float> ZDCPulseAnalyzer::m_shapeParameters

private

Definition at line 364 of file ZDCPulseAnalyzer.h.

m_sigMinHG

float ZDCPulseAnalyzer::m_sigMinHG {}

private

Definition at line 179 of file ZDCPulseAnalyzer.h.

{};           // Minimum amplitude significance to be considered valid pulse

m_sigMinLG

float ZDCPulseAnalyzer::m_sigMinLG {}

private

Definition at line 180 of file ZDCPulseAnalyzer.h.

{};           // Minimum amplitude significance to be considered valid pulse

m_T0CutHighHG

float ZDCPulseAnalyzer::m_T0CutHighHG {}

private

Definition at line 162 of file ZDCPulseAnalyzer.h.

{}; // maximum good corrected time for HG fits

m_T0CutHighLG

float ZDCPulseAnalyzer::m_T0CutHighLG {}

private

Definition at line 159 of file ZDCPulseAnalyzer.h.

{}; // maximum good corrected time for LG fits

m_T0CutLowHG

float ZDCPulseAnalyzer::m_T0CutLowHG {}

private

Definition at line 161 of file ZDCPulseAnalyzer.h.

{};  // minimum good corrected time for HG fits

m_T0CutLowLG

float ZDCPulseAnalyzer::m_T0CutLowLG {}

private

Definition at line 158 of file ZDCPulseAnalyzer.h.

{};  // minimum good corrected time for LG fits

m_t0CutSig

float ZDCPulseAnalyzer::m_t0CutSig {}

private

Definition at line 166 of file ZDCPulseAnalyzer.h.

{};

m_tag

std::string ZDCPulseAnalyzer::m_tag {}

private

Definition at line 89 of file ZDCPulseAnalyzer.h.

{};

m_timeCutMode

unsigned int ZDCPulseAnalyzer::m_timeCutMode {0}

private

Definition at line 167 of file ZDCPulseAnalyzer.h.

{0}; // 0 - no significance cut, 1 - cut ORed with fixed cut, 2 - cut ANDed with fixed cut

m_timeResFuncHG_p

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

private

Definition at line 164 of file ZDCPulseAnalyzer.h.

{};

m_timeResFuncLG_p

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

private

Definition at line 165 of file ZDCPulseAnalyzer.h.

{};

m_timeSig

float ZDCPulseAnalyzer::m_timeSig {}

private

Definition at line 342 of file ZDCPulseAnalyzer.h.

{};

m_timingCorrMode

unsigned int ZDCPulseAnalyzer::m_timingCorrMode {NoTimingCorr}

private

Definition at line 212 of file ZDCPulseAnalyzer.h.

{NoTimingCorr};

m_timingCorrRefADC

float ZDCPulseAnalyzer::m_timingCorrRefADC {500}

private

Definition at line 213 of file ZDCPulseAnalyzer.h.

{500};

m_timingCorrScale

float ZDCPulseAnalyzer::m_timingCorrScale {100}

private

Definition at line 214 of file ZDCPulseAnalyzer.h.

{100};

m_tmax

float ZDCPulseAnalyzer::m_tmax {}

private

Definition at line 97 of file ZDCPulseAnalyzer.h.

{};

m_tmin

float ZDCPulseAnalyzer::m_tmin {}

private

Definition at line 96 of file ZDCPulseAnalyzer.h.

{};

m_underFlowExclSamplesPostHG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPostHG {0}

private

Definition at line 207 of file ZDCPulseAnalyzer.h.

{0};

m_underFlowExclSamplesPostLG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPostLG {0}

private

Definition at line 209 of file ZDCPulseAnalyzer.h.

{0};

m_underFlowExclSamplesPreHG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPreHG {0}

private

Definition at line 206 of file ZDCPulseAnalyzer.h.

{0};

m_underFlowExclSamplesPreLG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPreLG {0}

private

Definition at line 208 of file ZDCPulseAnalyzer.h.

{0};

m_underflowExclusion

bool ZDCPulseAnalyzer::m_underflowExclusion {false}

private

Definition at line 291 of file ZDCPulseAnalyzer.h.

{false};

m_useDelayed

bool ZDCPulseAnalyzer::m_useDelayed {false}

private

Definition at line 109 of file ZDCPulseAnalyzer.h.

{false};

m_usedPresampIdx

int ZDCPulseAnalyzer::m_usedPresampIdx {}

private

Definition at line 300 of file ZDCPulseAnalyzer.h.

{};

m_useFixedBaseline

bool ZDCPulseAnalyzer::m_useFixedBaseline {}

private

Definition at line 250 of file ZDCPulseAnalyzer.h.

{};

m_useLowGain

bool ZDCPulseAnalyzer::m_useLowGain {false}

private

Definition at line 268 of file ZDCPulseAnalyzer.h.

{false};

m_useSampleHG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleHG

private

Definition at line 388 of file ZDCPulseAnalyzer.h.

m_useSampleLG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleLG

private

Definition at line 387 of file ZDCPulseAnalyzer.h.

s_combinedFitFunc

TF1 * ZDCPulseAnalyzer::s_combinedFitFunc = nullptr

staticprivate

Definition at line 81 of file ZDCPulseAnalyzer.h.

s_combinedFitTMax

float ZDCPulseAnalyzer::s_combinedFitTMax = 1000

staticprivate

Definition at line 82 of file ZDCPulseAnalyzer.h.

s_combinedFitTMin

float ZDCPulseAnalyzer::s_combinedFitTMin = -0.5

staticprivate

Definition at line 83 of file ZDCPulseAnalyzer.h.

s_delayedFitHist

TH1 * ZDCPulseAnalyzer::s_delayedFitHist = nullptr

staticprivate

Definition at line 80 of file ZDCPulseAnalyzer.h.

s_pullValues

std::vector< float > ZDCPulseAnalyzer::s_pullValues

staticprivate

Definition at line 84 of file ZDCPulseAnalyzer.h.

s_undelayedFitHist

TH1 * ZDCPulseAnalyzer::s_undelayedFitHist = nullptr

staticprivate

Definition at line 79 of file ZDCPulseAnalyzer.h.

---

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

• ZDCPulseAnalyzer.h
• ZDCPulseAnalyzer.cxx