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	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	setLGMode (unsigned int mode)
unsigned int	getLGMode () const
void	set2ndDerivStep (size_t step)
void	SetCutValues (float chisqDivAmpCutHG, float chisqDivAmpCutLG, float deltaT0MinHG, float deltaT0MaxHG, float deltaT0MinLG, float deltaT0MaxLG)
void	SetNoiseSigmas (float noiseSigHG, float noiseSigLG)
void	SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)
void	SetFitMinMaxAmp (float minAmpHG, float minAmpLG, float maxAmpHG, float maxAmpLG)
void	setMinimumSignificance (float sigMinHG, float sigMinLG)
void	SetTauT0Values (bool fixTau1, bool fixTau2, float tau1, float tau2, float t0HG, float t0LG)
void	SetADCOverUnderflowValues (int HGOverflowADC, int HGUnderflowADC, int LGOverflowADC)
void	SetTimingCorrParams (TimingCorrMode mode, float refADC, float refScale, const std::vector< float > &HGT0CorrParams, const std::vector< float > &LGT0CorrParams)
void	SetFitTimeMax (float tmax)
void	SetNonlinCorrParams (float refADC, float refScale, const std::vector< float > &paramsHG, const std::vector< float > &paramsLG)
void	enableFADCCorrections (bool correctPerSample, std::unique_ptr< const TH1 > &correHistHG, std::unique_ptr< const TH1 > &correHistLG)
void	disableFADCCorrections ()
bool	LoadAndAnalyzeData (const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG)
bool	LoadAndAnalyzeData (const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG, const std::vector< float > &ADCSamplesHGDelayed, const std::vector< float > &ADCSamplesLGDelayed)
bool	ReanalyzeData ()
bool	HaveData () const
bool	havePulse () const
bool	useLowGain () const
bool	failed () const
bool	HGOverflow () const
bool	HGUnderflow () const
bool	PSHGOverUnderflow () const
bool	LGOverflow () const
bool	LGUnderflow () const
bool	prePulse () const
bool	postPulse () const
bool	fitFailed () const
bool	badChisq () const
bool	badT0 () const
bool	excludeEarlyLG () const
bool	excludeLateLG () const
bool	preExpTail () const
bool	fitMinimumAmplitude () const
bool	repassPulse () const
bool	armSumInclude () const
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	GetFitTau1 () const
float	GetFitTau2 () const
float	GetFitPreT0 () const
float	GetFitPreAmp () const
float	GetFitPostT0 () const
float	GetFitPostAmp () const
float	GetFitExpAmp () const
float	GetAmpNoNonLin () const
float	GetAmplitude () const
float	GetAmpError () const
float	GetPreExpAmp () const
float	getRefitLGAmp () const
float	getRefitLGFitAmp () const
float	getRefitLGAmpCorr () const
float	getRefitLGChisq () const
float	getRefitLGTime () const
float	getRefitLGTimeSub () const
float	getPresample () const
float	getMaxADCHG () const
float	getMaxADCLG () const
float	getMinADCHG () const
float	getMinADCLG () const
float	getMaxADCSub () const
float	getMinADCSub () const
int	getMaxADCSampleHG () const
int	getMinADCSampleHG () const
int	getMaxADCSampleLG () const
int	getMinADCSampleLG () const
float	getADCPeakHG () const
float	getADCPeakLG () const
float	GetMaxDelta () const
float	GetMinDelta () const
float	GetFitTMax () const
float	GetFitTMin () const
float	GetdelayBS () const
float	GetMinDeriv2nd () const
float	GetMinDeriv2ndIndex () const
unsigned int	GetStatusMask () const
float	GetPreSampleAmp () const
float	GetBkgdMaxFraction () const
float	GetDelayedBaselineShiftFit () const
float	GetDelayedBaselineCorr () const
const TH1 *	GetHistogramPtr (bool refitLG=false)
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)>

Private Member Functions
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< bool > &useSamples, float peak2ndDerivMinThresh, float noiseSig, 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 > &samplesSig, 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::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 {}
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_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_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_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_fitNDoF {}
float	m_fitPreT0 {}
float	m_fitPreAmp {}
float	m_fitPostT0 {}
float	m_fitPostAmp {}
float	m_fitExpAmp {}
float	m_amplitude {}
float	m_ampNoNonLin {}
float	m_ampError {}
float	m_preSampleAmp {}
float	m_preAmplitude {}
float	m_postAmplitude {}
float	m_expAmplitude {}
float	m_bkgdMaxFraction {}
float	m_delayedBaselineShift {}
bool	m_evtLGRefit {false}
float	m_refitLGAmpl {0}
float	m_refitLGFitAmpl {0}
float	m_refitLGAmplCorr {0}
float	m_refitLGAmpError {0}
float	m_refitLGChisq {0}
float	m_refitLGTime {0}
float	m_refitLGTimeSub {0}
int	m_lastHGOverFlowSample {-1}
int	m_firstHGOverFlowSample {-1}
unsigned int	m_NSamplesAna {0}
std::vector< float >	m_ADCSamplesHG
std::vector< float >	m_ADCSamplesLG
std::vector< float >	m_ADCSamplesHGSub
std::vector< float >	m_ADCSamplesLGSub
std::vector< bool >	m_useSampleLG
std::vector< bool >	m_useSampleHG
std::vector< float >	m_ADCSSampSigHG
std::vector< float >	m_ADCSSampSigLG
std::vector< float >	m_samplesSub
std::vector< float >	m_samplesSig
std::vector< float >	m_samplesLGRefit
std::vector< float >	m_samplesSigLGRefit
std::vector< float >	m_samplesDeriv2nd
std::vector< float >	m_fitPulls

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

private

Definition at line 398 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 150 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(peak2ndDerivMinThreshLG),
  m_peak2ndDerivMinThreshHG(peak2ndDerivMinThreshHG),
  m_ADCSamplesHGSub(Nsample, 0), m_ADCSamplesLGSub(Nsample, 0),
  m_ADCSSampSigHG(Nsample, 0), m_ADCSSampSigLG(Nsample, 0), 
  m_samplesSub(Nsample, 0)
{
  // Create the histogram used for fitting
  //
  m_tmin = -deltaTSample / 2;
  m_tmax = m_tmin + ((float) Nsample) * deltaTSample;
  m_defaultFitTMax = m_tmax;
  
  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 184 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 484 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< bool > & useSamples, float peak2ndDerivMinThresh, float noiseSig, const std::vector< float > & toCorrParams, ChisqCutLambdatype chisqCutLambda, float minT0Corr, float maxT0Corr )

private

Definition at line 1181 of file ZDCPulseAnalyzer.cxx.

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

armSumInclude()

bool ZDCPulseAnalyzer::armSumInclude ( ) const

inline

Definition at line 621 of file ZDCPulseAnalyzer.h.

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

badChisq()

bool ZDCPulseAnalyzer::badChisq ( ) const

inline

Definition at line 613 of file ZDCPulseAnalyzer.h.

{return m_badChisq;}

badT0()

bool ZDCPulseAnalyzer::badT0 ( ) const

inline

Definition at line 615 of file ZDCPulseAnalyzer.h.

{return m_badT0;}

Calculate2ndDerivative()

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

staticprivate

Definition at line 2384 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++) {
    int deriv2nd = inputData[sample + step] + inputData[sample - step] - 2*inputData[sample];
    results.at(fillIndex++) = deriv2nd;
  }
 
  return results;
}

CalculateDerivative()

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

staticprivate

Definition at line 2363 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 2056 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 96 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 2532 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 == "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 == "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 586 of file ZDCPulseAnalyzer.h.

{m_haveFADCCorrections = false;}

DoAnalysis()

bool ZDCPulseAnalyzer::DoAnalysis ( bool repass )

private

Definition at line 1055 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,
               offset = m_chisqDivAmpOffsetLG,
               power = m_chisqDivAmpPowerLG]
      (float chisq, float amp, unsigned int fitNDoF)->bool
    {
      double ratio = chisq / (std::pow(amp, power) + offset);
      if (chisq/fitNDoF > 2 && ratio > cut) return false;
      else return true;
    };
    
    bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesLGSub, m_useSampleLG,
                  deriv2ndThreshLG, m_noiseSigLG, 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,
               offset = m_chisqDivAmpOffsetHG,
               power = m_chisqDivAmpPowerHG, tag = m_tag]
      (float chisq, float amp, unsigned int fitNDoF)->bool
    {
      double ratio = chisq / (std::pow(amp, power) + offset);
 
      if (chisq/float(fitNDoF) > 2 && ratio > cut) return false;
      else return true;
    };
    
    bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesHGSub, m_useSampleHG,
                  deriv2ndThreshHG, m_noiseSigHG, 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_ADCSSampSigLG, m_useSampleLG);
      DoFit(true);
 
      double amplCorrFactor = getAmplitudeCorrection(false);
      m_refitLGAmplCorr = m_refitLGAmpl*amplCorrFactor;
    }
    
    return result;
  }
}

DoFit()

void ZDCPulseAnalyzer::DoFit ( bool refitLG = false )

private

Definition at line 1605 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;
      }
    }
  }
  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 1782 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();
  }
  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 2139 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 2186 of file ZDCPulseAnalyzer.cxx.

{
  std::ostringstream ostrStream;
  
  (*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();
  
  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 2167 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 220 of file ZDCPulseAnalyzer.cxx.

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

enableFADCCorrections()

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

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

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

enablePreExclusion()

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

inline

Definition at line 501 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 243 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 535 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 616 of file ZDCPulseAnalyzer.h.

{return m_ExcludeEarly;}

excludeLateLG()

bool ZDCPulseAnalyzer::excludeLateLG ( ) const

inline

Definition at line 617 of file ZDCPulseAnalyzer.h.

{return m_ExcludeLate;}

failed()

bool ZDCPulseAnalyzer::failed ( ) const

inline

Definition at line 602 of file ZDCPulseAnalyzer.h.

{return m_fail;}

failSigCut()

bool ZDCPulseAnalyzer::failSigCut ( ) const

inline

Definition at line 622 of file ZDCPulseAnalyzer.h.

{return m_failSigCut;}

FillHistogram()

void ZDCPulseAnalyzer::FillHistogram ( bool refitLG )

inlineprivate

Definition at line 419 of file ZDCPulseAnalyzer.h.

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

fitFailed()

bool ZDCPulseAnalyzer::fitFailed ( ) const

inline

Definition at line 612 of file ZDCPulseAnalyzer.h.

{return m_fitFailed;}

fitMinimumAmplitude()

bool ZDCPulseAnalyzer::fitMinimumAmplitude ( ) const

inline

Definition at line 619 of file ZDCPulseAnalyzer.h.

{return m_fitMinAmp;}

getADCPeakHG()

float ZDCPulseAnalyzer::getADCPeakHG ( ) const

inline

Definition at line 709 of file ZDCPulseAnalyzer.h.

{return m_ADCPeakHG;}

getADCPeakLG()

float ZDCPulseAnalyzer::getADCPeakLG ( ) const

inline

Definition at line 710 of file ZDCPulseAnalyzer.h.

{return m_ADCPeakLG;}

GetAmpError()

float ZDCPulseAnalyzer::GetAmpError ( ) const

inline

Definition at line 648 of file ZDCPulseAnalyzer.h.

{return m_ampError;}

GetAmplitude()

float ZDCPulseAnalyzer::GetAmplitude ( ) const

inline

Definition at line 647 of file ZDCPulseAnalyzer.h.

{return m_amplitude;}

getAmplitudeCorrection()

double ZDCPulseAnalyzer::getAmplitudeCorrection ( bool highGain )

private

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

{return m_ampNoNonLin;}

GetBkgdMaxFraction()

float ZDCPulseAnalyzer::GetBkgdMaxFraction ( ) const

inline

Definition at line 726 of file ZDCPulseAnalyzer.h.

{return m_bkgdMaxFraction;}

GetChisq()

float ZDCPulseAnalyzer::GetChisq ( ) const

inline

Definition at line 636 of file ZDCPulseAnalyzer.h.

{return m_fitChisq;}

GetCombinedGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetCombinedGraph

(

bool

forceLG = false

)

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

{return m_delayedBaselineShift;}

GetDelayedBaselineCorr()

float ZDCPulseAnalyzer::GetDelayedBaselineCorr ( ) const

inline

Definition at line 729 of file ZDCPulseAnalyzer.h.

{return m_baselineCorr;}

GetDelayedBaselineShiftFit()

float ZDCPulseAnalyzer::GetDelayedBaselineShiftFit ( ) const

inline

Definition at line 728 of file ZDCPulseAnalyzer.h.

{return m_delayedBaselineShift;}

GetFitAmplitude()

float ZDCPulseAnalyzer::GetFitAmplitude ( ) const

inline

Definition at line 631 of file ZDCPulseAnalyzer.h.

{return m_fitAmplitude;}

GetFitExpAmp()

float ZDCPulseAnalyzer::GetFitExpAmp ( ) const

inline

Definition at line 643 of file ZDCPulseAnalyzer.h.

{return m_fitExpAmp;}

GetFitPostAmp()

float ZDCPulseAnalyzer::GetFitPostAmp ( ) const

inline

Definition at line 642 of file ZDCPulseAnalyzer.h.

{return m_postAmplitude;}

GetFitPostT0()

float ZDCPulseAnalyzer::GetFitPostT0 ( ) const

inline

Definition at line 641 of file ZDCPulseAnalyzer.h.

{return m_fitPostT0;}

GetFitPreAmp()

float ZDCPulseAnalyzer::GetFitPreAmp ( ) const

inline

Definition at line 640 of file ZDCPulseAnalyzer.h.

{return m_preAmplitude;}

GetFitPreT0()

float ZDCPulseAnalyzer::GetFitPreT0 ( ) const

inline

Definition at line 639 of file ZDCPulseAnalyzer.h.

{return m_fitPreT0;}

GetFitPulls()

std::vector< float > ZDCPulseAnalyzer::GetFitPulls

(

bool

forceLG = false

)

const

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

{return m_fitTime;}

GetFitTau1()

float ZDCPulseAnalyzer::GetFitTau1 ( ) const

inline

Definition at line 637 of file ZDCPulseAnalyzer.h.

{return m_fitTau1;}

GetFitTau2()

float ZDCPulseAnalyzer::GetFitTau2 ( ) const

inline

Definition at line 638 of file ZDCPulseAnalyzer.h.

{return m_fitTau2;}

GetFitTMax()

float ZDCPulseAnalyzer::GetFitTMax ( ) const

inline

Definition at line 715 of file ZDCPulseAnalyzer.h.

{return m_fitTMax;}

GetFitTMin()

float ZDCPulseAnalyzer::GetFitTMin ( ) const

inline

Definition at line 716 of file ZDCPulseAnalyzer.h.

{return m_fitTMin;}

GetGraph()

std::shared_ptr< TGraphErrors > ZDCPulseAnalyzer::GetGraph

(

bool

forceLG = false

)

Definition at line 2337 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 731 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 523 of file ZDCPulseAnalyzer.h.

{return m_LGMode;}

getMaxADCHG()

float ZDCPulseAnalyzer::getMaxADCHG ( ) const

inline

Definition at line 688 of file ZDCPulseAnalyzer.h.

{return m_maxADCHG;}

getMaxADCLG()

float ZDCPulseAnalyzer::getMaxADCLG ( ) const

inline

Definition at line 689 of file ZDCPulseAnalyzer.h.

{return m_maxADCLG;}

getMaxADCSampleHG()

int ZDCPulseAnalyzer::getMaxADCSampleHG ( ) const

inline

Definition at line 703 of file ZDCPulseAnalyzer.h.

{return m_maxADCSampleHG;}

getMaxADCSampleLG()

int ZDCPulseAnalyzer::getMaxADCSampleLG ( ) const

inline

Definition at line 706 of file ZDCPulseAnalyzer.h.

{return m_maxADCSampleLG;}

getMaxADCSub()

float ZDCPulseAnalyzer::getMaxADCSub ( ) const

inline

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

{return m_maxDelta;}

getMinADCHG()

float ZDCPulseAnalyzer::getMinADCHG ( ) const

inline

Definition at line 690 of file ZDCPulseAnalyzer.h.

{return m_minADCHG;}

getMinADCLG()

float ZDCPulseAnalyzer::getMinADCLG ( ) const

inline

Definition at line 691 of file ZDCPulseAnalyzer.h.

{return m_minADCLG;}

getMinADCSampleHG()

int ZDCPulseAnalyzer::getMinADCSampleHG ( ) const

inline

Definition at line 704 of file ZDCPulseAnalyzer.h.

{return m_minADCSampleHG;}

getMinADCSampleLG()

int ZDCPulseAnalyzer::getMinADCSampleLG ( ) const

inline

Definition at line 707 of file ZDCPulseAnalyzer.h.

{return m_minADCSampleLG;}

getMinADCSub()

float ZDCPulseAnalyzer::getMinADCSub ( ) const

inline

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

{return m_minDelta;}

GetMinDeriv2nd()

float ZDCPulseAnalyzer::GetMinDeriv2nd ( ) const

inline

Definition at line 720 of file ZDCPulseAnalyzer.h.

{return m_minDeriv2nd;}

GetMinDeriv2ndIndex()

float ZDCPulseAnalyzer::GetMinDeriv2ndIndex ( ) const

inline

Definition at line 721 of file ZDCPulseAnalyzer.h.

{return m_minDeriv2ndIndex;}

GetPreExpAmp()

float ZDCPulseAnalyzer::GetPreExpAmp ( ) const

inline

Definition at line 649 of file ZDCPulseAnalyzer.h.

{return m_expAmplitude;}

getPresample()

float ZDCPulseAnalyzer::getPresample ( ) const

inline

Definition at line 687 of file ZDCPulseAnalyzer.h.

{return m_preSample;}

GetPreSampleAmp()

float ZDCPulseAnalyzer::GetPreSampleAmp ( ) const

inline

Definition at line 725 of file ZDCPulseAnalyzer.h.

{return m_preSampleAmp;}

getRefitLGAmp()

float ZDCPulseAnalyzer::getRefitLGAmp ( ) const

inline

Definition at line 651 of file ZDCPulseAnalyzer.h.

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

getRefitLGAmpCorr()

float ZDCPulseAnalyzer::getRefitLGAmpCorr ( ) const

inline

Definition at line 663 of file ZDCPulseAnalyzer.h.

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

getRefitLGChisq()

float ZDCPulseAnalyzer::getRefitLGChisq ( ) const

inline

Definition at line 669 of file ZDCPulseAnalyzer.h.

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

getRefitLGFitAmp()

float ZDCPulseAnalyzer::getRefitLGFitAmp ( ) const

inline

Definition at line 657 of file ZDCPulseAnalyzer.h.

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

getRefitLGTime()

float ZDCPulseAnalyzer::getRefitLGTime ( ) const

inline

Definition at line 675 of file ZDCPulseAnalyzer.h.

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

getRefitLGTimeSub()

float ZDCPulseAnalyzer::getRefitLGTimeSub ( ) const

inline

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

{return m_samplesDeriv2nd;}

GetSamplesSub()

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

inline

Definition at line 752 of file ZDCPulseAnalyzer.h.

{return m_samplesSub;}

GetStatusMask()

unsigned int ZDCPulseAnalyzer::GetStatusMask

(

)

const

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

{return m_fitTimeCorr;}

GetT0Sub()

float ZDCPulseAnalyzer::GetT0Sub ( ) const

inline

Definition at line 633 of file ZDCPulseAnalyzer.h.

{return m_fitTimeSub;}

getTimeSig()

float ZDCPulseAnalyzer::getTimeSig ( ) const

inline

Definition at line 635 of file ZDCPulseAnalyzer.h.

{return m_timeSig;}

HaveData()

bool ZDCPulseAnalyzer::HaveData ( ) const

inline

Definition at line 595 of file ZDCPulseAnalyzer.h.

{return m_haveData;}

havePulse()

bool ZDCPulseAnalyzer::havePulse ( ) const

inline

Definition at line 600 of file ZDCPulseAnalyzer.h.

{return m_havePulse;}

HGOverflow()

bool ZDCPulseAnalyzer::HGOverflow ( ) const

inline

Definition at line 603 of file ZDCPulseAnalyzer.h.

{return m_HGOverflow;}

HGUnderflow()

bool ZDCPulseAnalyzer::HGUnderflow ( ) const

inline

Definition at line 605 of file ZDCPulseAnalyzer.h.

{return m_HGUnderflow;}

LGOverflow()

bool ZDCPulseAnalyzer::LGOverflow ( ) const

inline

Definition at line 607 of file ZDCPulseAnalyzer.h.

{return m_LGOverflow;}

LGUnderflow()

bool ZDCPulseAnalyzer::LGUnderflow ( ) const

inline

Definition at line 608 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 768 of file ZDCPulseAnalyzer.cxx.

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

LoadAndAnalyzeData() [2/2]

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

Definition at line 793 of file ZDCPulseAnalyzer.cxx.

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

MakeCombinedFitter()

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

staticprivate

Definition at line 2084 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 2416 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 611 of file ZDCPulseAnalyzer.h.

{return m_postPulse;}

preExpTail()

bool ZDCPulseAnalyzer::preExpTail ( ) const

inline

Definition at line 618 of file ZDCPulseAnalyzer.h.

{return m_preExpTail;}

prepareLGRefit()

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

private

Definition at line 1582 of file ZDCPulseAnalyzer.cxx.

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

prePulse()

bool ZDCPulseAnalyzer::prePulse ( ) const

inline

Definition at line 610 of file ZDCPulseAnalyzer.h.

{return m_prePulse;}

PSHGOverUnderflow()

bool ZDCPulseAnalyzer::PSHGOverUnderflow ( ) const

inline

Definition at line 606 of file ZDCPulseAnalyzer.h.

{return m_PSHGOverUnderflow;}

quietFits()

bool ZDCPulseAnalyzer::quietFits ( ) const

inline

Definition at line 489 of file ZDCPulseAnalyzer.h.

{return m_quietFits;}

ReanalyzeData()

bool ZDCPulseAnalyzer::ReanalyzeData

(

)

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

{return m_repassPulse;}

Reset()

void ZDCPulseAnalyzer::Reset ( bool reanalyze = false )

private

Definition at line 323 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;
    
    int sampleVecSize = m_Nsample;
    if (m_useDelayed) sampleVecSize *= 2;
 
    m_ADCSamplesHG.clear();
    m_ADCSamplesLG.clear();
    
    m_ADCSamplesHGSub.clear();
    m_ADCSamplesLGSub.clear();
 
    m_ADCSSampSigHG.assign(sampleVecSize, m_noiseSigHG);
    m_ADCSSampSigLG.assign(sampleVecSize, m_noiseSigLG); 
 
    m_minSampleEvt = 0;
    m_maxSampleEvt = (m_useDelayed ? 2 * m_Nsample - 1 : m_Nsample - 1);
 
    m_usedPresampIdx = 0;
 
    m_fitTMax = m_defaultFitTMax;
    m_fitTMin = m_defaultFitTMin;
 
    m_lastHGOverFlowSample  = -999;
    m_firstHGOverFlowSample = 999;
  }
 
  
  m_defaultT0Max = m_deltaTSample * (m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 0.5);
  m_defaultT0Min = m_deltaTSample * (m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance - 0.5);
 
  if (m_initializedFits) {
    m_defaultFitWrapper ->SetT0Range(m_defaultT0Min, m_defaultT0Max);
    m_prePulseFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
    m_preExpFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
  }
 
  // -----------------------
  // Statuses
  //
  m_havePulse  = false;
  
  m_prePulse  = false;
  m_postPulse = false;
  m_fitFailed = false;
  m_badChisq  = false;
 
  m_badT0        = false;
  m_preExpTail   = false;
  m_repassPulse = false;
 
  m_fitMinAmp = false;
  m_evtLGRefit = false;
  m_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_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 ( )

inline

Definition at line 487 of file ZDCPulseAnalyzer.h.

{m_saveFitFunc = true;}

ScanAndSubtractSamples()

bool ZDCPulseAnalyzer::ScanAndSubtractSamples ( )

private

Definition at line 857 of file ZDCPulseAnalyzer.cxx.

{
  //
  // Dump samples to verbose output
  //
  bool doDump = (*m_msgFunc_p)(ZDCMsg::Verbose, "Dumping all samples before subtraction: ");
      
  m_NSamplesAna = m_ADCSamplesHG.size();
 
  m_ADCSamplesHGSub.assign(m_NSamplesAna, 0);
  m_ADCSamplesLGSub.assign(m_NSamplesAna, 0);
 
  m_useSampleHG.assign(m_NSamplesAna, true);
  m_useSampleLG.assign(m_NSamplesAna, true);
 
  // Now do pedestal subtraction and check for overflows
  //
  m_minADCHG = m_HGOverflowADC;
  m_minADCLG = m_LGOverflowADC;
 
  m_maxADCHG = 0;
  m_maxADCLG = 0;
 
  for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
    float ADCHG = m_ADCSamplesHG[isample];
    float ADCLG = m_ADCSamplesLG[isample];
 
    //
    // We always pedestal subtract even if the sample isn't going to be used in analysis
    //  basically for diagnostics
    //
    m_ADCSamplesHGSub[isample] = ADCHG - m_pedestal;
    m_ADCSamplesLGSub[isample] = ADCLG - m_pedestal;
 
        
    // If 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;
    }
  }
 
  //  (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + ": ScanAndSubtractSamples done");
 
  return true;
}

set2ndDerivStep()

void ZDCPulseAnalyzer::set2ndDerivStep ( size_t step )

inline

Definition at line 525 of file ZDCPulseAnalyzer.h.

{m_2ndDerivStep = step;}

SetADCOverUnderflowValues()

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

Definition at line 514 of file ZDCPulseAnalyzer.cxx.

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

SetCutValues()

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

Definition at line 521 of file ZDCPulseAnalyzer.cxx.

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

SetDefaults()

void ZDCPulseAnalyzer::SetDefaults ( )

private

Definition at line 250 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_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_postPulse = false;
  m_prePulse = false;
 
  m_initialPrePulseT0  = -10;
  m_initialPrePulseAmp = 5;
 
  m_initialPostPulseT0  = 100;
 
  m_initialExpAmp = 0;
  m_fitPostT0lo   = 0;
 
  m_useDelayed = false;
  m_enablePreExcl = false;
  m_enablePostExcl = false;
  
  m_timingCorrMode = NoTimingCorr;
  m_haveNonlinCorr = false;
  m_quietFits = true;
  m_saveFitFunc = false;
  m_fitOptions = "s";
}

SetFitMinMaxAmp()

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

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

{ m_fitOptions = fitOptions;}

SetFitTimeMax()

void ZDCPulseAnalyzer::SetFitTimeMax

(

float

tmax

)

Definition at line 502 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 469 of file ZDCPulseAnalyzer.cxx.

{
  m_gainFactorHG = gainFactorHG;
  m_gainFactorLG = gainFactorLG;
}

setLGMode()

void ZDCPulseAnalyzer::setLGMode ( unsigned int mode )

inline

Definition at line 522 of file ZDCPulseAnalyzer.h.

{m_LGMode = mode;}

setMinimumSignificance()

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

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

                                                     {
    m_peak2ndDerivMinTolerance = tolerance;
    m_initializedFits = false;
  }

setQuietFits()

void ZDCPulseAnalyzer::setQuietFits ( )

inline

Definition at line 490 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 484 of file ZDCPulseAnalyzer.cxx.

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

SetTimingCorrParams()

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

inline

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

{m_quietFits = false;}

SetupFitFunctions()

void ZDCPulseAnalyzer::SetupFitFunctions ( )

private

Definition at line 675 of file ZDCPulseAnalyzer.cxx.

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

underflowExclusion()

bool ZDCPulseAnalyzer::underflowExclusion ( ) const

inline

Definition at line 623 of file ZDCPulseAnalyzer.h.

{return m_underflowExclusion;}

UpdateFitterTimeLimits()

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

private

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

{return m_useLowGain;}

ValidateJSONConfig()

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

private

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

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 295 of file ZDCPulseAnalyzer.h.

{};

m_ADCPeakLG

float ZDCPulseAnalyzer::m_ADCPeakLG {}

private

Definition at line 296 of file ZDCPulseAnalyzer.h.

{};

m_ADCSamplesHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHG

private

Definition at line 358 of file ZDCPulseAnalyzer.h.

m_ADCSamplesHGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHGSub

private

Definition at line 360 of file ZDCPulseAnalyzer.h.

m_ADCSamplesLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLG

private

Definition at line 359 of file ZDCPulseAnalyzer.h.

m_ADCSamplesLGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLGSub

private

Definition at line 361 of file ZDCPulseAnalyzer.h.

m_ADCSSampSigHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigHG

private

Definition at line 366 of file ZDCPulseAnalyzer.h.

m_ADCSSampSigLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigLG

private

Definition at line 367 of file ZDCPulseAnalyzer.h.

m_adjTimeRangeEvent

bool ZDCPulseAnalyzer::m_adjTimeRangeEvent {false}

private

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

{};

m_amplitude

float ZDCPulseAnalyzer::m_amplitude {}

private

Definition at line 335 of file ZDCPulseAnalyzer.h.

{};

m_ampNoNonLin

float ZDCPulseAnalyzer::m_ampNoNonLin {}

private

Definition at line 336 of file ZDCPulseAnalyzer.h.

{};

m_backToHG_pre

bool ZDCPulseAnalyzer::m_backToHG_pre {false}

private

Definition at line 277 of file ZDCPulseAnalyzer.h.

{false};

m_badChisq

bool ZDCPulseAnalyzer::m_badChisq {false}

private

Definition at line 262 of file ZDCPulseAnalyzer.h.

{false};

m_badT0

bool ZDCPulseAnalyzer::m_badT0 {false}

private

Definition at line 264 of file ZDCPulseAnalyzer.h.

{false};

m_baselineCorr

float ZDCPulseAnalyzer::m_baselineCorr {}

private

Definition at line 278 of file ZDCPulseAnalyzer.h.

{};

m_bkgdMaxFraction

float ZDCPulseAnalyzer::m_bkgdMaxFraction {}

private

Definition at line 342 of file ZDCPulseAnalyzer.h.

{};

m_chisqDivAmpCutHG

float ZDCPulseAnalyzer::m_chisqDivAmpCutHG {}

private

Definition at line 145 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpCutLG

float ZDCPulseAnalyzer::m_chisqDivAmpCutLG {}

private

Definition at line 144 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqDivAmpOffsetHG

float ZDCPulseAnalyzer::m_chisqDivAmpOffsetHG {}

private

Definition at line 147 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpOffsetLG

float ZDCPulseAnalyzer::m_chisqDivAmpOffsetLG {}

private

Definition at line 146 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_chisqDivAmpPowerHG

float ZDCPulseAnalyzer::m_chisqDivAmpPowerHG {}

private

Definition at line 149 of file ZDCPulseAnalyzer.h.

{}; // maximum good HG chisq / amplitude

m_chisqDivAmpPowerLG

float ZDCPulseAnalyzer::m_chisqDivAmpPowerLG {}

private

Definition at line 148 of file ZDCPulseAnalyzer.h.

{}; // maximum good LG chisq / amplitude

m_defaultCombinedFitter

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

private

Definition at line 239 of file ZDCPulseAnalyzer.h.

{};

m_defaultFitTMax

float ZDCPulseAnalyzer::m_defaultFitTMax {}

private

Definition at line 141 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 142 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 219 of file ZDCPulseAnalyzer.h.

{};

m_defaultT0Max

float ZDCPulseAnalyzer::m_defaultT0Max {}

private

Definition at line 162 of file ZDCPulseAnalyzer.h.

{};   // Upper limit on pulse t0

m_defaultT0Min

float ZDCPulseAnalyzer::m_defaultT0Min {}

private

Definition at line 163 of file ZDCPulseAnalyzer.h.

{};   // Lower limit on pulse t0

m_delayedBaselineShift

float ZDCPulseAnalyzer::m_delayedBaselineShift {}

private

Definition at line 343 of file ZDCPulseAnalyzer.h.

{};

m_delayedDeltaT

float ZDCPulseAnalyzer::m_delayedDeltaT {}

private

Definition at line 233 of file ZDCPulseAnalyzer.h.

{};

m_delayedHist

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

private

Definition at line 235 of file ZDCPulseAnalyzer.h.

{};

m_delayedHistLGRefit

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

private

Definition at line 236 of file ZDCPulseAnalyzer.h.

{};

m_delayedPedestalDiff

float ZDCPulseAnalyzer::m_delayedPedestalDiff {}

private

Definition at line 234 of file ZDCPulseAnalyzer.h.

{};

m_deltaTSample

float ZDCPulseAnalyzer::m_deltaTSample {}

private

Definition at line 93 of file ZDCPulseAnalyzer.h.

{};

m_enablePostExcl

bool ZDCPulseAnalyzer::m_enablePostExcl {false}

private

Definition at line 182 of file ZDCPulseAnalyzer.h.

{false};

m_enablePreExcl

bool ZDCPulseAnalyzer::m_enablePreExcl {false}

private

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

{false};

m_enableUnderflowExclLG

bool ZDCPulseAnalyzer::m_enableUnderflowExclLG {false}

private

Definition at line 188 of file ZDCPulseAnalyzer.h.

{false};

m_evtLGRefit

bool ZDCPulseAnalyzer::m_evtLGRefit {false}

private

Definition at line 345 of file ZDCPulseAnalyzer.h.

{false};

m_ExcludeEarly

bool ZDCPulseAnalyzer::m_ExcludeEarly {false}

private

Definition at line 265 of file ZDCPulseAnalyzer.h.

{false};

m_ExcludeLate

bool ZDCPulseAnalyzer::m_ExcludeLate {false}

private

Definition at line 266 of file ZDCPulseAnalyzer.h.

{false};

m_expAmplitude

float ZDCPulseAnalyzer::m_expAmplitude {}

private

Definition at line 341 of file ZDCPulseAnalyzer.h.

{};

m_fadcCorrFileName

std::string ZDCPulseAnalyzer::m_fadcCorrFileName

private

Definition at line 208 of file ZDCPulseAnalyzer.h.

m_FADCCorrHG

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

private

Definition at line 210 of file ZDCPulseAnalyzer.h.

{};

m_FADCCorrLG

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

private

Definition at line 211 of file ZDCPulseAnalyzer.h.

{};

m_FADCCorrPerSample

bool ZDCPulseAnalyzer::m_FADCCorrPerSample {false}

private

Definition at line 209 of file ZDCPulseAnalyzer.h.

{false};

m_fail

bool ZDCPulseAnalyzer::m_fail {false}

private

Definition at line 251 of file ZDCPulseAnalyzer.h.

{false};

m_failSigCut

bool ZDCPulseAnalyzer::m_failSigCut {false}

private

Definition at line 272 of file ZDCPulseAnalyzer.h.

{false};

m_firstHGOverFlowSample

int ZDCPulseAnalyzer::m_firstHGOverFlowSample {-1}

private

Definition at line 355 of file ZDCPulseAnalyzer.h.

{-1};

m_fitAmpError

float ZDCPulseAnalyzer::m_fitAmpError {}

private

Definition at line 320 of file ZDCPulseAnalyzer.h.

{};

m_fitAmplitude

float ZDCPulseAnalyzer::m_fitAmplitude {}

private

Definition at line 319 of file ZDCPulseAnalyzer.h.

{};

m_fitAmpMaxHG

float ZDCPulseAnalyzer::m_fitAmpMaxHG {}

private

Definition at line 168 of file ZDCPulseAnalyzer.h.

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

m_fitAmpMaxLG

float ZDCPulseAnalyzer::m_fitAmpMaxLG {}

private

Definition at line 169 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitAmpMinHG

float ZDCPulseAnalyzer::m_fitAmpMinHG {}

private

Definition at line 165 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitAmpMinLG

float ZDCPulseAnalyzer::m_fitAmpMinLG {}

private

Definition at line 166 of file ZDCPulseAnalyzer.h.

{};      // Minimum amplitude in the fit

m_fitChisq

float ZDCPulseAnalyzer::m_fitChisq {}

private

Definition at line 328 of file ZDCPulseAnalyzer.h.

{};

m_fitExpAmp

float ZDCPulseAnalyzer::m_fitExpAmp {}

private

Definition at line 334 of file ZDCPulseAnalyzer.h.

{};

m_fitFailed

bool ZDCPulseAnalyzer::m_fitFailed {false}

private

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

{};

m_fitHistLGRefit

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

private

Definition at line 216 of file ZDCPulseAnalyzer.h.

{};

m_fitMinAmp

bool ZDCPulseAnalyzer::m_fitMinAmp {false}

private

Definition at line 270 of file ZDCPulseAnalyzer.h.

{false};

m_fitNDoF

float ZDCPulseAnalyzer::m_fitNDoF {}

private

Definition at line 329 of file ZDCPulseAnalyzer.h.

{};

m_fitOptions

std::string ZDCPulseAnalyzer::m_fitOptions {}

private

Definition at line 127 of file ZDCPulseAnalyzer.h.

{};

m_fitPostAmp

float ZDCPulseAnalyzer::m_fitPostAmp {}

private

Definition at line 333 of file ZDCPulseAnalyzer.h.

{};

m_fitPostT0

float ZDCPulseAnalyzer::m_fitPostT0 {}

private

Definition at line 332 of file ZDCPulseAnalyzer.h.

{};

m_fitPostT0lo

float ZDCPulseAnalyzer::m_fitPostT0lo {}

private

Definition at line 308 of file ZDCPulseAnalyzer.h.

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

m_fitPreAmp

float ZDCPulseAnalyzer::m_fitPreAmp {}

private

Definition at line 331 of file ZDCPulseAnalyzer.h.

{};

m_fitPreT0

float ZDCPulseAnalyzer::m_fitPreT0 {}

private

Definition at line 330 of file ZDCPulseAnalyzer.h.

{};

m_fitPulls

std::vector<float> ZDCPulseAnalyzer::m_fitPulls

private

Definition at line 382 of file ZDCPulseAnalyzer.h.

m_fitTau1

float ZDCPulseAnalyzer::m_fitTau1 {}

private

Definition at line 326 of file ZDCPulseAnalyzer.h.

{};

m_fitTau2

float ZDCPulseAnalyzer::m_fitTau2 {}

private

Definition at line 327 of file ZDCPulseAnalyzer.h.

{};

m_fitTCorr2nd

float ZDCPulseAnalyzer::m_fitTCorr2nd {}

private

Definition at line 325 of file ZDCPulseAnalyzer.h.

{};

m_fitTime

float ZDCPulseAnalyzer::m_fitTime {}

private

Definition at line 321 of file ZDCPulseAnalyzer.h.

{};

m_fitTimeCorr

float ZDCPulseAnalyzer::m_fitTimeCorr {}

private

Definition at line 323 of file ZDCPulseAnalyzer.h.

{};

m_fitTimeSub

float ZDCPulseAnalyzer::m_fitTimeSub {}

private

Definition at line 322 of file ZDCPulseAnalyzer.h.

{};

m_fitTMax

float ZDCPulseAnalyzer::m_fitTMax {}

private

Definition at line 305 of file ZDCPulseAnalyzer.h.

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

m_fitTMin

float ZDCPulseAnalyzer::m_fitTMin {}

private

Definition at line 306 of file ZDCPulseAnalyzer.h.

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

m_fixPrePulse

bool ZDCPulseAnalyzer::m_fixPrePulse {false}

private

Definition at line 269 of file ZDCPulseAnalyzer.h.

{false};

m_fixTau1

bool ZDCPulseAnalyzer::m_fixTau1 {}

private

Definition at line 138 of file ZDCPulseAnalyzer.h.

{};

m_fixTau2

bool ZDCPulseAnalyzer::m_fixTau2 {}

private

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

{false};

m_haveFADCCorrections

bool ZDCPulseAnalyzer::m_haveFADCCorrections {false}

private

Definition at line 207 of file ZDCPulseAnalyzer.h.

{false};

m_haveNonlinCorr

bool ZDCPulseAnalyzer::m_haveNonlinCorr {false}

private

Definition at line 201 of file ZDCPulseAnalyzer.h.

{false};

m_havePulse

bool ZDCPulseAnalyzer::m_havePulse {false}

private

Definition at line 249 of file ZDCPulseAnalyzer.h.

{false};

m_haveSignifCuts

bool ZDCPulseAnalyzer::m_haveSignifCuts {false}

private

Definition at line 171 of file ZDCPulseAnalyzer.h.

{false};

m_HGOverflow

bool ZDCPulseAnalyzer::m_HGOverflow {false}

private

Definition at line 252 of file ZDCPulseAnalyzer.h.

{false};

m_HGOverflowADC

int ZDCPulseAnalyzer::m_HGOverflowADC {}

private

Definition at line 128 of file ZDCPulseAnalyzer.h.

{};

m_HGT0CorrParams

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

private

Definition at line 199 of file ZDCPulseAnalyzer.h.

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

m_HGUnderflow

bool ZDCPulseAnalyzer::m_HGUnderflow {false}

private

Definition at line 254 of file ZDCPulseAnalyzer.h.

{false};

m_HGUnderflowADC

int ZDCPulseAnalyzer::m_HGUnderflowADC {}

private

Definition at line 129 of file ZDCPulseAnalyzer.h.

{};

m_initialExpAmp

float ZDCPulseAnalyzer::m_initialExpAmp {}

private

Definition at line 301 of file ZDCPulseAnalyzer.h.

{};

m_initializedFits

bool ZDCPulseAnalyzer::m_initializedFits {false}

private

Definition at line 218 of file ZDCPulseAnalyzer.h.

{false};

m_initialPostPulseT0

float ZDCPulseAnalyzer::m_initialPostPulseT0 {}

private

Definition at line 317 of file ZDCPulseAnalyzer.h.

{};

m_initialPrePulseAmp

float ZDCPulseAnalyzer::m_initialPrePulseAmp {}

private

Definition at line 315 of file ZDCPulseAnalyzer.h.

{};

m_initialPrePulseT0

float ZDCPulseAnalyzer::m_initialPrePulseT0 {}

private

Definition at line 314 of file ZDCPulseAnalyzer.h.

{};

m_lastHGOverFlowSample

int ZDCPulseAnalyzer::m_lastHGOverFlowSample {-1}

private

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

{false};

m_LGOverflowADC

int ZDCPulseAnalyzer::m_LGOverflowADC {}

private

Definition at line 130 of file ZDCPulseAnalyzer.h.

{};

m_LGT0CorrParams

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

private

Definition at line 198 of file ZDCPulseAnalyzer.h.

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

m_LGUnderflow

bool ZDCPulseAnalyzer::m_LGUnderflow {false}

private

Definition at line 257 of file ZDCPulseAnalyzer.h.

{false};

m_maxADCHG

float ZDCPulseAnalyzer::m_maxADCHG {}

private

Definition at line 286 of file ZDCPulseAnalyzer.h.

{};

m_maxADCLG

float ZDCPulseAnalyzer::m_maxADCLG {}

private

Definition at line 290 of file ZDCPulseAnalyzer.h.

{};

m_maxADCSampleHG

int ZDCPulseAnalyzer::m_maxADCSampleHG

private

Definition at line 288 of file ZDCPulseAnalyzer.h.

m_maxADCSampleLG

int ZDCPulseAnalyzer::m_maxADCSampleLG

private

Definition at line 293 of file ZDCPulseAnalyzer.h.

m_maxDelta

float ZDCPulseAnalyzer::m_maxDelta {}

private

Definition at line 298 of file ZDCPulseAnalyzer.h.

{};

m_maxSampleEvt

unsigned int ZDCPulseAnalyzer::m_maxSampleEvt {}

private

Definition at line 228 of file ZDCPulseAnalyzer.h.

{};

m_maxSamplesPostExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPostExcl {0}

private

Definition at line 185 of file ZDCPulseAnalyzer.h.

{0};

m_maxSamplesPreExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPreExcl {0}

private

Definition at line 178 of file ZDCPulseAnalyzer.h.

{0};

m_minADCHG

float ZDCPulseAnalyzer::m_minADCHG {}

private

Definition at line 285 of file ZDCPulseAnalyzer.h.

{};

m_minADCLG

float ZDCPulseAnalyzer::m_minADCLG {}

private

Definition at line 291 of file ZDCPulseAnalyzer.h.

{};

m_minADCSampleHG

int ZDCPulseAnalyzer::m_minADCSampleHG

private

Definition at line 287 of file ZDCPulseAnalyzer.h.

m_minADCSampleLG

int ZDCPulseAnalyzer::m_minADCSampleLG

private

Definition at line 292 of file ZDCPulseAnalyzer.h.

m_minDelta

float ZDCPulseAnalyzer::m_minDelta {}

private

Definition at line 299 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2nd

float ZDCPulseAnalyzer::m_minDeriv2nd {}

private

Definition at line 302 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2ndIndex

int ZDCPulseAnalyzer::m_minDeriv2ndIndex {}

private

Definition at line 303 of file ZDCPulseAnalyzer.h.

{};

m_minDeriv2ndSig

float ZDCPulseAnalyzer::m_minDeriv2ndSig

private

Definition at line 310 of file ZDCPulseAnalyzer.h.

m_minSampleEvt

unsigned int ZDCPulseAnalyzer::m_minSampleEvt {}

private

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

{};

m_nominalT0LG

float ZDCPulseAnalyzer::m_nominalT0LG {}

private

Definition at line 133 of file ZDCPulseAnalyzer.h.

{};

m_nominalTau1

float ZDCPulseAnalyzer::m_nominalTau1 {}

private

Definition at line 135 of file ZDCPulseAnalyzer.h.

{};

m_nominalTau2

float ZDCPulseAnalyzer::m_nominalTau2 {}

private

Definition at line 136 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrParamsHG

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

private

Definition at line 204 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrParamsLG

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

private

Definition at line 205 of file ZDCPulseAnalyzer.h.

{};

m_nonLinCorrRefADC

float ZDCPulseAnalyzer::m_nonLinCorrRefADC {500}

private

Definition at line 202 of file ZDCPulseAnalyzer.h.

{500};

m_nonLinCorrRefScale

float ZDCPulseAnalyzer::m_nonLinCorrRefScale {100}

private

Definition at line 203 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 357 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 340 of file ZDCPulseAnalyzer.h.

{};

m_postExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclHGADCThresh {0}

private

Definition at line 183 of file ZDCPulseAnalyzer.h.

{0};

m_postExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclLGADCThresh {0}

private

Definition at line 184 of file ZDCPulseAnalyzer.h.

{0};

m_postPulse

bool ZDCPulseAnalyzer::m_postPulse {false}

private

Definition at line 260 of file ZDCPulseAnalyzer.h.

{false};

m_preAmplitude

float ZDCPulseAnalyzer::m_preAmplitude {}

private

Definition at line 339 of file ZDCPulseAnalyzer.h.

{};

m_preExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclHGADCThresh {0}

private

Definition at line 179 of file ZDCPulseAnalyzer.h.

{0};

m_preExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclLGADCThresh {0}

private

Definition at line 180 of file ZDCPulseAnalyzer.h.

{0};

m_preExpFitWrapper

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

private

Definition at line 221 of file ZDCPulseAnalyzer.h.

{};

m_preExpSig

float ZDCPulseAnalyzer::m_preExpSig

private

Definition at line 311 of file ZDCPulseAnalyzer.h.

m_preExpTail

bool ZDCPulseAnalyzer::m_preExpTail {false}

private

Definition at line 267 of file ZDCPulseAnalyzer.h.

{false};

m_prePulse

bool ZDCPulseAnalyzer::m_prePulse {false}

private

Definition at line 259 of file ZDCPulseAnalyzer.h.

{false};

m_prePulseCombinedFitter

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

private

Definition at line 238 of file ZDCPulseAnalyzer.h.

{};

m_prePulseFitWrapper

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

private

Definition at line 220 of file ZDCPulseAnalyzer.h.

{};

m_prePulseSig

float ZDCPulseAnalyzer::m_prePulseSig

private

Definition at line 312 of file ZDCPulseAnalyzer.h.

m_preSample

float ZDCPulseAnalyzer::m_preSample {}

private

Definition at line 283 of file ZDCPulseAnalyzer.h.

{};

m_preSampleAmp

float ZDCPulseAnalyzer::m_preSampleAmp {}

private

Definition at line 338 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 255 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 349 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGAmpl

float ZDCPulseAnalyzer::m_refitLGAmpl {0}

private

Definition at line 346 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGAmplCorr

float ZDCPulseAnalyzer::m_refitLGAmplCorr {0}

private

Definition at line 348 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGChisq

float ZDCPulseAnalyzer::m_refitLGChisq {0}

private

Definition at line 350 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGFitAmpl

float ZDCPulseAnalyzer::m_refitLGFitAmpl {0}

private

Definition at line 347 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGTime

float ZDCPulseAnalyzer::m_refitLGTime {0}

private

Definition at line 351 of file ZDCPulseAnalyzer.h.

{0};

m_refitLGTimeSub

float ZDCPulseAnalyzer::m_refitLGTimeSub {0}

private

Definition at line 352 of file ZDCPulseAnalyzer.h.

{0};

m_repassPulse

bool ZDCPulseAnalyzer::m_repassPulse {false}

private

Definition at line 271 of file ZDCPulseAnalyzer.h.

{false};

m_samplesDeriv2nd

std::vector<float> ZDCPulseAnalyzer::m_samplesDeriv2nd

private

Definition at line 375 of file ZDCPulseAnalyzer.h.

m_samplesLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesLGRefit

private

Definition at line 372 of file ZDCPulseAnalyzer.h.

m_samplesSig

std::vector<float> ZDCPulseAnalyzer::m_samplesSig

private

Definition at line 370 of file ZDCPulseAnalyzer.h.

m_samplesSigLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesSigLGRefit

private

Definition at line 373 of file ZDCPulseAnalyzer.h.

m_samplesSub

std::vector<float> ZDCPulseAnalyzer::m_samplesSub

private

Definition at line 369 of file ZDCPulseAnalyzer.h.

m_saveFitFunc

bool ZDCPulseAnalyzer::m_saveFitFunc {false}

private

Definition at line 100 of file ZDCPulseAnalyzer.h.

{false};

m_sigMinHG

float ZDCPulseAnalyzer::m_sigMinHG {}

private

Definition at line 172 of file ZDCPulseAnalyzer.h.

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

m_sigMinLG

float ZDCPulseAnalyzer::m_sigMinLG {}

private

Definition at line 173 of file ZDCPulseAnalyzer.h.

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

m_T0CutHighHG

float ZDCPulseAnalyzer::m_T0CutHighHG {}

private

Definition at line 155 of file ZDCPulseAnalyzer.h.

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

m_T0CutHighLG

float ZDCPulseAnalyzer::m_T0CutHighLG {}

private

Definition at line 152 of file ZDCPulseAnalyzer.h.

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

m_T0CutLowHG

float ZDCPulseAnalyzer::m_T0CutLowHG {}

private

Definition at line 154 of file ZDCPulseAnalyzer.h.

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

m_T0CutLowLG

float ZDCPulseAnalyzer::m_T0CutLowLG {}

private

Definition at line 151 of file ZDCPulseAnalyzer.h.

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

m_t0CutSig

float ZDCPulseAnalyzer::m_t0CutSig {}

private

Definition at line 159 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 160 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 157 of file ZDCPulseAnalyzer.h.

{};

m_timeResFuncLG_p

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

private

Definition at line 158 of file ZDCPulseAnalyzer.h.

{};

m_timeSig

float ZDCPulseAnalyzer::m_timeSig {}

private

Definition at line 324 of file ZDCPulseAnalyzer.h.

{};

m_timingCorrMode

unsigned int ZDCPulseAnalyzer::m_timingCorrMode {NoTimingCorr}

private

Definition at line 195 of file ZDCPulseAnalyzer.h.

{NoTimingCorr};

m_timingCorrRefADC

float ZDCPulseAnalyzer::m_timingCorrRefADC {500}

private

Definition at line 196 of file ZDCPulseAnalyzer.h.

{500};

m_timingCorrScale

float ZDCPulseAnalyzer::m_timingCorrScale {100}

private

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

{0};

m_underFlowExclSamplesPostLG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPostLG {0}

private

Definition at line 192 of file ZDCPulseAnalyzer.h.

{0};

m_underFlowExclSamplesPreHG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPreHG {0}

private

Definition at line 189 of file ZDCPulseAnalyzer.h.

{0};

m_underFlowExclSamplesPreLG

unsigned int ZDCPulseAnalyzer::m_underFlowExclSamplesPreLG {0}

private

Definition at line 191 of file ZDCPulseAnalyzer.h.

{0};

m_underflowExclusion

bool ZDCPulseAnalyzer::m_underflowExclusion {false}

private

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

{};

m_useFixedBaseline

bool ZDCPulseAnalyzer::m_useFixedBaseline {}

private

Definition at line 232 of file ZDCPulseAnalyzer.h.

{};

m_useLowGain

bool ZDCPulseAnalyzer::m_useLowGain {false}

private

Definition at line 250 of file ZDCPulseAnalyzer.h.

{false};

m_useSampleHG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleHG

private

Definition at line 364 of file ZDCPulseAnalyzer.h.

m_useSampleLG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleLG

private

Definition at line 363 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