ATLAS Offline Software
Public Types | Public Member Functions | Static Public Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
ZDCPulseAnalyzer Class Reference

#include <ZDCPulseAnalyzer.h>

Collaboration diagram for ZDCPulseAnalyzer:

Public Types

enum  {
  PulseBit = 0, LowGainBit = 1, FailBit = 2, HGOverflowBit = 3,
  HGUnderflowBit = 4, PSHGOverUnderflowBit = 5, LGOverflowBit = 6, LGUnderflowBit = 7,
  PrePulseBit = 8, PostPulseBit = 9, FitFailedBit = 10, BadChisqBit = 11,
  BadT0Bit = 12, ExcludeEarlyLGBit = 13, ExcludeLateLGBit = 14, preExpTailBit = 15,
  FitMinAmpBit = 16, RepassPulseBit = 17, ArmSumIncludeBit = 18, FailSigCutBit = 19,
  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
 
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
 

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, float maxChisqDivAmp, float minT0Corr, float maxT0Corr)
 
double getAmplitudeCorrection (bool highGain)
 
void prepareLGRefit (const std::vector< float > &samplesLG, const std::vector< float > &samplesSig, const std::vector< bool > &useSamples)
 
void FillHistogram (bool refitLG)
 
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

bool m_quietFits {}
 
bool m_saveFitFunc {}
 
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 {}
 
std::string m_fitFunction {}
 
size_t m_2ndDerivStep {1}
 
size_t m_peak2ndDerivMinSample {}
 
size_t m_peak2ndDerivMinTolerance {1}
 
float m_peak2ndDerivMinThreshLG {}
 
float m_peak2ndDerivMinThreshHG {}
 
bool m_useDelayed {false}
 
bool m_enableRepass {false}
 
float m_peak2ndDerivMinRepassLG {}
 
float m_peak2ndDerivMinRepassHG {}
 
float m_gainFactorHG {}
 
float m_gainFactorLG {}
 
float m_noiseSigHG {}
 
float m_noiseSigLG {}
 
std::string m_fitOptions {}
 
int m_HGOverflowADC {}
 
int m_HGUnderflowADC {}
 
int m_LGOverflowADC {}
 
float m_nominalT0HG {}
 
float m_nominalT0LG {}
 
float m_nominalTau1 {}
 
float m_nominalTau2 {}
 
bool m_fixTau1 {}
 
bool m_fixTau2 {}
 
float m_defaultFitTMax {}
 
float m_defaultFitTMin {}
 
float m_chisqDivAmpCutLG {}
 
float m_chisqDivAmpCutHG {}
 
float m_T0CutLowLG {}
 
float m_T0CutHighLG {}
 
float m_T0CutLowHG {}
 
float m_T0CutHighHG {}
 
std::unique_ptr< const TF1 > m_timeResFuncHG_p {}
 
std::unique_ptr< const TF1 > m_timeResFuncLG_p {}
 
float m_t0CutSig {}
 
unsigned int m_timeCutMode {0}
 
float m_defaultT0Max {}
 
float m_defaultT0Min {}
 
float m_fitAmpMinHG {}
 
float m_fitAmpMinLG {}
 
float m_fitAmpMaxHG {}
 
float m_fitAmpMaxLG {}
 
bool m_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}
 
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 {}
 
bool m_havePulse {}
 
bool m_useLowGain {}
 
bool m_fail {}
 
bool m_HGOverflow {}
 
bool m_HGUnderflow {}
 
bool m_PSHGOverUnderflow {}
 
bool m_LGOverflow {}
 
bool m_LGUnderflow {}
 
bool m_prePulse {}
 
bool m_postPulse {}
 
bool m_fitFailed {}
 
bool m_badChisq {}
 
bool m_badT0 {}
 
bool m_ExcludeEarly {}
 
bool m_ExcludeLate {}
 
bool m_preExpTail {}
 
bool m_fixPrePulse {}
 
bool m_fitMinAmp {}
 
bool m_repassPulse {}
 
bool m_failSigCut {}
 
bool m_backToHG_pre {}
 
float m_baselineCorr {}
 
int m_usedPresampIdx {}
 
float m_preSample {}
 
float m_minADCHG {}
 
float m_maxADCHG {}
 
int m_minADCSampleHG
 
int m_maxADCSampleHG
 
float m_maxADCLG {}
 
float m_minADCLG {}
 
int m_minADCSampleLG
 
int m_maxADCSampleLG
 
float m_ADCPeakHG {}
 
float m_ADCPeakLG {}
 
float m_maxDelta {}
 
float m_minDelta {}
 
float m_initialExpAmp {}
 
float m_minDeriv2nd {}
 
int m_minDeriv2ndIndex {}
 
float m_fitTMax {}
 
float m_fitTMin {}
 
float m_fitPostT0lo {}
 
float m_minDeriv2ndSig
 
float m_preExpSig
 
float m_prePulseSig
 
float m_initialPrePulseT0 {}
 
float m_initialPrePulseAmp {}
 
float m_initialPostPulseT0 {}
 
float m_fitAmplitude {}
 
float m_fitAmpError {}
 
float m_fitTime {}
 
float m_fitTimeSub {}
 
float m_fitTimeCorr {}
 
float m_timeSig {}
 
float m_fitTCorr2nd {}
 
float m_fitTau1 {}
 
float m_fitTau2 {}
 
float m_fitChisq {}
 
float m_fitNDoF {}
 
float m_fitPreT0 {}
 
float m_fitPreAmp {}
 
float m_fitPostT0 {}
 
float m_fitPostAmp {}
 
float m_fitExpAmp {}
 
float m_amplitude {}
 
float m_ampNoNonLin {}
 
float m_ampError {}
 
float m_preSampleAmp {}
 
float m_preAmplitude {}
 
float m_postAmplitude {}
 
float m_expAmplitude {}
 
float m_bkgdMaxFraction {}
 
float m_delayedBaselineShift {}
 
bool m_evtLGRefit {false}
 
float m_refitLGAmpl {0}
 
float m_refitLGFitAmpl {0}
 
float m_refitLGAmplCorr {0}
 
float m_refitLGAmpError {0}
 
float m_refitLGChisq {0}
 
float m_refitLGTime {0}
 
float m_refitLGTimeSub {0}
 
int m_lastHGOverFlowSample {-1}
 
int m_firstHGOverFlowSample {-1}
 
unsigned int m_NSamplesAna {0}
 
std::vector< float > m_ADCSamplesHG
 
std::vector< float > m_ADCSamplesLG
 
std::vector< float > m_ADCSamplesHGSub
 
std::vector< float > m_ADCSamplesLGSub
 
std::vector< bool > m_useSampleLG
 
std::vector< bool > m_useSampleHG
 
std::vector< float > m_ADCSSampSigHG
 
std::vector< float > m_ADCSSampSigLG
 
std::vector< float > m_samplesSub
 
std::vector< float > m_samplesSig
 
std::vector< float > m_samplesLGRefit
 
std::vector< float > m_samplesSigLGRefit
 
std::vector< float > m_samplesDeriv2nd
 
std::vector< float > m_fitPulls
 

Static Private Attributes

static 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

◆ 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 73 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 
N_STATUS_BITS 

Definition at line 28 of file ZDCPulseAnalyzer.h.

28  {PulseBit = 0, // &1
29  LowGainBit = 1, // &2
30  FailBit = 2, // &4
31  HGOverflowBit = 3, // &8
32  // -------------------------
33  HGUnderflowBit = 4, // &16
34  PSHGOverUnderflowBit = 5, // &32
35  LGOverflowBit = 6, // &64
36  LGUnderflowBit = 7, // &128
37  // -------------------------
38  PrePulseBit = 8, // &256
39  PostPulseBit = 9, // &512
40  FitFailedBit = 10, // &1024
41  BadChisqBit = 11, // &2048
42  // -------------------------
43  BadT0Bit = 12, // &4096
44  ExcludeEarlyLGBit = 13, // &8192
45  ExcludeLateLGBit = 14, // &16384
46  preExpTailBit = 15, // &32768
47  //
48  FitMinAmpBit = 16, // 0x10000
49  RepassPulseBit = 17, // 0x20000
50  ArmSumIncludeBit = 18, // 0x40000
51  FailSigCutBit = 19, // 0x80000
52  N_STATUS_BITS
53  };

◆ LowGainMode

enum ZDCPulseAnalyzer::LowGainMode
Enumerator
LGModeNormal 
LGModeForceLG 
LGModeRefitLG 

Definition at line 55 of file ZDCPulseAnalyzer.h.

55  {
56  LGModeNormal = 0,
57  LGModeForceLG,
58  LGModeRefitLG
59  };

◆ TimingCorrMode

enum ZDCPulseAnalyzer::TimingCorrMode
Enumerator
NoTimingCorr 
TimingCorrLin 
TimingCorrLog 

Definition at line 61 of file ZDCPulseAnalyzer.h.

61 {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 138 of file ZDCPulseAnalyzer.cxx.

140  :
141  m_msgFunc_p(std::move(msgFunc_p)),
142  m_tag(tag), m_Nsample(Nsample),
143  m_preSampleIdx(preSampleIdx),
144  m_deltaTSample(deltaTSample),
145  m_pedestal(pedestal), m_fitFunction(fitFunction),
146  m_peak2ndDerivMinSample(peak2ndDerivMinSample),
147  m_peak2ndDerivMinThreshLG(peak2ndDerivMinThreshLG),
148  m_peak2ndDerivMinThreshHG(peak2ndDerivMinThreshHG),
149  m_ADCSamplesHGSub(Nsample, 0), m_ADCSamplesLGSub(Nsample, 0),
150  m_ADCSSampSigHG(Nsample, 0), m_ADCSSampSigLG(Nsample, 0),
151  m_samplesSub(Nsample, 0)
152 {
153  // Create the histogram used for fitting
154  //
155  m_tmin = -deltaTSample / 2;
156  m_tmax = m_tmin + ((float) Nsample) * deltaTSample;
157  m_defaultFitTMax = m_tmax;
158 
159  std::string histName = "ZDCFitHist" + tag;
160  std::string histNameLGRefit = "ZDCFitHist" + tag + "_LGRefit";
161 
162  m_fitHist = std::make_unique<TH1F>(histName.c_str(), "", m_Nsample, m_tmin, m_tmax);
163  m_fitHistLGRefit = std::make_unique<TH1F>(histNameLGRefit.c_str(), "", m_Nsample, m_tmin, m_tmax);
164 
165  m_fitHist->SetDirectory(0);
166  m_fitHistLGRefit->SetDirectory(0);
167 
168  SetDefaults();
169  Reset();
170 }

◆ ZDCPulseAnalyzer() [2/2]

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

Definition at line 172 of file ZDCPulseAnalyzer.cxx.

172  :
173  m_msgFunc_p(std::move(msgFunc_p))
174 {
175  SetDefaults();
176 
177  // auto [result, resultString] = ValidateJSONConfig(configJSON);
178  // (*m_msgFunc_p)(ZDCMsg::Debug, "ValidateJSON produced result: " + resultString);
179 
180  auto [result2, resultString2] = ConfigFromJSON(configJSON);
181  (*m_msgFunc_p)(ZDCMsg::Debug, "ConfigFromJSON produced result: "+ resultString2);
182 
183  dumpConfiguration();
184 
185  // Create the histogram used for fitting
186  //
187  if (m_freqMHz >1.e-6) m_deltaTSample = 1000./m_freqMHz;
188  m_tmin = -m_deltaTSample / 2;
189  m_tmax = m_tmin + ((float)m_Nsample) * m_deltaTSample;
190  m_defaultFitTMax = m_tmax;
191 
192  std::string histName = "ZDCFitHist" + m_tag;
193  std::string histNameLGRefit = "ZDCFitHist" + m_tag + "_LGRefit";
194 
195  m_fitHist = std::make_unique<TH1F>(histName.c_str(), "", m_Nsample, m_tmin, m_tmax);
196  m_fitHistLGRefit = std::make_unique<TH1F>(histNameLGRefit.c_str(), "", m_Nsample, m_tmin, m_tmax);
197 
198  m_fitHist->SetDirectory(0);
199  m_fitHistLGRefit->SetDirectory(0);
200 
201  Reset();
202 }

◆ ~ZDCPulseAnalyzer()

ZDCPulseAnalyzer::~ZDCPulseAnalyzer ( )
inline

Definition at line 469 of file ZDCPulseAnalyzer.h.

469 {}

Member Function Documentation

◆ AnalyzeData()

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

Definition at line 1123 of file ZDCPulseAnalyzer.cxx.

1132 {
1133 
1134  // We keep track of which sample we used to do the subtraction sepaate from m_minSampleEvt
1135  // because the corresponding time is the reference time we provide to the fit function when
1136  // we have pre-pulses and in case we change the m_minSampleEvt after doing the subtraction
1137  //
1138  // e.g. our refit when the chisquare cuts fails
1139  //
1140 
1141  // Find the first used sample in the event
1142  //
1143  bool haveFirst = false;
1144  unsigned int lastUsed = 0;
1145 
1146  for (unsigned int sample = preSampleIdx; sample < nSamples; sample++) {
1147  if (useSample[sample]) {
1148  //
1149  // We're going to use this sample in the analysis, update bookeeping
1150  //
1151  if (!haveFirst) {
1152  if (sample > m_minSampleEvt) m_minSampleEvt = sample;
1153  haveFirst = true;
1154  }
1155  else {
1156  lastUsed = sample;
1157  }
1158  }
1159  }
1160 
1161  if (lastUsed < m_maxSampleEvt) m_maxSampleEvt = lastUsed;
1162 
1163  // Check to see whether we've changed the range of samples used in the analysis
1164  //
1165  // Should be obseleted with reworking of the fitting using Root::Fit package
1166  //
1167  if (m_minSampleEvt > preSampleIdx) {
1168  m_ExcludeEarly = true;
1169  m_adjTimeRangeEvent = true;
1170  }
1171 
1172  if (m_maxSampleEvt < nSamples - 1) {
1173  m_adjTimeRangeEvent = true;
1174  m_ExcludeLate = true;
1175  }
1176 
1177  // Prepare for subtraction
1178  //
1179  m_usedPresampIdx = m_minSampleEvt;
1180  m_preSample = samples[m_usedPresampIdx];
1181 
1182  // std::ostringstream pedMessage;
1183  // pedMessage << "Pedestal index = " << m_usedPresampIdx << ", value = " << m_preSample;
1184  // (*m_msgFunc_p)(ZDCMsg::Verbose, pedMessage.str().c_str());
1185 
1186  m_samplesSub = samples;
1187  m_samplesSig.assign(m_NSamplesAna, noiseSig);
1188 
1189 
1190  //
1191  // When we are combinig delayed and undelayed samples we have to deal with the fact that
1192  // the two readouts can have different noise and thus different baselines. Which is a huge
1193  // headache.
1194  //
1195  if (m_useDelayed) {
1196  if (m_useFixedBaseline) {
1197  m_baselineCorr = m_delayedPedestalDiff;
1198  }
1199  else {
1200  //
1201  // Use much-improved method to match delayed and undelayed baselines
1202  //
1203  m_baselineCorr = obtainDelayedBaselineCorr(m_samplesSub);
1204  std::ostringstream baselineMsg;
1205  baselineMsg << "Delayed samples baseline correction = " << m_baselineCorr << std::endl;
1206  (*m_msgFunc_p)(ZDCMsg::Debug, baselineMsg.str().c_str());
1207  }
1208 
1209  // Now apply the baseline correction to align ADC values for delayed and undelayed samples
1210  //
1211  for (size_t isample = 0; isample < nSamples; isample++) {
1212  if (isample % 2) m_samplesSub[isample] -= m_baselineCorr;
1213  }
1214 
1215  // If we use one of the delayed samples for presample, we have to adjust the presample value as well
1216  //
1217  if (m_usedPresampIdx % 2) m_preSample -= m_baselineCorr;
1218  }
1219 
1220  // Do the presample subtraction
1221  //
1222  std::for_each(m_samplesSub.begin(), m_samplesSub.end(), [ = ] (float & adcUnsub) {return adcUnsub -= m_preSample;} );
1223 
1224  // Calculate the second derivatives using step size m_2ndDerivStep
1225  //
1226  m_samplesDeriv2nd = Calculate2ndDerivative(m_samplesSub, m_2ndDerivStep);
1227 
1228  // Find the sample which has the lowest 2nd derivative. We loop over the range defined by the
1229  // tolerance on the position of the minimum second derivative. Note: the +1 in the upper iterator is because
1230  // that's where the loop terminates, not the last element.
1231  //
1232  SampleCIter minDeriv2ndIter;
1233 
1234  int upperDelta = std::min(m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 1, nSamples);
1235 
1236  minDeriv2ndIter = std::min_element(m_samplesDeriv2nd.begin() + m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance, m_samplesDeriv2nd.begin() + upperDelta);
1237 
1238  m_minDeriv2nd = *minDeriv2ndIter;
1239  m_minDeriv2ndSig = -m_minDeriv2nd/(std::sqrt(6.0)*noiseSig);
1240 
1241  m_minDeriv2ndIndex = std::distance(m_samplesDeriv2nd.cbegin(), minDeriv2ndIter);
1242 
1243  // BAC 02-04-23 This check turned out to be problematic. Todo: figure out how to replace
1244  //
1245  // // Also check the ADC value for the "peak" sample to make sure it is significant (at least 3 sigma)
1246  // // The factor of sqrt(2) on the noise is because we have done a pre-sample subtraction
1247  // //
1248  if (std::abs(m_minDeriv2nd) >= peak2ndDerivMinThresh) {
1249  m_havePulse = true;
1250  }
1251  else {
1252  m_havePulse = false;
1253  }
1254 
1255  // save the low and high gain ADC values at the peak -- if we have a pulse, at m_minDeriv2ndIndex
1256  // otherwise at m_peak2ndDerivMinSample
1257  //
1258  if (m_havePulse) {
1259  m_ADCPeakHG = m_ADCSamplesHG.at(m_minDeriv2ndIndex);
1260  m_ADCPeakLG = m_ADCSamplesLG.at(m_minDeriv2ndIndex);
1261  }
1262  else {
1263  m_ADCPeakHG = m_ADCSamplesHG.at(m_peak2ndDerivMinSample);
1264  m_ADCPeakLG = m_ADCSamplesLG.at(m_peak2ndDerivMinSample);
1265  }
1266 
1267  // Now decide whether we have a preceeding pulse or not. There are two possible kinds of preceeding pulses:
1268  // 1) exponential tail from a preceeding pulse
1269  // 2) peaked pulse before the main pulse
1270  //
1271  // we can, of course, have both
1272  //
1273 
1274  // To check for exponential tail, test the slope determined by the minimum ADC value (and pre-sample)
1275  // **beware** this can cause trouble in 2015 data where the pulses had overshoot due to the transformers
1276  //
1277 
1278  // Implement a much simpler test for presence of an exponential tail from an OOT pulse
1279  // namely if the slope evaluated at the presample is significantly negative, then
1280  // we have a preceeding pulse.
1281  //
1282  // Note that we don't have to subtract the FADC value corresponding to the presample because
1283  // that subtraction has already been done.
1284  //
1285  if (m_havePulse) {
1286  // If we've alreday excluded early samples, we have almost by construction have negative exponential tail
1287  //
1288  if (m_ExcludeEarly) m_preExpTail = true;
1289 
1290  //
1291  // The subtracted ADC value at m_usedPresampIdx is, by construction, zero
1292  // The next sample has had the pre-sample subtracted, so it represents the initial derivative
1293  //
1294  float derivPresampleSig = m_samplesSub[m_usedPresampIdx+1]/(std::sqrt(2.0)*noiseSig);
1295  if (derivPresampleSig < -5) {
1296  m_preExpTail = true;
1297  m_preExpSig = derivPresampleSig;
1298  }
1299 
1300  for (unsigned int isample = m_usedPresampIdx; isample < m_samplesSub.size(); isample++) {
1301  if (!useSample[isample]) continue;
1302 
1303  float sampleSig = -m_samplesSub[isample]/(std::sqrt(2.0)*noiseSig);
1304 
1305  // Compare the derivative significant to the 2nd derivative significance,
1306  // so we don't waste time dealing with small perturbations on large signals
1307  //
1308  if ((sampleSig > 5 && sampleSig > 0.02*m_minDeriv2ndSig) || sampleSig > 0.5*m_minDeriv2ndSig) {
1309  m_preExpTail = true;
1310  if (sampleSig > m_preExpSig) m_preExpSig = sampleSig;
1311  }
1312  }
1313 
1314  // Now we search for maxima before the main pulse
1315  //
1316  int loopLimit = (m_havePulse ? m_minDeriv2ndIndex - 2 : m_peak2ndDerivMinSample - 2);
1317  int loopStart = m_minSampleEvt == 0 ? 1 : m_minSampleEvt;
1318 
1319  float maxPrepulseSig = 0;
1320  unsigned int maxPrepulseSample = 0;
1321 
1322  for (int isample = loopStart; isample <= loopLimit; isample++) {
1323  if (!useSample[isample]) continue;
1324 
1325  //
1326  // If any of the second derivatives prior to the peak are significantly negative, we have a an extra pulse
1327  // prior to the main one -- as opposed to just an expnential tail
1328  //
1329  float prePulseSig = -m_samplesDeriv2nd[isample]/(std::sqrt(6.0)*noiseSig);
1330 
1331  // std::cout << m_tag << ", for sample " << isample << ", 2nd derivative = " << m_samplesDeriv2nd[isample]
1332  // << " 0.05 * m_minDeriv2nd) = " << 0.05 * m_minDeriv2nd
1333  // << ", prePulseSig = " << prePulseSig << std::endl;
1334 
1335  if ((prePulseSig > 6 && m_samplesDeriv2nd[isample] < 0.05 * m_minDeriv2nd) ||
1336  m_samplesDeriv2nd[isample] < 0.5*m_minDeriv2nd)
1337  {
1338  m_prePulse = true;
1339  if (prePulseSig > maxPrepulseSig) {
1340  maxPrepulseSig = prePulseSig;
1341  maxPrepulseSample = isample;
1342  }
1343  }
1344  }
1345 
1346  if (m_prePulse) {
1347  // std::cout << m_tag << ": prepulse sigma = " << m_prePulseSig << ", pre exp sigma = " << m_preExpSig << std::endl;
1348  m_prePulseSig = maxPrepulseSig;
1349 
1350  if (m_preExpTail) {
1351  //
1352  // We have a prepulse. If we already indicated an negative exponential,
1353  // if the prepulse has greater significance, we override the negative exponential
1354  //
1355  if (m_prePulseSig > m_preExpSig) {
1356  m_preExpTail = false;
1357  }
1358  else {
1359  m_prePulse = false;
1360  }
1361  }
1362 
1363  m_initialPrePulseAmp = m_samplesSub[maxPrepulseSample];
1364  m_initialPrePulseT0 = m_deltaTSample * (maxPrepulseSample);
1365  }
1366 
1367  // if (m_preExpTail) m_prePulse = true;
1368 
1369  // -----------------------------------------------------
1370  // Post pulse detection
1371  //
1372  unsigned int postStartIdx = std::max(static_cast<unsigned int>(m_minDeriv2ndIndex + 2),
1373  static_cast<unsigned int>(m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 1));
1374 
1375 
1376  for (int isample = postStartIdx; isample < (int) nSamples - 1; isample++) {
1377  if (!useSample.at(isample)) continue;
1378 
1379  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1380  // BAC 12-01-2024
1381  //
1382  // The following code is commented out as a temporary measure to deal with apparent reflections
1383  // associated with large out-of-time pulses that introduce a "kink" that triggers the derivative
1384  // test. A work-around that doesn't introduce specific code for the 2023 Pb+Pb run but allows
1385  // adaption for this specific issue is going to take some work. For now we leave the 2nd derivative
1386  // test, but will also need to introduce some configurability of the cut -- which we need anyway
1387  //
1388  // Calculate the forward derivative. the pulse should never increase on the tail. If it
1389  // does, we almost certainly have a post-pulse
1390  //
1391  // float deriv = m_samplesSub[isample + 1] - m_samplesSub[isample];
1392  // if (deriv/(std::sqrt(2)*noiseSig) > 6) {
1393  // m_postPulse = true;
1394  // m_maxSampleEvt = isample;
1395  // m_adjTimeRangeEvent = true;
1396  // break;
1397  // }
1398  // else {
1399  //----------------------------------------------------------------------------------------------
1400  //
1401  // Now we check the second derivative which might also indicate a post pulse
1402  // even if the derivative is not sufficiently large
1403  //
1404  // add small 1e-3 in division to avoid floating overflow
1405  //
1406 
1407  float deriv = m_samplesSub.at(isample + 1) - m_samplesSub.at(isample);
1408  float derivSig = deriv/(std::sqrt(2)*noiseSig);
1409  float deriv2ndSig = -m_samplesDeriv2nd.at(isample) / (std::sqrt(6)*noiseSig);
1410 
1411  float deriv2ndTest = m_samplesDeriv2nd.at(isample) / (-m_minDeriv2nd + 1.0e-3);
1412 
1413  if (derivSig > 5) {
1414  //
1415  // Check the 2nd derivative -- we should be at a minimum(?)
1416  //
1417  if (std::abs(deriv2ndTest) > 0.15) {
1418  m_postPulse = true;
1419  m_maxSampleEvt = std::min<int>(isample - (m_2ndDerivStep - 1), m_maxSampleEvt);
1420 
1421  m_adjTimeRangeEvent = true;
1422  break;
1423  }
1424  }
1425 
1426  // The place to apply the cut on samples depends on whether we have found a "minimum" or a "maximum"
1427  // The -m_2ndDerivStep for the minimum accounts for the shift between 2nd derivative and the samples
1428  // if we find a maximum we cut one sample lower
1429  //
1430  if (deriv2ndSig > 5 && deriv2ndTest < -0.1) {
1431  m_postPulse = true;
1432  m_maxSampleEvt = std::min<int>(isample - m_2ndDerivStep, m_maxSampleEvt);
1433 
1434  m_adjTimeRangeEvent = true;
1435  break;
1436  }
1437  }
1438  }
1439 
1440  if (m_postPulse) {
1441  std::ostringstream ostrm;
1442  ostrm << "Post pulse found, m_maxSampleEvt = " << m_maxSampleEvt;
1443  (*m_msgFunc_p)(ZDCMsg::Debug, ostrm.str());
1444  }
1445 
1446 
1447  // -----------------------------------------------------
1448 
1449  // Stop now if we have no pulse or we've detected a failure
1450  //
1451  if (m_fail || !m_havePulse) return false;
1452 
1453  if (!m_useDelayed) DoFit();
1454  else DoFitCombined();
1455 
1456  if (fitFailed()) {
1457  m_fail = true;
1458  }
1459  else {
1460  std::ostringstream ostrm;
1461  // ostrm << "Pulse fit successful with chisquare = " << m_fitChisq;
1462  // (*m_msgFunc_p)(ZDCMsg::Debug, ostrm.str());
1463 
1464  m_fitTimeCorr = m_fitTimeSub;
1465 
1466  if (m_timingCorrMode != NoTimingCorr) {
1467  //
1468  // We correct relative to the m_timingCorrRefADC using m_timingCorrScale to scale
1469  //
1470  double t0CorrFact = (m_fitAmplitude - m_timingCorrRefADC) / m_timingCorrScale;
1471  if (m_timingCorrMode == TimingCorrLog) t0CorrFact = std::log(t0CorrFact);
1472 
1473  // Calculate the correction using a polynomial of power determined by the size of the vector.
1474  // For historical reasons we include here a constant term, though it is degenerate with
1475  // the nominal t0 and/or timing calibrations.
1476  //
1477  float correction = 0;
1478 
1479  for (unsigned int ipow = 0; ipow < t0CorrParams.size(); ipow++) {
1480  correction += t0CorrParams[ipow]*std::pow(t0CorrFact, double(ipow));
1481  }
1482 
1483  // The correction represents the offset of the timing value from zero so we subtract the result
1484  //
1485  m_fitTimeCorr -= correction;
1486  }
1487 
1488  bool failFixedCut = m_fitTimeCorr < minT0Corr || m_fitTimeCorr > maxT0Corr;
1489 
1490  // Calculate the timing significance. Note this implementation breaks the model for
1491  // how DoAnalysis is currently used by explicitly testing m_useLowGain, but that model
1492  // needs adjustment anyway ... (one step at a time)
1493  //
1494  // Note that to avoid coupling non-linear corrections to the amplitude and the
1495  // timing significance we evaluate the time resolution using the fit amplitude
1496  //
1497  if (m_timeCutMode != 0) {
1498  double timeResolution = 0;
1499  if (m_useLowGain) timeResolution = m_timeResFuncLG_p->Eval(m_fitAmplitude);
1500  else timeResolution = m_timeResFuncHG_p->Eval(m_fitAmplitude);
1501 
1502  m_timeSig = m_fitTimeCorr/timeResolution;
1503  if (std::abs(m_timeSig) > m_t0CutSig) {
1504  //
1505  // We've failed the significance cut. In OR mode (1) we mark the time
1506  // as bad if we've lso failed the fixed cut. In AND mode, we mark it
1507  // as bad regardless of the fixed cut.
1508  //
1509  if (m_timeCutMode == 1) {
1510  if (failFixedCut) m_badT0 = true;
1511  }
1512  else m_badT0 = true;
1513  }
1514  else if (m_timeCutMode == 2 && failFixedCut) m_badT0 = failFixedCut;
1515  }
1516  else {
1517  m_timeSig = -1;
1518  m_badT0 = failFixedCut;
1519  }
1520 
1521  // Now check for valid chisq and valid time
1522  //
1523  if (m_fitChisq/m_fitNDoF > 2 && m_fitChisq / (m_fitAmplitude + 1.0e-6) > maxChisqDivAmp) m_badChisq = true;
1524  }
1525 
1526  return !m_fitFailed;
1527 }

◆ armSumInclude()

bool ZDCPulseAnalyzer::armSumInclude ( ) const
inline

Definition at line 606 of file ZDCPulseAnalyzer.h.

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

◆ badChisq()

bool ZDCPulseAnalyzer::badChisq ( ) const
inline

Definition at line 598 of file ZDCPulseAnalyzer.h.

598 {return m_badChisq;}

◆ badT0()

bool ZDCPulseAnalyzer::badT0 ( ) const
inline

Definition at line 600 of file ZDCPulseAnalyzer.h.

600 {return m_badT0;}

◆ Calculate2ndDerivative()

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

Definition at line 2311 of file ZDCPulseAnalyzer.cxx.

2312 {
2313  unsigned int nSamples = inputData.size();
2314 
2315  // We start with two zero entries for which we can't calculate the double-step derivative
2316  // and would pad with two zero entries at the end. Start by initializing
2317  //
2318  unsigned int vecSize = 2*step + nSamples - step - 1;
2319  std::vector<float> results(vecSize, 0);
2320 
2321  unsigned int fillIndex = step;
2322  for (unsigned int sample = step; sample < nSamples - step; sample++) {
2323  int deriv2nd = inputData[sample + step] + inputData[sample - step] - 2*inputData[sample];
2324  results.at(fillIndex++) = deriv2nd;
2325  }
2326 
2327  return results;
2328 }

◆ CalculateDerivative()

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

Definition at line 2290 of file ZDCPulseAnalyzer.cxx.

2291 {
2292  unsigned int nSamples = inputData.size();
2293 
2294  // 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
2295  //
2296  unsigned int vecSize = 2*(step - 1) + nSamples - step - 1;
2297  std::vector<float> results(vecSize, 0);
2298 
2299  // Now fill out the values
2300  //
2301  unsigned int fillIdx = step - 1;
2302 
2303  for (unsigned int sample = 0; sample < nSamples - step; sample++) {
2304  int deriv = inputData[sample + step] - inputData[sample];
2305  results.at(fillIdx++) = deriv;
2306  }
2307 
2308  return results;
2309 }

◆ checkTF1Limits()

void ZDCPulseAnalyzer::checkTF1Limits ( TF1 *  func)
private

Definition at line 2000 of file ZDCPulseAnalyzer.cxx.

2001 {
2002  for (int ipar = 0; ipar < func->GetNpar(); ipar++) {
2003  double parLimitLow, parLimitHigh;
2004 
2005  func->GetParLimits(ipar, parLimitLow, parLimitHigh);
2006 
2007  (*m_msgFunc_p)(ZDCMsg::Debug, (
2008  "ZDCPulseAnalyzer name=" + std::string(func->GetName())
2009  + " ipar=" + std::to_string(ipar)
2010  + " parLimitLow=" + std::to_string(parLimitLow)
2011  + " parLimitHigh="+ std::to_string(parLimitHigh)
2012  )
2013  );
2014 
2015  //if (std::abs(parLimitHigh / parLimitLow - 1) > 1e-6) {
2016  if (std::abs(parLimitHigh - parLimitLow) > (1e-6)*std::abs(parLimitLow)) {
2017  double value = func->GetParameter(ipar);
2018  if (value >= parLimitHigh) {
2019  value = parLimitHigh * 0.9;
2020  }
2021  else if (value <= parLimitLow) {
2022  value = parLimitLow + 0.1*std::abs(parLimitLow);
2023  }
2024  func->SetParameter(ipar, value);
2025  }
2026  }
2027 }

◆ CombinedPulsesFCN()

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

Definition at line 84 of file ZDCPulseAnalyzer.cxx.

85 {
86  // The first parameter is a correction factor to account for decrease in beam intensity between x
87  // and y scan. It is applied here and not passed to the actual fit function
88  //
89  int nSamples = s_undelayedFitHist->GetNbinsX();
90 
91  if (flag == 3) {
92  s_pullValues.assign(nSamples * 2, 0);
93  }
94 
95  double chiSquare = 0;
96 
97  float delayBaselineAdjust = par[0];
98 
99  // undelayed
100  //
101  for (int isample = 0; isample < nSamples; isample++) {
102  double histValue = s_undelayedFitHist->GetBinContent(isample + 1);
103  double histError = std::max(s_undelayedFitHist->GetBinError(isample + 1), 1.0);
104  double t = s_undelayedFitHist->GetBinCenter(isample + 1);
105 
106  if (t > s_combinedFitTMax) break;
107  if (t < s_combinedFitTMin) continue;
108 
109  double funcVal = s_combinedFitFunc->EvalPar(&t, &par[1]);
110 
111  double pull = (histValue - funcVal) / histError;
112 
113  if (flag == 3) s_pullValues[2 * isample] = pull;
114  chiSquare += pull * pull;
115  }
116 
117  // delayed
118  //
119  for (int isample = 0; isample < nSamples; isample++) {
120  double histValue = s_delayedFitHist->GetBinContent(isample + 1);
121  double histError = std::max(s_delayedFitHist->GetBinError(isample + 1), 1.0);
122  double t = s_delayedFitHist->GetBinCenter(isample + 1);
123 
124  if (t > s_combinedFitTMax) break;
125  if (t < s_combinedFitTMin) continue;
126 
127  double funcVal = s_combinedFitFunc->EvalPar(&t, &par[1]) + delayBaselineAdjust;
128  double pull = (histValue - funcVal) / histError;
129 
130  if (flag == 3) s_pullValues[2 * isample + 1] = pull;
131  chiSquare += pull * pull;
132  }
133 
134  f = chiSquare;
135 }

◆ ConfigFromJSON()

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

Definition at line 2459 of file ZDCPulseAnalyzer.cxx.

2460 {
2461  bool result = true;
2462  std::string resultString = "success";
2463 
2464  for (auto [key, value] : config.items()) {
2465  //
2466  // Big if statement to process configuration parameters
2467  //
2468  if (key == "Nsample") m_Nsample = value;
2469  else if (key == "tag") m_tag = value;
2470  else if (key == "LGMode") m_LGMode = value;
2471  else if (key == "Nsample") m_Nsample = value;
2472  else if (key == "useDelayed") m_useDelayed = value;
2473  else if (key == "preSampleIdx") m_preSampleIdx = value;
2474  else if (key == "FADCFreqMHz") m_freqMHz = value;
2475  else if (key == "nominalPedestal") m_pedestal = value;
2476  else if (key == "fitFunction") m_fitFunction = value;
2477  else if (key == "peakSample") m_peak2ndDerivMinSample = value;
2478  else if (key == "peakTolerance") m_peak2ndDerivMinTolerance = value;
2479  else if (key == "2ndDerivThreshHG") m_peak2ndDerivMinThreshHG = value;
2480  else if (key == "2ndDerivThreshLG") m_peak2ndDerivMinThreshLG = value;
2481  else if (key == "2ndDerivStep") m_2ndDerivStep = value;
2482  else if (key == "HGOverflowADC") m_HGOverflowADC = value;
2483  else if (key == "HGUnderflowADC") m_HGUnderflowADC = value;
2484  else if (key == "LGOverflowADC") m_LGOverflowADC = value;
2485  else if (key == "nominalT0HG") m_nominalT0HG = value;
2486  else if (key == "nominalT0LG") m_nominalT0LG = value;
2487  else if (key == "nominalTau1") m_nominalTau1 = value;
2488  else if (key == "nominalTau2") m_nominalTau2 = value;
2489  else if (key == "fixTau1") m_fixTau1 = value;
2490  else if (key == "fixTau2") m_fixTau2 = value;
2491  else if (key == "T0CutsHG") {
2492  m_T0CutLowHG = value[0];
2493  m_T0CutHighHG = value[1];
2494  }
2495  else if (key == "T0CutsLG") {
2496  m_T0CutLowLG = value[0];
2497  m_T0CutHighLG = value[1];
2498  }
2499  else if (key == "chisqDivAmpCutHG") m_chisqDivAmpCutHG = value;
2500  else if (key == "chisqDivAmpCutLG") m_chisqDivAmpCutLG = value;
2501  else if (key == "gainFactorHG") m_gainFactorHG = value;
2502  else if (key == "gainFactorLG") m_gainFactorLG = value;
2503  else if (key == "noiseSigmaHG") m_noiseSigHG = value;
2504  else if (key == "noiseSigmaLG") m_noiseSigLG = value;
2505  else if (key == "enableRepass") m_enableRepass = value;
2506  else if (key == "Repass2ndDerivThreshHG") m_peak2ndDerivMinRepassHG = value;
2507  else if (key == "Repass2ndDerivThreshLG") m_peak2ndDerivMinRepassLG = value;
2508  else if (key == "fitAmpMinMaxHG") {
2509  m_fitAmpMinHG = value[0];
2510  m_fitAmpMaxHG = value[1];
2511  }
2512  else if (key == "fitAmpMinMaxLG") {
2513  m_fitAmpMinLG = value[0];
2514  m_fitAmpMaxLG = value[1];
2515  }
2516  else if (key == "quietFits") {
2517  m_quietFits = value[0];
2518  }
2519  else if (key == "enablePreExclusion") {
2520  m_enablePreExcl = true;
2521  m_maxSamplesPreExcl = value[0];
2522  m_preExclHGADCThresh = value[1];
2523  m_preExclLGADCThresh = value[2];
2524  }
2525  else if (key == "enablePostExclusion") {
2526  m_enablePostExcl = true;
2527  m_maxSamplesPostExcl = value[0];
2528  m_postExclHGADCThresh = value[1];
2529  m_postExclLGADCThresh = value[2];
2530  }
2531  else if (key == "ampMinSignifHGLG") {
2532  m_haveSignifCuts = true;
2533  m_sigMinHG = value[0];
2534  m_sigMinLG = value[1];
2535  }
2536  else if (key == "enableFADCCorrections") {
2537  auto fileNameJson = value["filename"];
2538  auto doPerSampleCorrJson = value["doPerSampleCorr"];
2539 
2540  if (fileNameJson.is_null() || doPerSampleCorrJson.is_null()) {
2541  result = false;
2542  std::string resultString = "failure processing enableFADCCorrections object";
2543  break;
2544  }
2545 
2546  m_haveFADCCorrections = true;
2547  m_FADCCorrPerSample = doPerSampleCorrJson;
2548  m_fadcCorrFileName = fileNameJson;
2549  }
2550  else {
2551  result = false;
2552  std::string resultString = "unprocessed parameter";
2553  break;
2554  }
2555  }
2556 
2557  return {result, resultString};
2558 }

◆ disableFADCCorrections()

void ZDCPulseAnalyzer::disableFADCCorrections ( )
inline

Definition at line 571 of file ZDCPulseAnalyzer.h.

571 {m_haveFADCCorrections = false;}

◆ DoAnalysis()

bool ZDCPulseAnalyzer::DoAnalysis ( bool  repass)
private

Definition at line 1017 of file ZDCPulseAnalyzer.cxx.

1018 {
1019  float deriv2ndThreshHG = 0;
1020  float deriv2ndThreshLG = 0;
1021 
1022  if (!repass) {
1023  ScanAndSubtractSamples();
1024 
1025  deriv2ndThreshHG = m_peak2ndDerivMinThreshHG;
1026  deriv2ndThreshLG = m_peak2ndDerivMinThreshLG;
1027  }
1028  else {
1029  deriv2ndThreshHG = m_peak2ndDerivMinRepassHG;
1030  deriv2ndThreshLG = m_peak2ndDerivMinRepassLG;
1031  }
1032 
1033  m_useLowGain = m_HGUnderflow || m_HGOverflow || (m_LGMode == LGModeForceLG);
1034  if (m_useLowGain) {
1035  // (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " using low gain data ");
1036 
1037  bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesLGSub, m_useSampleLG,
1038  deriv2ndThreshLG, m_noiseSigLG, m_LGT0CorrParams,
1039  m_chisqDivAmpCutLG, m_T0CutLowLG, m_T0CutHighLG);
1040  if (result) {
1041  //
1042  // +++BAC
1043  //
1044  // I have removed some code that attempted a refit in case of failure of the chi-square cut
1045  // Instead, we should implement an analysis of the failure with possible re-fit afterwards
1046  // with possible change of the pre- or post-pulse condition
1047  //
1048  // --BAC
1049  //
1050 
1051  double amplCorrFactor = getAmplitudeCorrection(false);
1052 
1053  //
1054  // Multiply amplitude by gain factor
1055  //
1056  m_ampNoNonLin = m_fitAmplitude * m_gainFactorLG;
1057  m_amplitude = m_fitAmplitude * amplCorrFactor * m_gainFactorLG;
1058  m_ampError = m_fitAmpError * amplCorrFactor * m_gainFactorLG;
1059  m_preSampleAmp = m_preSample * m_gainFactorLG;
1060  m_preAmplitude = m_fitPreAmp * m_gainFactorLG;
1061  m_postAmplitude = m_fitPostAmp * m_gainFactorLG;
1062  m_expAmplitude = m_fitExpAmp * m_gainFactorLG;
1063 
1064  // BAC: also scale up the 2nd derivative by the gain factor so low and high gain can be treated on the same footing
1065  //
1066  m_minDeriv2nd *= m_gainFactorLG;
1067  }
1068 
1069  return result;
1070  }
1071  else {
1072  // (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + " using high gain data ");
1073 
1074  bool result = AnalyzeData(m_NSamplesAna, m_preSampleIdx, m_ADCSamplesHGSub, m_useSampleHG,
1075  deriv2ndThreshHG, m_noiseSigHG, m_HGT0CorrParams,
1076  m_chisqDivAmpCutHG, m_T0CutLowHG, m_T0CutHighHG);
1077  if (result) {
1078  // +++BAC
1079  //
1080  // I have removed some code that attempted a refit in case of failure of the chi-square cut
1081  // Instead, we should implement an analysis of the failure with possible re-fit afterwards
1082  // with possible change of the pre- or post-pulse condition
1083  //
1084  // --BAC
1085 
1086  m_preSampleAmp = m_preSample * m_gainFactorHG;
1087  m_amplitude = m_fitAmplitude * m_gainFactorHG;
1088  m_ampNoNonLin = m_amplitude;
1089  m_ampError = m_fitAmpError * m_gainFactorHG;
1090  m_preAmplitude = m_fitPreAmp * m_gainFactorHG;
1091  m_postAmplitude = m_fitPostAmp* m_gainFactorHG;
1092  m_expAmplitude = m_fitExpAmp * m_gainFactorHG;
1093 
1094  m_minDeriv2nd *= m_gainFactorHG;
1095 
1096  // If we have a non-linear correction, apply it here
1097  //
1098  // We apply it as an inverse correction - i.e. we divide by a correction
1099  // term tha is a sum of coefficients times the ADC minus a reference
1100  // to a power. The lowest power is 1, the highest is deteremined by
1101  // the number of provided coefficients
1102  //
1103  double amplCorrFactor = getAmplitudeCorrection(true);
1104 
1105  m_amplitude *= amplCorrFactor;
1106  m_ampError *= amplCorrFactor;
1107  }
1108 
1109  // If LG refit has been requested, do it now
1110  //
1111  if (m_LGMode == LGModeRefitLG && m_havePulse) {
1112  prepareLGRefit(m_ADCSamplesLGSub, m_ADCSSampSigLG, m_useSampleLG);
1113  DoFit(true);
1114 
1115  double amplCorrFactor = getAmplitudeCorrection(false);
1116  m_refitLGAmplCorr = m_refitLGAmpl*amplCorrFactor;
1117  }
1118 
1119  return result;
1120  }
1121 }

◆ DoFit()

void ZDCPulseAnalyzer::DoFit ( bool  refitLG = false)
private

Definition at line 1552 of file ZDCPulseAnalyzer.cxx.

1553 {
1554  bool fitLG = m_useLowGain || refitLG;
1555 
1556  TH1* hist_p = nullptr;
1557  FillHistogram(refitLG);
1558 
1559  // Set the initial values
1560  //
1561  float ampInitial, fitAmpMin, fitAmpMax, t0Initial;
1562 
1563  if (fitLG) {
1564  fitAmpMin = m_fitAmpMinLG;
1565  fitAmpMax = m_fitAmpMaxLG;
1566  t0Initial = m_nominalT0LG;
1567  ampInitial = m_ADCPeakLG;
1568  }
1569  else {
1570  ampInitial = m_ADCPeakHG;
1571  fitAmpMin = m_fitAmpMinHG;
1572  fitAmpMax = m_fitAmpMaxHG;
1573  t0Initial = m_nominalT0HG;
1574  }
1575 
1576  if (refitLG) {
1577  hist_p = m_fitHistLGRefit.get();
1578  }
1579  else {
1580  hist_p = m_fitHist.get();
1581  }
1582  if (ampInitial < fitAmpMin) ampInitial = fitAmpMin * 1.5;
1583 
1584 
1585  ZDCFitWrapper* fitWrapper = m_defaultFitWrapper.get();
1586  if (preExpTail()) {
1587  fitWrapper = m_preExpFitWrapper.get();
1588  (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->SetInitialExpPulse(m_initialExpAmp);
1589  }
1590  else if (prePulse()) {
1591  fitWrapper = m_prePulseFitWrapper.get();
1592  (static_cast<ZDCPrePulseFitWrapper*>(fitWrapper))->SetInitialPrePulse(m_initialPrePulseAmp, m_initialPrePulseT0,0,25);
1593  }
1594 
1595  if (m_adjTimeRangeEvent) {
1596  m_fitTMin = std::max(m_fitTMin, m_deltaTSample * m_minSampleEvt - m_deltaTSample / 2);
1597  m_fitTMax = std::min(m_fitTMax, m_deltaTSample * m_maxSampleEvt + m_deltaTSample / 2);
1598 
1599  float fitTReference = m_deltaTSample * m_usedPresampIdx;
1600 
1601  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
1602  }
1603  else {
1604  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
1605  }
1606 
1607  // Now perform the fit
1608  //
1609  std::string options = m_fitOptions + "Ns";
1610  if (m_quietFits) {
1611  options += "Q";
1612  }
1613 
1614  bool fitFailed = false;
1615 
1616  // dumpTF1(fitWrapper->GetWrapperTF1RawPtr());
1617  checkTF1Limits(fitWrapper->GetWrapperTF1RawPtr());
1618 
1619  //
1620  // Fit the data with the function provided by the fit wrapper
1621  //
1622  TFitResultPtr result_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
1623  int fitStatus = result_ptr;
1624 
1625  //
1626  // If the first fit failed, also check the EDM. If sufficiently small, the failure is almost surely due
1627  // to parameter limits and we just accept the result
1628  //
1629  if (fitStatus != 0 && result_ptr->Edm() > 0.001)
1630  {
1631  //
1632  // We contstrain the fit and try again
1633  //
1634  fitWrapper->ConstrainFit();
1635 
1636  TFitResultPtr constrFitResult_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
1637  fitWrapper->UnconstrainFit();
1638 
1639  if ((int) constrFitResult_ptr != 0) {
1640  //
1641  // Even the constrained fit failed, so we quit.
1642  //
1643  fitFailed = true;
1644  }
1645  else {
1646  // Now we try the fit again with the constraint removed
1647  //
1648  TFitResultPtr unconstrFitResult_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
1649  if ((int) unconstrFitResult_ptr != 0) {
1650  //
1651  // The unconstrained fit failed again, so we redo the constrained fit
1652  //
1653  fitWrapper->ConstrainFit();
1654 
1655  TFitResultPtr constrFit2Result_ptr = hist_p->Fit(fitWrapper->GetWrapperTF1RawPtr(), options.c_str(), "", m_fitTMin, m_fitTMax);
1656  if ((int) constrFit2Result_ptr != 0) {
1657  //
1658  // Even the constrained fit failed the second time, so we quit.
1659  //
1660  fitFailed = true;
1661  }
1662 
1663  result_ptr = constrFit2Result_ptr;
1664  fitWrapper->UnconstrainFit();
1665  }
1666  else {
1667  result_ptr = unconstrFitResult_ptr;
1668  }
1669  }
1670  }
1671 
1672  if (!m_fitFailed && m_saveFitFunc) {
1673  hist_p->GetListOfFunctions()->Clear();
1674 
1675  TF1* func = fitWrapper->GetWrapperTF1RawPtr();
1676  std::string name = func->GetName();
1677 
1678  TF1* copyFunc = static_cast<TF1*>(func->Clone((name + "_copy").c_str()));
1679  hist_p->GetListOfFunctions()->Add(copyFunc);
1680  }
1681 
1682  if (!refitLG) {
1683  m_fitFailed = fitFailed;
1684  m_bkgdMaxFraction = fitWrapper->GetBkgdMaxFraction();
1685  m_fitAmplitude = fitWrapper->GetAmplitude();
1686  m_fitAmpError = fitWrapper->GetAmpError();
1687 
1688  if (preExpTail()) {
1689  m_fitExpAmp = (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->GetExpAmp();
1690  }
1691  else {
1692  m_fitExpAmp = 0;
1693  }
1694 
1695  m_fitTime = fitWrapper->GetTime();
1696  m_fitTimeSub = m_fitTime - t0Initial;
1697 
1698  m_fitChisq = result_ptr->Chi2();
1699  m_fitNDoF = result_ptr->Ndf();
1700 
1701  m_fitTau1 = fitWrapper->GetTau1();
1702  m_fitTau2 = fitWrapper->GetTau2();
1703 
1704  // Here we need to check if the fit amplitude is small (close) enough to fitAmpMin.
1705  // with "< 1+epsilon" where epsilon ~ 1%
1706  if (m_fitAmplitude < fitAmpMin * 1.01) {
1707  m_fitMinAmp = true;
1708  }
1709 
1710  float sigMinCut = fitLG ? m_sigMinLG : m_sigMinHG;
1711  if (m_fitAmpError > 1e-6) {
1712  if (m_fitAmplitude/m_fitAmpError < sigMinCut) m_failSigCut = true;
1713  }
1714  }
1715  else {
1716  m_evtLGRefit = true;
1717  m_refitLGFitAmpl = fitWrapper->GetAmplitude();
1718  m_refitLGAmpl = fitWrapper->GetAmplitude() * m_gainFactorLG;
1719  m_refitLGAmpError = fitWrapper->GetAmpError() * m_gainFactorLG;
1720  m_refitLGChisq = result_ptr->Chi2();
1721  m_refitLGTime = fitWrapper->GetTime();
1722  m_refitLGTimeSub = m_refitLGTime - t0Initial;
1723  }
1724 }

◆ DoFitCombined()

void ZDCPulseAnalyzer::DoFitCombined ( bool  refitLG = false)
private

Definition at line 1726 of file ZDCPulseAnalyzer.cxx.

1727 {
1728  bool fitLG = refitLG || m_useLowGain;
1729  TH1* hist_p = nullptr, *delayedHist_p = nullptr;
1730 
1731  FillHistogram(refitLG);
1732  if (refitLG) {
1733  hist_p = m_fitHistLGRefit.get();
1734  delayedHist_p = m_delayedHistLGRefit.get();
1735  }
1736  else {
1737  hist_p = m_fitHist.get();
1738  delayedHist_p = m_delayedHist.get();
1739  }
1740 
1741  float fitAmpMin, fitAmpMax, t0Initial, ampInitial;
1742  if (fitLG) {
1743  ampInitial = m_ADCPeakLG;
1744  fitAmpMin = m_fitAmpMinLG;
1745  fitAmpMax = m_fitAmpMaxLG;
1746  t0Initial = m_nominalT0LG;
1747  }
1748  else {
1749  ampInitial = m_ADCPeakHG;
1750  fitAmpMin = m_fitAmpMinHG;
1751  fitAmpMax = m_fitAmpMaxHG;
1752  t0Initial = m_nominalT0HG;
1753  }
1754 
1755  // Set the initial values
1756  //
1757  if (ampInitial < fitAmpMin) ampInitial = fitAmpMin * 1.5;
1758 
1759  ZDCFitWrapper* fitWrapper = m_defaultFitWrapper.get();
1760  //if (prePulse()) fitWrapper = fitWrapper = m_preExpFitWrapper.get();
1761 
1762  if (preExpTail()) {
1763  fitWrapper = m_preExpFitWrapper.get();
1764  (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->SetInitialExpPulse(m_initialExpAmp);
1765  }
1766  else if (prePulse()) {
1767  fitWrapper = m_prePulseFitWrapper.get();
1768  (static_cast<ZDCPrePulseFitWrapper*>(fitWrapper))->SetInitialPrePulse(m_initialPrePulseAmp, m_initialPrePulseT0,0,25);
1769  }
1770 
1771  // Initialize the fit wrapper for this event, specifying a
1772  // per-event fit range if necessary
1773  //
1774  if (m_adjTimeRangeEvent) {
1775  m_fitTMin = std::max(m_fitTMin, m_deltaTSample * m_minSampleEvt - m_deltaTSample / 2);
1776  m_fitTMax = std::min(m_fitTMax, m_deltaTSample * m_maxSampleEvt + m_deltaTSample / 2);
1777 
1778  float fitTReference = m_deltaTSample * m_usedPresampIdx;
1779 
1780  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
1781  }
1782  else {
1783  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
1784  }
1785 
1786  // Set up the virtual fitter
1787  //
1788  TFitter* theFitter = nullptr;
1789 
1790  if (prePulse()) {
1791  m_prePulseCombinedFitter = MakeCombinedFitter(fitWrapper->GetWrapperTF1RawPtr());
1792 
1793  theFitter = m_prePulseCombinedFitter.get();
1794  }
1795  else {
1796  m_defaultCombinedFitter = MakeCombinedFitter(fitWrapper->GetWrapperTF1RawPtr());
1797 
1798  theFitter = m_defaultCombinedFitter.get();
1799  }
1800 
1801  // dumpTF1(fitWrapper->GetWrapperTF1RawPtr());
1802 
1803  // Set the static pointers to histograms and function for use in FCN
1804  //
1805  s_undelayedFitHist = hist_p;
1806  s_delayedFitHist = delayedHist_p;
1807  s_combinedFitFunc = fitWrapper->GetWrapperTF1RawPtr();
1808  s_combinedFitTMax = m_fitTMax;
1809  s_combinedFitTMin = m_fitTMin;
1810 
1811 
1812  size_t numFitPar = theFitter->GetNumberTotalParameters();
1813 
1814  theFitter->GetMinuit()->fISW[4] = -1;
1815 
1816  // Now perform the fit
1817  //
1818  if (m_quietFits) {
1819  theFitter->GetMinuit()->fISW[4] = -1;
1820 
1821  int ierr= 0;
1822  theFitter->GetMinuit()->mnexcm("SET NOWarnings",nullptr,0,ierr);
1823  }
1824  else theFitter->GetMinuit()->fISW[4] = 0;
1825 
1826  // Only include baseline shift in fit for pre-pulses. Otherwise baseline matching should work
1827  //
1828  if (prePulse()) {
1829  theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
1830  theFitter->ReleaseParameter(0);
1831  }
1832  else {
1833  theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
1834  theFitter->FixParameter(0);
1835  }
1836 
1837 
1838  double arglist[100];
1839  arglist[0] = 5000; // number of function calls
1840  arglist[1] = 0.01; // tolerance
1841  int status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
1842 
1843  double fitAmp = theFitter->GetParameter(1);
1844 
1845  // Capture the chi-square etc.
1846  //
1847  double chi2, edm, errdef;
1848  int nvpar, nparx;
1849 
1850  theFitter->GetStats(chi2, edm, errdef, nvpar, nparx);
1851 
1852  // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
1853  // with "< 1+epsilon" where epsilon ~ 1%
1854  //
1855  if (status || fitAmp < fitAmpMin * 1.01 || edm > 0.01){
1856 
1857  //
1858  // We first retry the fit with no baseline adjust
1859  //
1860  theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
1861  theFitter->FixParameter(0);
1862 
1863  // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
1864  // with "< 1+epsilon" where epsilon ~ 1%
1865  if (fitAmp < fitAmpMin * 1.01) {
1866  if (m_adjTimeRangeEvent) {
1867  float fitTReference = m_deltaTSample * m_usedPresampIdx;
1868  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax, m_fitTMin, m_fitTMax, fitTReference);
1869  }
1870  else {
1871  fitWrapper->Initialize(ampInitial, t0Initial, fitAmpMin, fitAmpMax);
1872  }
1873  }
1874 
1875  status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
1876  if (status != 0) {
1877  //
1878  // Fit failed event with no baseline adust, so be it
1879  //
1880  theFitter->ReleaseParameter(0);
1881  m_fitFailed = true;
1882  }
1883  else {
1884  //
1885  // The fit succeeded with no baseline adjust, re-fit allowing for baseline adjust using
1886  // the parameters from previous fit as the starting point
1887  //
1888  theFitter->ReleaseParameter(0);
1889  status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
1890 
1891  if (status) {
1892  // Since we know the fit can succeed without the baseline adjust, go back to it
1893  //
1894  theFitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
1895  theFitter->FixParameter(0);
1896  status = theFitter->ExecuteCommand("MIGRAD", arglist, 2);
1897  }
1898  }
1899  }
1900  else m_fitFailed = false;
1901 
1902  // Check to see if the fit forced the amplitude to the minimum, if so set the corresponding status bit
1903  //
1904  fitAmp = theFitter->GetParameter(1);
1905 
1906  // Here we need to check if fitAmp is small (close) enough to fitAmpMin.
1907  // with "< 1+epsilon" where epsilon ~ 1%
1908  if (fitAmp < fitAmpMin * 1.01) {
1909  m_fitMinAmp = true;
1910  }
1911 
1912  // Check that the amplitude passes minimum significance requirement
1913  //
1914  float sigMinCut = fitLG ? m_sigMinLG : m_sigMinHG;
1915  if (m_fitAmpError > 1e-6) {
1916  if (m_fitAmplitude/m_fitAmpError < sigMinCut) m_failSigCut = true;
1917  }
1918 
1919  if (!m_quietFits) theFitter->GetMinuit()->fISW[4] = -1;
1920 
1921  std::vector<double> funcParams(numFitPar - 1);
1922  std::vector<double> funcParamErrs(numFitPar - 1);
1923 
1924  // Save the baseline shift between delayed and undelayed samples
1925  //
1926  m_delayedBaselineShift = theFitter->GetParameter(0);
1927 
1928  // Capture and store the fit function parameteds and errors
1929  //
1930  for (size_t ipar = 1; ipar < numFitPar; ipar++) {
1931  funcParams[ipar - 1] = theFitter->GetParameter(ipar);
1932  funcParamErrs[ipar - 1] = theFitter->GetParError(ipar);
1933  }
1934 
1935  s_combinedFitFunc->SetParameters(&funcParams[0]);
1936  s_combinedFitFunc->SetParErrors(&funcParamErrs[0]);
1937 
1938  // Capture the chi-square etc.
1939  //
1940  theFitter->GetStats(chi2, edm, errdef, nvpar, nparx);
1941 
1942  int ndf = 2 * m_Nsample - nvpar;
1943 
1944  s_combinedFitFunc->SetChisquare(chi2);
1945  s_combinedFitFunc->SetNDF(ndf);
1946 
1947  // add to list of functions
1948  if (m_saveFitFunc) {
1949  s_undelayedFitHist->GetListOfFunctions()->Clear();
1950  s_undelayedFitHist->GetListOfFunctions()->Add(s_combinedFitFunc);
1951 
1952  s_delayedFitHist->GetListOfFunctions()->Clear();
1953  s_delayedFitHist->GetListOfFunctions()->Add(s_combinedFitFunc);
1954  }
1955 
1956  if (!refitLG) {
1957  // Save the pull values from the last call to FCN
1958  //
1959  arglist[0] = 3; // number of function calls
1960  theFitter->ExecuteCommand("Cal1fcn", arglist, 1);
1961  m_fitPulls = s_pullValues;
1962 
1963  m_fitAmplitude = fitWrapper->GetAmplitude();
1964  m_fitTime = fitWrapper->GetTime();
1965  if (prePulse()) {
1966  m_fitPreT0 = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPreT0();
1967  m_fitPreAmp = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPreAmp();
1968  m_fitPostT0 = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPostT0();
1969  m_fitPostAmp = (static_cast<ZDCPrePulseFitWrapper*>(m_prePulseFitWrapper.get()))->GetPostAmp();
1970  }
1971 
1972  if (preExpTail()) {
1973  m_fitExpAmp = (static_cast<ZDCPreExpFitWrapper*>(m_preExpFitWrapper.get()))->GetExpAmp();
1974  }
1975  else {
1976  m_fitExpAmp = 0;
1977  }
1978 
1979  m_fitTimeSub = m_fitTime - t0Initial;
1980  m_fitChisq = chi2;
1981  m_fitNDoF = ndf;
1982 
1983  m_fitTau1 = fitWrapper->GetTau1();
1984  m_fitTau2 = fitWrapper->GetTau2();
1985 
1986  m_fitAmpError = fitWrapper->GetAmpError();
1987  m_bkgdMaxFraction = fitWrapper->GetBkgdMaxFraction();
1988  }
1989  else {
1990  m_evtLGRefit = true;
1991  m_refitLGFitAmpl = fitWrapper->GetAmplitude();
1992  m_refitLGAmpl = fitWrapper->GetAmplitude() * m_gainFactorLG;
1993  m_refitLGAmpError = fitWrapper->GetAmpError() * m_gainFactorLG;
1994  m_refitLGChisq = chi2;
1995  m_refitLGTime = fitWrapper->GetTime();
1996  m_refitLGTimeSub = m_refitLGTime - t0Initial;
1997  }
1998 }

◆ dump()

void ZDCPulseAnalyzer::dump ( ) const

Definition at line 2084 of file ZDCPulseAnalyzer.cxx.

2085 {
2086  (*m_msgFunc_p)(ZDCMsg::Info, ("ZDCPulseAnalyzer dump for tag = " + m_tag));
2087 
2088  (*m_msgFunc_p)(ZDCMsg::Info, ("Presample index, value = " + std::to_string(m_preSampleIdx) + ", " + std::to_string(m_preSample)));
2089 
2090  if (m_useDelayed) {
2091  (*m_msgFunc_p)(ZDCMsg::Info, ("using delayed samples with delta T = " + std::to_string(m_delayedDeltaT) + ", and pedestalDiff == " +
2092  std::to_string(m_delayedPedestalDiff)));
2093  }
2094 
2095  std::ostringstream message1;
2096  message1 << "samplesSub ";
2097  for (size_t sample = 0; sample < m_samplesSub.size(); sample++) {
2098  message1 << ", [" << sample << "] = " << m_samplesSub[sample];
2099  }
2100  (*m_msgFunc_p)(ZDCMsg::Info, message1.str());
2101 
2102  std::ostringstream message3;
2103  message3 << "samplesDeriv2nd ";
2104  for (size_t sample = 0; sample < m_samplesDeriv2nd.size(); sample++) {
2105  message3 << ", [" << sample << "] = " << m_samplesDeriv2nd[sample];
2106  }
2107  (*m_msgFunc_p)(ZDCMsg::Info, message3.str());
2108 
2109  (*m_msgFunc_p)(ZDCMsg::Info, ("minimum 2nd deriv sample, value = " + std::to_string(m_minDeriv2ndIndex) + ", " + std::to_string(m_minDeriv2nd)));
2110 }

◆ dumpConfiguration()

void ZDCPulseAnalyzer::dumpConfiguration ( ) const

Definition at line 2131 of file ZDCPulseAnalyzer.cxx.

2132 {
2133  std::ostringstream ostrStream;
2134 
2135  (*m_msgFunc_p)(ZDCMsg::Info, ("ZDCPulserAnalyzer:: settings for instance: " + m_tag));
2136 
2137  ostrStream << "Nsample = " << m_Nsample << " at frequency " << m_freqMHz << " MHz, preSample index = "
2138  << m_preSampleIdx << ", nominal pedestal = " << m_pedestal;
2139 
2140  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2141 
2142  ostrStream << "LG mode = " << m_LGMode << ", gainFactor HG = " << m_gainFactorHG << ", gainFactor LG = " << m_gainFactorLG << ", noise sigma HG = " << m_noiseSigHG << ", noiseSigLG = " << m_noiseSigLG;
2143  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2144 
2145  ostrStream << "peak sample = " << m_peak2ndDerivMinSample << ", tolerance = " << m_peak2ndDerivMinTolerance
2146  << ", 2ndDerivThresh HG, LG = " << m_peak2ndDerivMinThreshHG << ", " << m_peak2ndDerivMinThreshLG
2147  << ", 2nd deriv step = " << m_2ndDerivStep;
2148  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2149 
2150  if (m_useDelayed) {
2151  ostrStream << "using delayed samples with delta T = " << m_delayedDeltaT << ", and default pedestalDiff == "
2152  << m_delayedPedestalDiff;
2153  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2154  }
2155 
2156  ostrStream << "m_fixTau1 = " << m_fixTau1 << ", m_fixTau2 = " << m_fixTau2 << ", m_nominalTau1 = " << m_nominalTau1
2157  << ", m_nominalTau2 = " << m_nominalTau2 << ", m_nominalT0HG = " << m_nominalT0HG
2158  << ", m_nominalT0LG = " << m_nominalT0LG;
2159  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2160 
2161  ostrStream << "m_HGOverflowADC = " << m_HGOverflowADC << ", m_HGUnderflowADC = " << m_HGUnderflowADC
2162  << ", m_LGOverflowADC = "<< m_LGOverflowADC;
2163  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2164 
2165  ostrStream << "m_chisqDivAmpCutLG = " << m_chisqDivAmpCutLG << ", m_chisqDivAmpCutHG=" << m_chisqDivAmpCutHG
2166  << ", t0Cuts HG = [" << m_T0CutLowHG << ", " << m_T0CutHighHG << "], t0Cuts LG = ["
2167  << m_T0CutLowLG << ", " << m_T0CutHighLG << "]";
2168  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2169 
2170  if ( m_enableRepass) {
2171  ostrStream << "Repass enabled with peak2ndDerivMinRepassHG = " << m_peak2ndDerivMinRepassHG << ", peak2ndDerivMinRepassLG = " << m_peak2ndDerivMinRepassLG;
2172  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2173  }
2174 
2175  if (m_enablePreExcl) {
2176  ostrStream << "Pre-exclusion enabled for up to " << m_maxSamplesPreExcl << ", samples with ADC threshold HG = "
2177  << m_preExclHGADCThresh << ", LG = " << m_preExclLGADCThresh;
2178  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2179  }
2180  if (m_enablePostExcl) {
2181  ostrStream << "Post-exclusion enabled for up to " << m_maxSamplesPostExcl << ", samples with ADC threshold HG = "
2182  << m_postExclHGADCThresh << ", LG = " << m_postExclLGADCThresh;
2183  (*m_msgFunc_p)(ZDCMsg::Info, ostrStream.str()); ostrStream.str(""); ostrStream.clear();
2184  }
2185 
2186 }

◆ dumpTF1()

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

Definition at line 2112 of file ZDCPulseAnalyzer.cxx.

2113 {
2114  std::string message = "Dump of TF1: " + std::string(func->GetName());
2115  bool continueDump = (*m_msgFunc_p)(ZDCMsg::Verbose, std::move(message));
2116  if (!continueDump) return;
2117 
2118  unsigned int npar = func->GetNpar();
2119  for (unsigned int ipar = 0; ipar < npar; ipar++) {
2120  std::ostringstream msgstr;
2121 
2122  double parMin = 0, parMax = 0;
2123  func->GetParLimits(ipar, parMin, parMax);
2124 
2125  msgstr << "Parameter " << ipar << ", value = " << func->GetParameter(ipar) << ", error = "
2126  << func->GetParError(ipar) << ", min = " << parMin << ", max = " << parMax;
2127  (*m_msgFunc_p)(ZDCMsg::Verbose, msgstr.str());
2128  }
2129 }

◆ enableDelayed()

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

Definition at line 204 of file ZDCPulseAnalyzer.cxx.

205 {
206  m_useDelayed = true;
207  m_useFixedBaseline = fixedBaseline;
208 
209  m_delayedDeltaT = deltaT;
210  m_delayedPedestalDiff = pedestalShift;
211 
212  m_deltaTSample /= 2.;
213 
214  std::string delayedHGName = std::string(m_fitHist->GetName()) + "delayed";
215  std::string delayedLGName = std::string(m_fitHistLGRefit->GetName()) + "delayed";
216 
217  m_delayedHist = std::make_unique<TH1F>(delayedHGName.c_str(), "", m_Nsample, m_tmin + m_delayedDeltaT, m_tmax + m_delayedDeltaT);
218  m_delayedHist->SetDirectory(0);
219 
220  m_delayedHistLGRefit = std::make_unique<TH1F>(delayedLGName.c_str(), "", m_Nsample, m_tmin + m_delayedDeltaT, m_tmax + m_delayedDeltaT);
221  m_delayedHistLGRefit->SetDirectory(0);
222 
223  m_ADCSamplesHGSub.assign(2 * m_Nsample, 0);
224  m_ADCSamplesLGSub.assign(2 * m_Nsample, 0);
225 }

◆ enableFADCCorrections()

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

Definition at line 540 of file ZDCPulseAnalyzer.cxx.

541 {
542  m_haveFADCCorrections = true;
543  m_FADCCorrPerSample = correctPerSample;
544 
545  // check for appropriate limits
546  //
547  auto getXmin=[](const TH1 * pH){
548  return pH->GetXaxis()->GetXmin();
549  };
550  auto getXmax=[](const TH1 * pH){
551  return pH->GetXaxis()->GetXmax();
552  };
553  auto xmin= getXmin(correHistHG.get());
554  auto xmax= getXmax(correHistHG.get());
555  if (std::abs(xmin+0.5) > 1e-3 || std::abs(xmax - 4095.5) > 1e-3) {
556  (*m_msgFunc_p)(ZDCMsg::Error, "ZDCPulseAnalyzer::enableFADCCorrections:: invalid high gain correction histogram range: xmin, xmax = " +
557  std::to_string(xmin ) + ", " + std::to_string(xmax) );
558  }
559  else {
560  m_FADCCorrHG = std::move(correHistHG);
561  }
562  xmin= getXmin(correHistLG.get());
563  xmax= getXmax(correHistLG.get());
564  if (std::abs(xmin+0.5) > 1e-3 ||
565  std::abs(xmax - 4095.5) > 1e-3) {
566  (*m_msgFunc_p)(ZDCMsg::Error, "ZDCPulseAnalyzer::enableFADCCorrections:: invalid low gain correction histogram range: xmin, xmax = " +
567  std::to_string(xmin) + ", " + std::to_string(xmax) );
568  }
569  else {
570  m_FADCCorrLG = std::move(correHistLG);
571  }
572 }

◆ enablePostExclusion()

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

Definition at line 494 of file ZDCPulseAnalyzer.h.

495  {
496  m_enablePostExcl = true;
497  m_maxSamplesPostExcl = maxSamplesExcl;
498  m_postExclHGADCThresh = HGADCThresh;
499  m_postExclLGADCThresh = LGADCThresh;
500  }

◆ enablePreExclusion()

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

Definition at line 486 of file ZDCPulseAnalyzer.h.

487  {
488  m_enablePreExcl = true;
489  m_maxSamplesPreExcl = maxSamplesExcl;
490  m_preExclHGADCThresh = HGADCThresh;
491  m_preExclLGADCThresh = LGADCThresh;
492  }

◆ enableRepass()

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

Definition at line 227 of file ZDCPulseAnalyzer.cxx.

228 {
229  m_enableRepass = true;
230  m_peak2ndDerivMinRepassHG = peak2ndDerivMinRepassHG;
231  m_peak2ndDerivMinRepassLG = peak2ndDerivMinRepassLG;
232 }

◆ 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 511 of file ZDCPulseAnalyzer.cxx.

514 {
515  m_timeCutMode = AND ? 2 : 1;
516  m_t0CutSig = sigCut;
517 
518  // Make the TF1's that provide the resolution
519  //
520  std::string timeResHGName = "TimeResFuncHG_" + m_tag;
521  std::string timeResLGName = "TimeResFuncLG_" + m_tag;
522 
523  TF1* funcHG_p = new TF1(timeResHGName.c_str(), TF1String.c_str(), 0, m_HGOverflowADC);
524  TF1* funcLG_p = new TF1(timeResLGName.c_str(), TF1String.c_str(), 0, m_LGOverflowADC);
525 
526  if (parsHG.size() != static_cast<unsigned int>(funcHG_p->GetNpar()) ||
527  parsLG.size() != static_cast<unsigned int>(funcLG_p->GetNpar())) {
528  //
529  // generate an error message
530  }
531 
532  funcHG_p->SetParameters(&parsHG[0]);
533  funcLG_p->SetParameters(&parsLG[0]);
534 
535  m_timeResFuncHG_p.reset(funcHG_p);
536  m_timeResFuncLG_p.reset(funcLG_p);
537 
538 }

◆ excludeEarlyLG()

bool ZDCPulseAnalyzer::excludeEarlyLG ( ) const
inline

Definition at line 601 of file ZDCPulseAnalyzer.h.

601 {return m_ExcludeEarly;}

◆ excludeLateLG()

bool ZDCPulseAnalyzer::excludeLateLG ( ) const
inline

Definition at line 602 of file ZDCPulseAnalyzer.h.

602 {return m_ExcludeLate;}

◆ failed()

bool ZDCPulseAnalyzer::failed ( ) const
inline

Definition at line 587 of file ZDCPulseAnalyzer.h.

587 {return m_fail;}

◆ failSigCut()

bool ZDCPulseAnalyzer::failSigCut ( ) const
inline

Definition at line 607 of file ZDCPulseAnalyzer.h.

607 {return m_failSigCut;}

◆ FillHistogram()

void ZDCPulseAnalyzer::FillHistogram ( bool  refitLG)
inlineprivate

Definition at line 404 of file ZDCPulseAnalyzer.h.

405  {
406  if (!m_useDelayed) {
407  if (!refitLG) {
408  // Set the data and errors in the histogram object
409  //
410  for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
411  m_fitHist->SetBinContent(isample + 1, m_samplesSub[isample]);
412  m_fitHist->SetBinError(isample + 1, m_samplesSig[isample]);
413  }
414  }
415  else {
416  for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
417  m_fitHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample]);
418  m_fitHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]);
419  }
420  }
421  }
422  else {
423  if (!refitLG) {
424  // Set the data and errors in the histogram object
425  //
426  for (size_t isample = 0; isample < m_Nsample; isample++) {
427  m_fitHist->SetBinContent(isample + 1, m_samplesSub[isample * 2]);
428  m_delayedHist->SetBinContent(isample + 1, m_samplesSub[isample * 2 + 1]);
429 
430  m_fitHist->SetBinError(isample + 1, m_samplesSig[isample]);
431  m_delayedHist->SetBinError(isample + 1, m_samplesSig[isample]);
432  }
433  }
434  else {
435  // Set the data and errors in the histogram object
436  //
437  for (size_t isample = 0; isample < m_Nsample; isample++) {
438  m_fitHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample * 2]);
439  m_delayedHistLGRefit->SetBinContent(isample + 1, m_samplesLGRefit[isample * 2 + 1]);
440 
441  m_fitHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]);
442  m_delayedHistLGRefit->SetBinError(isample + 1, m_samplesSigLGRefit[isample]);
443  }
444  }
445  }
446  }

◆ fitFailed()

bool ZDCPulseAnalyzer::fitFailed ( ) const
inline

Definition at line 597 of file ZDCPulseAnalyzer.h.

597 {return m_fitFailed;}

◆ fitMinimumAmplitude()

bool ZDCPulseAnalyzer::fitMinimumAmplitude ( ) const
inline

Definition at line 604 of file ZDCPulseAnalyzer.h.

604 {return m_fitMinAmp;}

◆ getADCPeakHG()

float ZDCPulseAnalyzer::getADCPeakHG ( ) const
inline

Definition at line 693 of file ZDCPulseAnalyzer.h.

693 {return m_ADCPeakHG;}

◆ getADCPeakLG()

float ZDCPulseAnalyzer::getADCPeakLG ( ) const
inline

Definition at line 694 of file ZDCPulseAnalyzer.h.

694 {return m_ADCPeakLG;}

◆ GetAmpError()

float ZDCPulseAnalyzer::GetAmpError ( ) const
inline

Definition at line 632 of file ZDCPulseAnalyzer.h.

632 {return m_ampError;}

◆ GetAmplitude()

float ZDCPulseAnalyzer::GetAmplitude ( ) const
inline

Definition at line 631 of file ZDCPulseAnalyzer.h.

631 {return m_amplitude;}

◆ getAmplitudeCorrection()

double ZDCPulseAnalyzer::getAmplitudeCorrection ( bool  highGain)
private

Definition at line 611 of file ZDCPulseAnalyzer.cxx.

612 {
613  double amplCorrFactor = 1;
614 
615  // If we have FADC correction and we aren't applying it per-sample, do so here
616  //
617  if (m_haveFADCCorrections && !m_FADCCorrPerSample) {
618  double fadcCorr = highGain ? m_FADCCorrHG->Interpolate(m_fitAmplitude) : m_FADCCorrLG->Interpolate(m_fitAmplitude);
619  amplCorrFactor *= fadcCorr;
620  }
621 
622  double amplCorr = m_fitAmplitude * amplCorrFactor;
623 
624  // If we have a non-linear correction, apply it here
625  // We apply it as an inverse correction - i.e. we divide by a correction
626  // term tha is a sum of coefficients times the ADC minus a reference
627  // to a power. The lowest power is 1, the highest is deteremined by
628  // the number of provided coefficients
629 
630  if (m_haveNonlinCorr) {
631  float invNLCorr = 1.0;
632  float nlPolyArg = (amplCorr - m_nonLinCorrRefADC) / m_nonLinCorrRefScale;
633 
634  if (highGain) {
635  for (size_t power = 1; power <= m_nonLinCorrParamsHG.size(); power++) {
636  invNLCorr += m_nonLinCorrParamsHG[power - 1]*pow(nlPolyArg, power);
637  }
638  }
639  else {
640  for (size_t power = 1; power <= m_nonLinCorrParamsLG.size(); power++) {
641  invNLCorr += m_nonLinCorrParamsLG[power - 1]*pow(nlPolyArg, power);
642  }
643  }
644 
645  amplCorrFactor /= invNLCorr;
646  }
647 
648  return amplCorrFactor;
649 }

◆ GetAmpNoNonLin()

float ZDCPulseAnalyzer::GetAmpNoNonLin ( ) const
inline

Definition at line 630 of file ZDCPulseAnalyzer.h.

630 {return m_ampNoNonLin;}

◆ GetBkgdMaxFraction()

float ZDCPulseAnalyzer::GetBkgdMaxFraction ( ) const
inline

Definition at line 710 of file ZDCPulseAnalyzer.h.

710 {return m_bkgdMaxFraction;}

◆ GetChisq()

float ZDCPulseAnalyzer::GetChisq ( ) const
inline

Definition at line 620 of file ZDCPulseAnalyzer.h.

620 {return m_fitChisq;}

◆ GetCombinedGraph()

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

Definition at line 2219 of file ZDCPulseAnalyzer.cxx.

2220 {
2221  //
2222  // We defer filling the histogram if we don't have a pulse until the histogram is requested
2223  //
2224  GetHistogramPtr(LGRefit);
2225 
2226  TH1* hist_p = nullptr, *delayedHist_p = nullptr;
2227  if (LGRefit) {
2228  hist_p = m_fitHistLGRefit.get();
2229  delayedHist_p = m_delayedHistLGRefit.get();
2230  }
2231  else {
2232  hist_p = m_fitHist.get();
2233  delayedHist_p = m_delayedHist.get();
2234  }
2235 
2236  std::shared_ptr<TGraphErrors> theGraph = std::make_shared<TGraphErrors>(TGraphErrors(2 * m_Nsample));
2237  size_t npts = 0;
2238 
2239  for (int ipt = 0; ipt < hist_p->GetNbinsX(); ipt++) {
2240  theGraph->SetPoint(npts, hist_p->GetBinCenter(ipt + 1), hist_p->GetBinContent(ipt + 1));
2241  theGraph->SetPointError(npts++, 0, hist_p->GetBinError(ipt + 1));
2242  }
2243 
2244  for (int iDelayPt = 0; iDelayPt < delayedHist_p->GetNbinsX(); iDelayPt++) {
2245  theGraph->SetPoint(npts, delayedHist_p->GetBinCenter(iDelayPt + 1), delayedHist_p->GetBinContent(iDelayPt + 1) - m_delayedBaselineShift);
2246  theGraph->SetPointError(npts++, 0, delayedHist_p->GetBinError(iDelayPt + 1));
2247  }
2248  if (m_havePulse) {
2249  TF1* func_p = static_cast<TF1*>(hist_p->GetListOfFunctions()->Last());
2250  if (func_p) {
2251  theGraph->GetListOfFunctions()->Add(new TF1(*func_p));
2252  hist_p->GetListOfFunctions()->SetOwner (false);
2253  }
2254  }
2255  theGraph->SetName(( std::string(hist_p->GetName()) + "combinaed").c_str());
2256 
2257  theGraph->SetMarkerStyle(20);
2258  theGraph->SetMarkerColor(1);
2259 
2260  return theGraph;
2261 }

◆ GetdelayBS()

float ZDCPulseAnalyzer::GetdelayBS ( ) const
inline

Definition at line 702 of file ZDCPulseAnalyzer.h.

702 {return m_delayedBaselineShift;}

◆ GetDelayedBaselineCorr()

float ZDCPulseAnalyzer::GetDelayedBaselineCorr ( ) const
inline

Definition at line 713 of file ZDCPulseAnalyzer.h.

713 {return m_baselineCorr;}

◆ GetDelayedBaselineShiftFit()

float ZDCPulseAnalyzer::GetDelayedBaselineShiftFit ( ) const
inline

Definition at line 712 of file ZDCPulseAnalyzer.h.

712 {return m_delayedBaselineShift;}

◆ GetFitAmplitude()

float ZDCPulseAnalyzer::GetFitAmplitude ( ) const
inline

Definition at line 615 of file ZDCPulseAnalyzer.h.

615 {return m_fitAmplitude;}

◆ GetFitExpAmp()

float ZDCPulseAnalyzer::GetFitExpAmp ( ) const
inline

Definition at line 627 of file ZDCPulseAnalyzer.h.

627 {return m_fitExpAmp;}

◆ GetFitPostAmp()

float ZDCPulseAnalyzer::GetFitPostAmp ( ) const
inline

Definition at line 626 of file ZDCPulseAnalyzer.h.

626 {return m_postAmplitude;}

◆ GetFitPostT0()

float ZDCPulseAnalyzer::GetFitPostT0 ( ) const
inline

Definition at line 625 of file ZDCPulseAnalyzer.h.

625 {return m_fitPostT0;}

◆ GetFitPreAmp()

float ZDCPulseAnalyzer::GetFitPreAmp ( ) const
inline

Definition at line 624 of file ZDCPulseAnalyzer.h.

624 {return m_preAmplitude;}

◆ GetFitPreT0()

float ZDCPulseAnalyzer::GetFitPreT0 ( ) const
inline

Definition at line 623 of file ZDCPulseAnalyzer.h.

623 {return m_fitPreT0;}

◆ GetFitPulls()

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

Definition at line 574 of file ZDCPulseAnalyzer.cxx.

575 {
576  //
577  // If there was no pulse for this event, return an empty vector (see reset() method)
578  //
579  if (!m_havePulse) {
580  return m_fitPulls;
581  }
582 
583  //
584  // The combined (delayed+undelayed) pulse fitting fills out m_fitPulls directly
585  //
586  if (m_useDelayed) {
587  return m_fitPulls;
588  }
589  else {
590  //
591  // When not using combined fitting, We don't have the pre-calculated pulls. Calculate them on the fly.
592  //
593  std::vector<float> pulls(m_Nsample, -100);
594 
595  const TH1* dataHist_p = refitLG ? m_fitHistLGRefit.get() : m_fitHist.get();
596  const TF1* fit_p = static_cast<const TF1*>(dataHist_p->GetListOfFunctions()->Last());
597 
598  for (size_t ibin = 0; ibin < m_Nsample ; ibin++) {
599  float t = dataHist_p->GetBinCenter(ibin + 1);
600  float fitVal = fit_p->Eval(t);
601  float histVal = dataHist_p->GetBinContent(ibin + 1);
602  float histErr = dataHist_p->GetBinError(ibin + 1);
603  float pull = (histVal - fitVal)/histErr;
604  pulls[ibin] = pull;
605  }
606 
607  return pulls;
608  }
609 }

◆ GetFitT0()

float ZDCPulseAnalyzer::GetFitT0 ( ) const
inline

Definition at line 616 of file ZDCPulseAnalyzer.h.

616 {return m_fitTime;}

◆ GetFitTau1()

float ZDCPulseAnalyzer::GetFitTau1 ( ) const
inline

Definition at line 621 of file ZDCPulseAnalyzer.h.

621 {return m_fitTau1;}

◆ GetFitTau2()

float ZDCPulseAnalyzer::GetFitTau2 ( ) const
inline

Definition at line 622 of file ZDCPulseAnalyzer.h.

622 {return m_fitTau2;}

◆ GetFitTMax()

float ZDCPulseAnalyzer::GetFitTMax ( ) const
inline

Definition at line 699 of file ZDCPulseAnalyzer.h.

699 {return m_fitTMax;}

◆ GetFitTMin()

float ZDCPulseAnalyzer::GetFitTMin ( ) const
inline

Definition at line 700 of file ZDCPulseAnalyzer.h.

700 {return m_fitTMin;}

◆ GetGraph()

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

Definition at line 2264 of file ZDCPulseAnalyzer.cxx.

2265 {
2266  //
2267  // We defer filling the histogram if we don't have a pulse until the histogram is requested
2268  //
2269  const TH1* hist_p = GetHistogramPtr(forceLG);
2270 
2271  std::shared_ptr<TGraphErrors> theGraph = std::make_shared<TGraphErrors>(TGraphErrors(m_Nsample));
2272  size_t npts = 0;
2273 
2274  for (int ipt = 0; ipt < hist_p->GetNbinsX(); ipt++) {
2275  theGraph->SetPoint(npts, hist_p->GetBinCenter(ipt + 1), hist_p->GetBinContent(ipt + 1));
2276  theGraph->SetPointError(npts++, 0, hist_p->GetBinError(ipt + 1));
2277  }
2278 
2279  TF1* func_p = static_cast<TF1*>(hist_p->GetListOfFunctions()->Last());
2280  theGraph->GetListOfFunctions()->Add(func_p);
2281  theGraph->SetName(( std::string(hist_p->GetName()) + "not_combinaed").c_str());
2282 
2283  theGraph->SetMarkerStyle(20);
2284  theGraph->SetMarkerColor(1);
2285 
2286  return theGraph;
2287 }

◆ GetHistogramPtr()

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

Definition at line 715 of file ZDCPulseAnalyzer.h.

716  {
717  //
718  // We defer filling the histogram if we don't have a pulse until the histogram is requested
719  //
720  if (!m_havePulse) {
721  FillHistogram(refitLG);
722  }
723 
724  return refitLG ? m_fitHistLGRefit.get() : m_fitHist.get();
725  }

◆ getLGMode()

unsigned int ZDCPulseAnalyzer::getLGMode ( ) const
inline

Definition at line 508 of file ZDCPulseAnalyzer.h.

508 {return m_LGMode;}

◆ getMaxADCHG()

float ZDCPulseAnalyzer::getMaxADCHG ( ) const
inline

Definition at line 672 of file ZDCPulseAnalyzer.h.

672 {return m_maxADCHG;}

◆ getMaxADCLG()

float ZDCPulseAnalyzer::getMaxADCLG ( ) const
inline

Definition at line 673 of file ZDCPulseAnalyzer.h.

673 {return m_maxADCLG;}

◆ getMaxADCSampleHG()

int ZDCPulseAnalyzer::getMaxADCSampleHG ( ) const
inline

Definition at line 687 of file ZDCPulseAnalyzer.h.

687 {return m_maxADCSampleHG;}

◆ getMaxADCSampleLG()

int ZDCPulseAnalyzer::getMaxADCSampleLG ( ) const
inline

Definition at line 690 of file ZDCPulseAnalyzer.h.

690 {return m_maxADCSampleLG;}

◆ getMaxADCSub()

float ZDCPulseAnalyzer::getMaxADCSub ( ) const
inline

Definition at line 677 of file ZDCPulseAnalyzer.h.

677  {
678  float maxADCNosub = m_useLowGain ? m_maxADCLG : m_maxADCHG;
679  return maxADCNosub - m_pedestal - m_preSample;
680  }

◆ GetMaxDelta()

float ZDCPulseAnalyzer::GetMaxDelta ( ) const
inline

Definition at line 696 of file ZDCPulseAnalyzer.h.

696 {return m_maxDelta;}

◆ getMinADCHG()

float ZDCPulseAnalyzer::getMinADCHG ( ) const
inline

Definition at line 674 of file ZDCPulseAnalyzer.h.

674 {return m_minADCHG;}

◆ getMinADCLG()

float ZDCPulseAnalyzer::getMinADCLG ( ) const
inline

Definition at line 675 of file ZDCPulseAnalyzer.h.

675 {return m_minADCLG;}

◆ getMinADCSampleHG()

int ZDCPulseAnalyzer::getMinADCSampleHG ( ) const
inline

Definition at line 688 of file ZDCPulseAnalyzer.h.

688 {return m_minADCSampleHG;}

◆ getMinADCSampleLG()

int ZDCPulseAnalyzer::getMinADCSampleLG ( ) const
inline

Definition at line 691 of file ZDCPulseAnalyzer.h.

691 {return m_minADCSampleLG;}

◆ getMinADCSub()

float ZDCPulseAnalyzer::getMinADCSub ( ) const
inline

Definition at line 682 of file ZDCPulseAnalyzer.h.

682  {
683  float minADCNosub = m_useLowGain ? m_minADCLG : m_minADCHG;
684  return minADCNosub - m_pedestal - m_preSample;
685  }

◆ GetMinDelta()

float ZDCPulseAnalyzer::GetMinDelta ( ) const
inline

Definition at line 697 of file ZDCPulseAnalyzer.h.

697 {return m_minDelta;}

◆ GetMinDeriv2nd()

float ZDCPulseAnalyzer::GetMinDeriv2nd ( ) const
inline

Definition at line 704 of file ZDCPulseAnalyzer.h.

704 {return m_minDeriv2nd;}

◆ GetMinDeriv2ndIndex()

float ZDCPulseAnalyzer::GetMinDeriv2ndIndex ( ) const
inline

Definition at line 705 of file ZDCPulseAnalyzer.h.

705 {return m_minDeriv2ndIndex;}

◆ GetPreExpAmp()

float ZDCPulseAnalyzer::GetPreExpAmp ( ) const
inline

Definition at line 633 of file ZDCPulseAnalyzer.h.

633 {return m_expAmplitude;}

◆ getPresample()

float ZDCPulseAnalyzer::getPresample ( ) const
inline

Definition at line 671 of file ZDCPulseAnalyzer.h.

671 {return m_preSample;}

◆ GetPreSampleAmp()

float ZDCPulseAnalyzer::GetPreSampleAmp ( ) const
inline

Definition at line 709 of file ZDCPulseAnalyzer.h.

709 {return m_preSampleAmp;}

◆ getRefitLGAmp()

float ZDCPulseAnalyzer::getRefitLGAmp ( ) const
inline

Definition at line 635 of file ZDCPulseAnalyzer.h.

636  {
637  if (m_evtLGRefit) return m_refitLGAmpl;
638  else return 0;
639  }

◆ getRefitLGAmpCorr()

float ZDCPulseAnalyzer::getRefitLGAmpCorr ( ) const
inline

Definition at line 647 of file ZDCPulseAnalyzer.h.

648  {
649  if (m_evtLGRefit) return m_refitLGAmplCorr;
650  else return 0;
651  }

◆ getRefitLGChisq()

float ZDCPulseAnalyzer::getRefitLGChisq ( ) const
inline

Definition at line 653 of file ZDCPulseAnalyzer.h.

654  {
655  if (m_evtLGRefit) return m_refitLGChisq;
656  else return 0;
657  }

◆ getRefitLGFitAmp()

float ZDCPulseAnalyzer::getRefitLGFitAmp ( ) const
inline

Definition at line 641 of file ZDCPulseAnalyzer.h.

642  {
643  if (m_evtLGRefit) return m_refitLGFitAmpl;
644  else return 0;
645  }

◆ getRefitLGTime()

float ZDCPulseAnalyzer::getRefitLGTime ( ) const
inline

Definition at line 659 of file ZDCPulseAnalyzer.h.

660  {
661  if (m_evtLGRefit) return m_refitLGTime;
662  else return 0;
663  }

◆ getRefitLGTimeSub()

float ZDCPulseAnalyzer::getRefitLGTimeSub ( ) const
inline

Definition at line 665 of file ZDCPulseAnalyzer.h.

666  {
667  if (m_evtLGRefit) return m_refitLGTimeSub;
668  else return 0;
669  }

◆ GetSamplesDeriv2nd()

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

Definition at line 737 of file ZDCPulseAnalyzer.h.

737 {return m_samplesDeriv2nd;}

◆ GetSamplesSub()

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

Definition at line 736 of file ZDCPulseAnalyzer.h.

736 {return m_samplesSub;}

◆ GetStatusMask()

unsigned int ZDCPulseAnalyzer::GetStatusMask ( ) const

Definition at line 2188 of file ZDCPulseAnalyzer.cxx.

2189 {
2190  unsigned int statusMask = 0;
2191 
2192  if (havePulse()) statusMask |= 1 << PulseBit;
2193  if (useLowGain()) statusMask |= 1 << LowGainBit;
2194  if (failed()) statusMask |= 1 << FailBit;
2195  if (HGOverflow()) statusMask |= 1 << HGOverflowBit;
2196 
2197  if (HGUnderflow()) statusMask |= 1 << HGUnderflowBit;
2198  if (PSHGOverUnderflow()) statusMask |= 1 << PSHGOverUnderflowBit;
2199  if (LGOverflow()) statusMask |= 1 << LGOverflowBit;
2200  if (LGUnderflow()) statusMask |= 1 << LGUnderflowBit;
2201 
2202  if (prePulse()) statusMask |= 1 << PrePulseBit;
2203  if (postPulse()) statusMask |= 1 << PostPulseBit;
2204  if (fitFailed()) statusMask |= 1 << FitFailedBit;
2205  if (badChisq()) statusMask |= 1 << BadChisqBit;
2206 
2207  if (badT0()) statusMask |= 1 << BadT0Bit;
2208  if (excludeEarlyLG()) statusMask |= 1 << ExcludeEarlyLGBit;
2209  if (excludeLateLG()) statusMask |= 1 << ExcludeLateLGBit;
2210  if (preExpTail()) statusMask |= 1 << preExpTailBit;
2211  if (fitMinimumAmplitude()) statusMask |= 1 << FitMinAmpBit;
2212  if (repassPulse()) statusMask |= 1 << RepassPulseBit;
2213  if (armSumInclude()) statusMask |= 1 << ArmSumIncludeBit;
2214  if (failSigCut()) statusMask |= 1 << FailSigCutBit;
2215 
2216  return statusMask;
2217 }

◆ GetT0Corr()

float ZDCPulseAnalyzer::GetT0Corr ( ) const
inline

Definition at line 618 of file ZDCPulseAnalyzer.h.

618 {return m_fitTimeCorr;}

◆ GetT0Sub()

float ZDCPulseAnalyzer::GetT0Sub ( ) const
inline

Definition at line 617 of file ZDCPulseAnalyzer.h.

617 {return m_fitTimeSub;}

◆ getTimeSig()

float ZDCPulseAnalyzer::getTimeSig ( ) const
inline

Definition at line 619 of file ZDCPulseAnalyzer.h.

619 {return m_timeSig;}

◆ HaveData()

bool ZDCPulseAnalyzer::HaveData ( ) const
inline

Definition at line 580 of file ZDCPulseAnalyzer.h.

580 {return m_haveData;}

◆ havePulse()

bool ZDCPulseAnalyzer::havePulse ( ) const
inline

Definition at line 585 of file ZDCPulseAnalyzer.h.

585 {return m_havePulse;}

◆ HGOverflow()

bool ZDCPulseAnalyzer::HGOverflow ( ) const
inline

Definition at line 588 of file ZDCPulseAnalyzer.h.

588 {return m_HGOverflow;}

◆ HGUnderflow()

bool ZDCPulseAnalyzer::HGUnderflow ( ) const
inline

Definition at line 590 of file ZDCPulseAnalyzer.h.

590 {return m_HGUnderflow;}

◆ LGOverflow()

bool ZDCPulseAnalyzer::LGOverflow ( ) const
inline

Definition at line 592 of file ZDCPulseAnalyzer.h.

592 {return m_LGOverflow;}

◆ LGUnderflow()

bool ZDCPulseAnalyzer::LGUnderflow ( ) const
inline

Definition at line 593 of file ZDCPulseAnalyzer.h.

593 {return m_LGUnderflow;}

◆ LoadAndAnalyzeData() [1/2]

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

Definition at line 744 of file ZDCPulseAnalyzer.cxx.

745 {
746  if (m_useDelayed) {
747  (*m_msgFunc_p)(ZDCMsg::Fatal, "ZDCPulseAnalyzer::LoadAndAnalyzeData:: Wrong LoadAndAnalyzeData called -- expecting both delayed and undelayed samples");
748  }
749 
750  if (!m_initializedFits) SetupFitFunctions();
751 
752  // Clear any transient data
753  //
754  Reset(false);
755 
756  // Make sure we have the right number of samples. Should never fail. necessry?
757  //
758  if (ADCSamplesHG.size() != m_Nsample || ADCSamplesLG.size() != m_Nsample) {
759  m_fail = true;
760  return false;
761  }
762 
763  m_ADCSamplesHG = ADCSamplesHG;
764  m_ADCSamplesLG = ADCSamplesLG;
765 
766  return DoAnalysis(false);
767 }

◆ 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 769 of file ZDCPulseAnalyzer.cxx.

771 {
772  if (!m_useDelayed) {
773  (*m_msgFunc_p)(ZDCMsg::Fatal, "ZDCPulseAnalyzer::LoadAndAnalyzeData:: Wrong LoadAndAnalyzeData called -- expecting only undelayed samples");
774  }
775 
776  if (!m_initializedFits) SetupFitFunctions();
777 
778  // Clear any transient data
779  //
780  Reset();
781 
782  // Make sure we have the right number of samples. Should never fail. necessry?
783  //
784  if (ADCSamplesHG.size() != m_Nsample || ADCSamplesLG.size() != m_Nsample ||
785  ADCSamplesHGDelayed.size() != m_Nsample || ADCSamplesLGDelayed.size() != m_Nsample) {
786  m_fail = true;
787  return false;
788  }
789 
790  m_ADCSamplesHG.reserve(m_Nsample*2);
791  m_ADCSamplesLG.reserve(m_Nsample*2);
792 
793  // Now do pedestal subtraction and check for overflows
794  //
795  for (size_t isample = 0; isample < m_Nsample; isample++) {
796  float ADCHG = ADCSamplesHG[isample];
797  float ADCLG = ADCSamplesLG[isample];
798 
799  float ADCHGDelay = ADCSamplesHGDelayed[isample] - m_delayedPedestalDiff;
800  float ADCLGDelay = ADCSamplesLGDelayed[isample] - m_delayedPedestalDiff;
801 
802  if (m_delayedDeltaT > 0) {
803  m_ADCSamplesHG.push_back(ADCHG);
804  m_ADCSamplesHG.push_back(ADCHGDelay);
805 
806  m_ADCSamplesLG.push_back(ADCLG);
807  m_ADCSamplesLG.push_back(ADCLGDelay);
808  }
809  else {
810  m_ADCSamplesHG.push_back(ADCHGDelay);
811  m_ADCSamplesHG.push_back(ADCHG);
812 
813  m_ADCSamplesLG.push_back(ADCLGDelay);
814  m_ADCSamplesLG.push_back(ADCLG);
815  }
816  }
817 
818  return DoAnalysis(false);
819 }

◆ MakeCombinedFitter()

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

Definition at line 2029 of file ZDCPulseAnalyzer.cxx.

2030 {
2031  TVirtualFitter::SetDefaultFitter("Minuit");
2032 
2033  size_t nFitParams = func->GetNpar() + 1;
2034  std::unique_ptr<TFitter> fitter = std::make_unique<TFitter>(nFitParams);
2035 
2036  fitter->GetMinuit()->fISW[4] = -1;
2037  fitter->SetParameter(0, "delayBaselineAdjust", 0, 0.01, -100, 100);
2038 
2039  for (size_t ipar = 0; ipar < nFitParams - 1; ipar++) {
2040  double parLimitLow, parLimitHigh;
2041 
2042  func->GetParLimits(ipar, parLimitLow, parLimitHigh);
2043  if (std::abs(parLimitHigh / parLimitLow - 1) < 1e-6) {
2044  double value = func->GetParameter(ipar);
2045  double lowLim = std::min(value * 0.99, value * 1.01);
2046  double highLim = std::max(value * 0.99, value * 1.01);
2047 
2048  fitter->SetParameter(ipar + 1, func->GetParName(ipar), func->GetParameter(ipar), 0.01, lowLim, highLim);
2049  fitter->FixParameter(ipar + 1);
2050  }
2051  else {
2052  double value = func->GetParameter(ipar);
2053  if (value >= parLimitHigh) value = parLimitHigh * 0.99;
2054  else if (value <= parLimitLow) value = parLimitLow * 1.01;
2055 
2056  double step = std::min((parLimitHigh - parLimitLow)/100., (value - parLimitLow)/100.);
2057 
2058  fitter->SetParameter(ipar + 1, func->GetParName(ipar), value, step, parLimitLow, parLimitHigh);
2059  }
2060  }
2061 
2062  fitter->SetFCN(ZDCPulseAnalyzer::CombinedPulsesFCN);
2063 
2064  return fitter;
2065 }

◆ obtainDelayedBaselineCorr()

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

Definition at line 2343 of file ZDCPulseAnalyzer.cxx.

2344 {
2345  const unsigned int nsamples = samples.size();
2346 
2347  std::vector<float> derivVec = CalculateDerivative(samples, 2);
2348  std::vector<float> deriv2ndVec = Calculate2ndDerivative(samples, 2);
2349 
2350  // Now step through and check even and odd samples values for 2nd derivative and derivative
2351  // we start with index 2 since the 2nd derivative calculation has 2 initial zeros with nstep = 2
2352  //
2353  float minScore = 1.0e9;
2354  unsigned int minIndex = 0;
2355 
2356  for (unsigned int idx = 2; idx < nsamples - 1; idx++) {
2357  float deriv = derivVec[idx];
2358  float prevDeriv = derivVec[idx - 1];
2359 
2360  float derivDiff = deriv - prevDeriv;
2361 
2362  float deriv2nd = deriv2ndVec[idx];
2363  if (idx > nsamples - 2) deriv2nd = deriv2ndVec[idx - 1];
2364 
2365  // Calculate a score based on the actual derivatives (squared) and 2nd derivatives (squared)
2366  // and the slope differences (squared). The relative weights are not adjustable for now
2367  //
2368  float score = (deriv*deriv + 2*derivDiff*derivDiff +
2369  0.5*deriv2nd*deriv2nd);
2370 
2371  if (score < minScore) {
2372  minScore = score;
2373  minIndex = idx;
2374  }
2375  }
2376 
2377  // We use four samples, two each of "even" and "odd".
2378  // Because of the way the above analysis is done, we can always
2379  // Go back one even and one odd sample and forward one odd sample.
2380  //
2381  //if minIndex is < 2 or >samples.size() the result is undefined; prevent this:
2382  if (minIndex<2 or (minIndex+1) >=nsamples){
2383  throw std::out_of_range("minIndex out of range in ZDCPulseAnalyzer::obtainDelayedBaselineCorr");
2384  }
2385  float sample0 = samples[minIndex - 2];
2386  float sample1 = samples[minIndex - 1];
2387  float sample2 = samples[minIndex];
2388  float sample3 = samples[minIndex + 1];
2389 
2390  // Possibility -- implement logarithmic interpolation for large 2nd derivative?
2391  //
2392  float baselineCorr = (0.5 * (sample1 - sample0 + sample3 - sample2) -
2393  0.25 * (sample3 - sample1 + sample2 - sample0));
2394 
2395  if (minIndex % 2 != 0) baselineCorr =-baselineCorr;
2396 
2397  return baselineCorr;
2398 }

◆ postPulse()

bool ZDCPulseAnalyzer::postPulse ( ) const
inline

Definition at line 596 of file ZDCPulseAnalyzer.h.

596 {return m_postPulse;}

◆ preExpTail()

bool ZDCPulseAnalyzer::preExpTail ( ) const
inline

Definition at line 603 of file ZDCPulseAnalyzer.h.

603 {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 1529 of file ZDCPulseAnalyzer.cxx.

1531 {
1532  m_samplesLGRefit.clear();
1533  m_samplesSigLGRefit.clear();
1534 
1535  float presampleLG = m_ADCSamplesLGSub[m_usedPresampIdx];
1536 
1537  // Do the presample subtraction
1538  //
1539  for (unsigned int idx = 0; idx < samplesLG.size(); idx++) {
1540  m_samplesLGRefit.push_back(samplesLG[idx] - presampleLG);
1541 
1542  if (useSamples[idx]) {
1543  m_samplesSigLGRefit.push_back(samplesSig[idx]);
1544  }
1545  else {
1546  m_samplesSigLGRefit.push_back(0);
1547  }
1548  }
1549 }

◆ prePulse()

bool ZDCPulseAnalyzer::prePulse ( ) const
inline

Definition at line 595 of file ZDCPulseAnalyzer.h.

595 {return m_prePulse;}

◆ PSHGOverUnderflow()

bool ZDCPulseAnalyzer::PSHGOverUnderflow ( ) const
inline

Definition at line 591 of file ZDCPulseAnalyzer.h.

591 {return m_PSHGOverUnderflow;}

◆ quietFits()

bool ZDCPulseAnalyzer::quietFits ( ) const
inline

Definition at line 474 of file ZDCPulseAnalyzer.h.

474 {return m_quietFits;}

◆ ReanalyzeData()

bool ZDCPulseAnalyzer::ReanalyzeData ( )

Definition at line 821 of file ZDCPulseAnalyzer.cxx.

822 {
823  Reset(true);
824 
825  bool result = DoAnalysis(true);
826  if (result && havePulse()) {
827  m_repassPulse = true;
828  }
829 
830  return result;
831 }

◆ repassPulse()

bool ZDCPulseAnalyzer::repassPulse ( ) const
inline

Definition at line 605 of file ZDCPulseAnalyzer.h.

605 {return m_repassPulse;}

◆ Reset()

void ZDCPulseAnalyzer::Reset ( bool  reanalyze = false)
private

Definition at line 297 of file ZDCPulseAnalyzer.cxx.

298 {
299  if (!repass) {
300  m_haveData = false;
301 
302  m_useLowGain = false;
303  m_fail = false;
304  m_HGOverflow = false;
305 
306  m_HGUnderflow = false;
307  m_PSHGOverUnderflow = false;
308  m_LGOverflow = false;
309  m_LGUnderflow = false;
310 
311  m_ExcludeEarly = false;
312  m_ExcludeLate = false;
313 
314  m_adjTimeRangeEvent = false;
315  m_backToHG_pre = false;
316  m_fixPrePulse = false;
317 
318  m_minADCLG = -1;
319  m_maxADCLG = -1;
320  m_minADCHG = -1;
321  m_maxADCHG = -1;
322 
323  m_minADCSampleHG = -1;
324  m_maxADCSampleHG = -1;
325  m_minADCSampleLG = -1;
326  m_maxADCSampleLG = -1;
327 
328  m_ADCPeakHG = -1;
329  m_ADCPeakLG = -1;
330 
331  int sampleVecSize = m_Nsample;
332  if (m_useDelayed) sampleVecSize *= 2;
333 
334  m_ADCSamplesHG.clear();
335  m_ADCSamplesLG.clear();
336 
337  m_ADCSamplesHGSub.clear();
338  m_ADCSamplesLGSub.clear();
339 
340  m_ADCSSampSigHG.assign(sampleVecSize, m_noiseSigHG);
341  m_ADCSSampSigLG.assign(sampleVecSize, m_noiseSigLG);
342 
343  m_minSampleEvt = 0;
344  m_maxSampleEvt = (m_useDelayed ? 2 * m_Nsample - 1 : m_Nsample - 1);
345 
346  m_usedPresampIdx = 0;
347 
348  m_fitTMax = m_defaultFitTMax;
349  m_fitTMin = m_defaultFitTMin;
350 
351  m_lastHGOverFlowSample = -999;
352  m_firstHGOverFlowSample = 999;
353  }
354 
355 
356  m_defaultT0Max = m_deltaTSample * (m_peak2ndDerivMinSample + m_peak2ndDerivMinTolerance + 0.5);
357  m_defaultT0Min = m_deltaTSample * (m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance - 0.5);
358 
359  if (m_initializedFits) {
360  m_defaultFitWrapper ->SetT0Range(m_defaultT0Min, m_defaultT0Max);
361  m_prePulseFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
362  m_preExpFitWrapper->SetT0Range(m_defaultT0Min, m_defaultT0Max);
363  }
364 
365  // -----------------------
366  // Statuses
367  //
368  m_havePulse = false;
369 
370  m_prePulse = false;
371  m_postPulse = false;
372  m_fitFailed = false;
373  m_badChisq = false;
374 
375  m_badT0 = false;
376  m_preExpTail = false;
377  m_repassPulse = false;
378 
379  m_fitMinAmp = false;
380  m_evtLGRefit = false;
381  m_failSigCut = false;
382 
383  // -----------------------
384 
385  m_delayedBaselineShift = 0;
386 
387  m_fitAmplitude = 0;
388  m_ampNoNonLin = 0;
389  m_fitTime = -100;
390  m_fitTimeSub = -100;
391  m_fitTimeCorr = -100;
392  m_fitTCorr2nd = -100;
393 
394  m_fitPreT0 = -100;
395  m_fitPreAmp = -100;
396  m_fitPostT0 = -100;
397  m_fitPostAmp = -100;
398  m_fitExpAmp = -100;
399 
400  m_minDeriv2ndSig = -10;
401  m_preExpSig = -10;
402  m_prePulseSig = -10;
403 
404  m_fitChisq = 0;
405 
406  m_amplitude = 0;
407  m_ampError = 0;
408  m_preSampleAmp = 0;
409  m_preAmplitude = 0;
410  m_postAmplitude = 0;
411  m_expAmplitude = 0;
412  m_bkgdMaxFraction = 0;
413 
414  m_refitLGAmpl = 0;
415  m_refitLGAmpError = 0;
416  m_refitLGChisq = 0;
417  m_refitLGTime = -100;
418  m_refitLGTimeSub = -100;
419 
420  m_initialPrePulseT0 = -10;
421  m_initialPrePulseAmp = 5;
422 
423  m_initialPostPulseT0 = 100;
424 
425  m_initialExpAmp = 0;
426  m_fitPostT0lo = 0;
427 
428  m_fitPulls.clear();
429 
430  m_sigMinLG = 0;
431  m_sigMinHG = 0;
432 
433  m_samplesSub.clear();
434  m_samplesDeriv2nd.clear();
435 }

◆ saveFitFunc()

void ZDCPulseAnalyzer::saveFitFunc ( )
inline

Definition at line 472 of file ZDCPulseAnalyzer.h.

472 {m_saveFitFunc = true;}

◆ ScanAndSubtractSamples()

bool ZDCPulseAnalyzer::ScanAndSubtractSamples ( )
private

Definition at line 833 of file ZDCPulseAnalyzer.cxx.

834 {
835  //
836  // Dump samples to verbose output
837  //
838  bool doDump = (*m_msgFunc_p)(ZDCMsg::Verbose, "Dumping all samples before subtraction: ");
839 
840  m_NSamplesAna = m_ADCSamplesHG.size();
841 
842  m_ADCSamplesHGSub.assign(m_NSamplesAna, 0);
843  m_ADCSamplesLGSub.assign(m_NSamplesAna, 0);
844 
845  m_useSampleHG.assign(m_NSamplesAna, true);
846  m_useSampleLG.assign(m_NSamplesAna, true);
847 
848  // Now do pedestal subtraction and check for overflows
849  //
850  m_minADCHG = m_HGOverflowADC;
851  m_minADCLG = m_LGOverflowADC;
852 
853  m_maxADCHG = 0;
854  m_maxADCLG = 0;
855 
856  for (size_t isample = 0; isample < m_NSamplesAna; isample++) {
857  float ADCHG = m_ADCSamplesHG[isample];
858  float ADCLG = m_ADCSamplesLG[isample];
859 
860  //
861  // We always pedestal subtract even if the sample isn't going to be used in analysis
862  // basically for diagnostics
863  //
864  m_ADCSamplesHGSub[isample] = ADCHG - m_pedestal;
865  m_ADCSamplesLGSub[isample] = ADCLG - m_pedestal;
866 
867 
868  // If we have the per-sample FADC correction, we apply it after pedestal correction
869  // since we analyze the FADC response after baseline (~ same as pedestal) subtraction
870  //
871  if (m_haveFADCCorrections && m_FADCCorrPerSample) {
872  double fadcCorrHG = m_FADCCorrHG->Interpolate(m_ADCSamplesHGSub[isample]);
873  double fadcCorrLG = m_FADCCorrLG->Interpolate(m_ADCSamplesLGSub[isample]);
874 
875  m_ADCSamplesHGSub[isample] *= fadcCorrHG;
876  m_ADCSamplesLGSub[isample] *= fadcCorrLG;
877 
878  if (doDump) {
879  std::ostringstream dumpString;
880  dumpString << "After FADC correction, sample " << isample << ", HG ADC = " << m_ADCSamplesHGSub[isample]
881  << ", LG ADC = " << m_ADCSamplesLGSub[isample] << std::endl;
882  (*m_msgFunc_p)(ZDCMsg::Verbose, dumpString.str().c_str());
883  }
884  }
885 
886  if (ADCHG > m_maxADCHG) {
887  m_maxADCHG = ADCHG;
888  m_maxADCSampleHG = isample;
889  }
890  else if (ADCHG < m_minADCHG) {
891  m_minADCHG = ADCHG;
892  m_minADCSampleHG = isample;
893  }
894 
895  if (ADCLG > m_maxADCLG) {
896  m_maxADCLG = ADCLG;
897  m_maxADCSampleLG = isample;
898  }
899  else if (ADCLG < m_minADCLG) {
900  m_minADCLG = ADCLG;
901  m_minADCSampleLG = isample;
902  }
903 
904  if (m_useSampleHG[isample]) {
905  if (m_enablePreExcl) {
906  if (ADCHG > m_preExclHGADCThresh && isample < m_maxSamplesPreExcl) {
907  m_useSampleHG[isample] = false;
908  continue;
909  }
910  }
911 
912  if (m_enablePostExcl) {
913  if (ADCHG > m_postExclHGADCThresh && isample >= m_NSamplesAna - m_maxSamplesPostExcl) {
914  m_useSampleHG[isample] = false;
915  continue;
916  }
917  }
918 
919  // If we get here, we've passed the above filters on the sample
920  //
921  if (ADCHG > m_HGOverflowADC) {
922  m_HGOverflow = true;
923 
924  if (isample == m_preSampleIdx) m_PSHGOverUnderflow = true;
925 
926  // Note: the implementation of the explicit pre- and post- sample exclusion should make this
927  // code obselete but before removing it we first need to validate the pre- and post-exclusion
928  //
929  if ((int) isample > m_lastHGOverFlowSample) m_lastHGOverFlowSample = isample;
930  if ((int) isample < m_firstHGOverFlowSample) m_firstHGOverFlowSample = isample;
931  }
932  else if (ADCHG < m_HGUnderflowADC) {
933  m_HGUnderflow = true;
934 
935  if (isample == m_preSampleIdx) m_PSHGOverUnderflow = true;
936  }
937  }
938 
939  // Now the low gain sample
940  //
941  if (m_useSampleLG[isample]) {
942  if (m_enablePreExcl) {
943  if (ADCLG > m_preExclLGADCThresh && isample <= m_maxSamplesPreExcl) {
944  m_useSampleLG[isample] = false;
945  continue;
946  }
947  }
948 
949  if (m_enablePostExcl) {
950  if (ADCLG > m_postExclLGADCThresh && isample >= m_NSamplesAna - m_maxSamplesPostExcl) {
951  m_useSampleLG[isample] = false;
952  m_ExcludeLate = true;
953  continue;
954  }
955  }
956 
957  if (ADCLG > m_LGOverflowADC) {
958  m_LGOverflow = true;
959  m_fail = true;
960  m_amplitude = m_LGOverflowADC * m_gainFactorLG; // Give a vale here even though we know it's wrong because
961  // the user may not check the return value and we know that
962  // amplitude is bigger than this
963  }
964 
965  if (ADCLG == 0) {
966  m_LGUnderflow = true;
967  m_fail = true;
968  }
969  }
970  }
971 
972  // if (doDump) {
973  // (*m_msgFunc_p)(ZDCMsg::Verbose, "Dump of useSamples: ");
974 
975  // std::ostringstream dumpStringUseHG;
976  // dumpStringUseHG << "HG: ";
977  // for (auto val : m_useSampleHG) {
978  // dumpStringUseHG << val << " ";
979  // }
980  // (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringUseHG.str().c_str());
981 
982  // std::ostringstream dumpStringUseLG;
983  // dumpStringUseLG << "LG: ";
984  // for (auto val : m_useSampleLG) {
985  // dumpStringUseLG << val << " ";
986  // }
987  // (*m_msgFunc_p)(ZDCMsg::Verbose, dumpStringUseLG.str().c_str());
988  // }
989 
990  // This ugly code should be obseleted by the introduction of the better, pre- and post-sample exclusion but
991  // that code still has to be fully validated.
992  //
993  // See if we can still use high gain even in the case of HG overflow if the overflow results from
994  // the first few samples or the last few samples
995  //
996  if (m_HGOverflow && !m_HGUnderflow) {
997  if (m_lastHGOverFlowSample < 2 && m_lastHGOverFlowSample > -1) {
998  m_HGOverflow = false;
999  m_minSampleEvt = m_lastHGOverFlowSample + 1;
1000  m_adjTimeRangeEvent = true;
1001  m_backToHG_pre = true;
1002  m_ExcludeEarly = true;
1003  }
1004  else if (m_firstHGOverFlowSample < static_cast<int>(m_NSamplesAna) && m_firstHGOverFlowSample >= static_cast<int>(m_NSamplesAna - 2) ) {
1005  m_maxSampleEvt = m_firstHGOverFlowSample - 1;
1006  m_HGOverflow = false;
1007  m_adjTimeRangeEvent = true;
1008  m_ExcludeLate = true;
1009  }
1010  }
1011 
1012  // (*m_msgFunc_p)(ZDCMsg::Verbose, "ZDCPulseAnalyzer:: " + m_tag + ": ScanAndSubtractSamples done");
1013 
1014  return true;
1015 }

◆ set2ndDerivStep()

void ZDCPulseAnalyzer::set2ndDerivStep ( size_t  step)
inline

Definition at line 510 of file ZDCPulseAnalyzer.h.

510 {m_2ndDerivStep = step;}

◆ SetADCOverUnderflowValues()

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

Definition at line 490 of file ZDCPulseAnalyzer.cxx.

491 {
492  m_HGOverflowADC = HGOverflowADC;
493  m_LGOverflowADC = LGOverflowADC;
494  m_HGUnderflowADC = HGUnderflowADC;
495 }

◆ SetCutValues()

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

Definition at line 497 of file ZDCPulseAnalyzer.cxx.

500 {
501  m_chisqDivAmpCutHG = chisqDivAmpCutHG;
502  m_chisqDivAmpCutLG = chisqDivAmpCutLG;
503 
504  m_T0CutLowHG = deltaT0MinHG;
505  m_T0CutLowLG = deltaT0MinLG;
506 
507  m_T0CutHighHG = deltaT0MaxHG;
508  m_T0CutHighLG = deltaT0MaxLG;
509 }

◆ SetDefaults()

void ZDCPulseAnalyzer::SetDefaults ( )
private

Definition at line 234 of file ZDCPulseAnalyzer.cxx.

235 {
236  m_LGMode = LGModeNormal;
237 
238  m_nominalTau1 = 1.5;
239  m_nominalTau2 = 5;
240 
241  m_fixTau1 = false;
242  m_fixTau2 = false;
243 
244  m_HGOverflowADC = 3500;
245  m_HGUnderflowADC = 1;
246  m_LGOverflowADC = 3900;
247 
248  // Default values for the gain factors uswed to match low and high gain
249  //
250  m_gainFactorLG = 10;
251  m_gainFactorHG = 1;
252 
253  m_2ndDerivStep = 1;
254 
255  m_noiseSigHG = 1;
256  m_noiseSigLG = 1;
257 
258  m_timeCutMode = 0;
259  m_chisqDivAmpCutLG = 100;
260  m_chisqDivAmpCutHG = 100;
261 
262  m_LGT0CorrParams.assign(4, 0);
263  m_HGT0CorrParams.assign(4, 0);
264 
265  // m_defaultFitTMax = m_tmax;
266  // m_defaultFitTMin = m_tmin;
267 
268  m_fitAmpMinHG = 1;
269  m_fitAmpMinLG = 1;
270 
271  m_fitAmpMaxHG = 1500;
272  m_fitAmpMaxLG = 1500;
273 
274  m_haveSignifCuts = false;
275 
276  m_postPulse = false;
277  m_prePulse = false;
278 
279  m_initialPrePulseT0 = -10;
280  m_initialPrePulseAmp = 5;
281 
282  m_initialPostPulseT0 = 100;
283 
284  m_initialExpAmp = 0;
285  m_fitPostT0lo = 0;
286 
287  m_useDelayed = false;
288  m_enablePreExcl = false;
289  m_enablePostExcl = false;
290 
291  m_timingCorrMode = NoTimingCorr;
292  m_haveNonlinCorr = false;
293  m_quietFits = true;
294  m_fitOptions = "s";
295 }

◆ SetFitMinMaxAmp()

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

Definition at line 451 of file ZDCPulseAnalyzer.cxx.

452 {
453  m_fitAmpMinHG = minAmpHG;
454  m_fitAmpMinLG = minAmpLG;
455 
456  m_fitAmpMaxHG = maxAmpHG;
457  m_fitAmpMaxLG = maxAmpLG;
458 }

◆ setFitOPtions()

void ZDCPulseAnalyzer::setFitOPtions ( const std::string &  fitOptions)
inline

Definition at line 471 of file ZDCPulseAnalyzer.h.

471 { m_fitOptions = fitOptions;}

◆ SetFitTimeMax()

void ZDCPulseAnalyzer::SetFitTimeMax ( float  tmax)

Definition at line 478 of file ZDCPulseAnalyzer.cxx.

479 {
480  if (tmax < m_tmin) {
481  (*m_msgFunc_p)(ZDCMsg::Error, ("ZDCPulseAnalyzer::SetFitTimeMax:: invalid FitTimeMax: " + std::to_string(tmax)));
482  return;
483  }
484 
485  m_defaultFitTMax = std::min(tmax, m_defaultFitTMax);
486 
487  if (m_initializedFits) SetupFitFunctions();
488 }

◆ SetGainFactorsHGLG()

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

Definition at line 445 of file ZDCPulseAnalyzer.cxx.

446 {
447  m_gainFactorHG = gainFactorHG;
448  m_gainFactorLG = gainFactorLG;
449 }

◆ setLGMode()

void ZDCPulseAnalyzer::setLGMode ( unsigned int  mode)
inline

Definition at line 507 of file ZDCPulseAnalyzer.h.

507 {m_LGMode = mode;}

◆ setMinimumSignificance()

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

Definition at line 438 of file ZDCPulseAnalyzer.cxx.

439 {
440  m_haveSignifCuts = true;
441  m_sigMinHG = sigMinHG;
442  m_sigMinLG = sigMinLG;
443 }

◆ SetNoiseSigmas()

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

Definition at line 516 of file ZDCPulseAnalyzer.h.

517  {
518  m_noiseSigHG = noiseSigHG;
519  m_noiseSigLG = noiseSigLG;
520  }

◆ SetNonlinCorrParams()

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

Definition at line 547 of file ZDCPulseAnalyzer.h.

548  {
549  std::string HGParamsStr = "HG coefficients = ", LGParamsStr = "LG coefficients = ";
550 
551  for (auto val : paramsHG) {HGParamsStr += std::to_string(val) + " ";}
552  for (auto val : paramsLG) {LGParamsStr += std::to_string(val) + " ";}
553 
554  (*m_msgFunc_p)(ZDCMsg::Info, ("Setting non-linear parameters for module: " + m_tag + ", reference ADC = " +
555  std::to_string(refADC) + ", reference scale = " + std::to_string(refScale)));
556 
557  (*m_msgFunc_p)(ZDCMsg::Info, std::move(HGParamsStr));
558  (*m_msgFunc_p)(ZDCMsg::Info, std::move(LGParamsStr));
559 
560  m_nonLinCorrRefADC = refADC;
561  m_nonLinCorrRefScale = refScale;
562  m_nonLinCorrParamsHG = paramsHG;
563  m_nonLinCorrParamsLG = paramsLG;
564  m_haveNonlinCorr = true;
565  }

◆ SetPeak2ndDerivMinTolerance()

void ZDCPulseAnalyzer::SetPeak2ndDerivMinTolerance ( size_t  tolerance)
inline

Definition at line 502 of file ZDCPulseAnalyzer.h.

502  {
503  m_peak2ndDerivMinTolerance = tolerance;
504  m_initializedFits = false;
505  }

◆ setQuietFits()

void ZDCPulseAnalyzer::setQuietFits ( )
inline

Definition at line 475 of file ZDCPulseAnalyzer.h.

475 {m_quietFits = true;}

◆ SetTauT0Values()

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

Definition at line 460 of file ZDCPulseAnalyzer.cxx.

461 {
462  m_fixTau1 = fixTau1;
463  m_fixTau2 = fixTau2;
464  m_nominalTau1 = tau1;
465  m_nominalTau2 = tau2;
466 
467  m_nominalT0HG = t0HG;
468  m_nominalT0LG = t0LG;
469 
470  std::ostringstream ostrm;
471  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;
472 
473  (*m_msgFunc_p)(ZDCMsg::Info, ostrm.str());
474 
475  m_initializedFits = false;
476 }

◆ SetTimingCorrParams()

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

Definition at line 532 of file ZDCPulseAnalyzer.h.

534  {
535  m_timingCorrMode = mode;
536  if (mode != NoTimingCorr) {
537  m_timingCorrRefADC = refADC;
538  m_timingCorrScale = refScale;
539 
540  m_HGT0CorrParams = HGT0CorrParams;
541  m_LGT0CorrParams = LGT0CorrParams;
542  }
543  }

◆ setUnquietFits()

void ZDCPulseAnalyzer::setUnquietFits ( )
inline

Definition at line 476 of file ZDCPulseAnalyzer.h.

476 {m_quietFits = false;}

◆ SetupFitFunctions()

void ZDCPulseAnalyzer::SetupFitFunctions ( )
private

Definition at line 651 of file ZDCPulseAnalyzer.cxx.

652 {
653  float prePulseTMin = 0;
654  float prePulseTMax = prePulseTMin + m_deltaTSample * (m_peak2ndDerivMinSample - m_peak2ndDerivMinTolerance);
655 
656  if (m_fitFunction == "FermiExp") {
657  if (!m_fixTau1 || !m_fixTau2) {
658  //
659  // Use the variable tau version of the expFermiFit
660  //
661  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
662  }
663  else {
664  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
665  }
666 
667  m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, m_nominalTau2, false));
668  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
669  }
670  else if (m_fitFunction == "FermiExpRun3") {
671  if (!m_fixTau1 || !m_fixTau2) {
672  //
673  // Use the variable tau version of the expFermiFit
674  //
675  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTausRun3(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
676  }
677  else {
678  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
679  }
680 
681  m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
682  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
683  }
684  else if (m_fitFunction == "FermiExpLHCf") {
685  //
686  // Use the variable tau version of the expFermiFit
687  //
688  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTausLHCf(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2,
689  m_nominalTau1, m_nominalTau2));
690 
691  m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiLHCfPreExp>(new ZDCFitExpFermiLHCfPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
692 
693  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiLHCfPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
694  }
695  else if (m_fitFunction == "FermiExpLinear") {
696  if (!m_fixTau1 || !m_fixTau2) {
697  //
698  // Use the variable tau version of the expFermiFit
699  //
700  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
701  }
702  else {
703  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
704  }
705 
706  m_preExpFitWrapper = std::unique_ptr<ZDCFitExpFermiPreExp>(new ZDCFitExpFermiPreExp(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2, 6, false));
707  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitExpFermiLinearPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
708  }
709  else if (m_fitFunction == "ComplexPrePulse") {
710  if (!m_fixTau1 || !m_fixTau2) {
711  //
712  // Use the variable tau version of the expFermiFit
713  //
714  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
715  }
716  else {
717  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
718  }
719 
720  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitComplexPrePulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
721  }
722  else if (m_fitFunction == "GeneralPulse") {
723  if (!m_fixTau1 || !m_fixTau2) {
724  //
725  // Use the variable tau version of the expFermiFit
726  //
727  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiVariableTaus(m_tag, m_tmin, m_tmax, m_fixTau1, m_fixTau2, m_nominalTau1, m_nominalTau2));
728  }
729  else {
730  m_defaultFitWrapper = std::unique_ptr<ZDCFitWrapper>(new ZDCFitExpFermiLinearFixedTaus(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
731  }
732 
733  m_prePulseFitWrapper = std::unique_ptr<ZDCPrePulseFitWrapper>(new ZDCFitGeneralPulse(m_tag, m_tmin, m_tmax, m_nominalTau1, m_nominalTau2));
734  }
735  else {
736  (*m_msgFunc_p)(ZDCMsg::Fatal, "Wrong fit function type: " + m_fitFunction);
737  }
738 
739  m_prePulseFitWrapper->SetPrePulseT0Range(prePulseTMin, prePulseTMax);
740 
741  m_initializedFits = true;
742 }

◆ UpdateFitterTimeLimits()

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

Definition at line 2067 of file ZDCPulseAnalyzer.cxx.

2068 {
2069  double parLimitLow, parLimitHigh;
2070 
2071  auto func_p = wrapper->GetWrapperTF1();
2072  func_p->GetParLimits(1, parLimitLow, parLimitHigh);
2073 
2074  fitter->SetParameter(2, func_p->GetParName(1), func_p->GetParameter(1), 0.01, parLimitLow, parLimitHigh);
2075 
2076  if (prePulse) {
2077  unsigned int parIndex = static_cast<ZDCPrePulseFitWrapper*>(wrapper)->GetPreT0ParIndex();
2078 
2079  func_p->GetParLimits(parIndex, parLimitLow, parLimitHigh);
2080  fitter->SetParameter(parIndex + 1, func_p->GetParName(parIndex), func_p->GetParameter(parIndex), 0.01, parLimitLow, parLimitHigh);
2081  }
2082 }

◆ useLowGain()

bool ZDCPulseAnalyzer::useLowGain ( ) const
inline

Definition at line 586 of file ZDCPulseAnalyzer.h.

586 {return m_useLowGain;}

◆ ValidateJSONConfig()

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

Definition at line 2400 of file ZDCPulseAnalyzer.cxx.

2401 {
2402  bool result = true;
2403  std::string resultString = "success";
2404 
2405  for (auto [key, descr] : JSONConfigParams) {
2406  auto iter = config.find(key);
2407  if (iter != config.end()) {
2408  //
2409  // Check type consistency
2410  //
2411  auto jsonType = iter.value().type();
2412  auto paramType = std::get<0>(descr);
2413  if (jsonType != paramType) {
2414  result = false;
2415  resultString = "Bad type for parameter " + key + ", type in JSON = " + std::to_string((unsigned int) jsonType) ;
2416  break;
2417  }
2418 
2419  size_t paramSize = std::get<1>(descr);
2420  size_t jsonSize = iter.value().size();
2421  if (jsonSize != paramSize) {
2422  result = false;
2423  resultString = "Bad length for parameter " + key + ", length in JSON = " + std::to_string(jsonSize) ;
2424  break;
2425  }
2426  }
2427  else {
2428  bool required = std::get<2>(descr);
2429  if (required) {
2430  result = false;
2431  resultString = "Missing required parameter " + key;
2432  break;
2433  }
2434  }
2435  }
2436 
2437  if (result) {
2438  //
2439  // Now check that the parameters in the JSON object are in the master list of parameters
2440  //
2441  for (auto [key, value] : config.items()) {
2442  //
2443  // Look for this key in the list of allowed parameters. Yes, it's a slow
2444  // search but we only do it once at configuration time.
2445  //
2446  // bool found = false;
2447  auto iter = JSONConfigParams.find(key);
2448  if (iter == JSONConfigParams.end()) {
2449  result = false;
2450  resultString = "Unknown parameter, key = " + key;
2451  break;
2452  }
2453  }
2454  }
2455 
2456  return {result, resultString};
2457 }

Member Data Documentation

◆ JSONConfigParams

const ZDCJSONConfig::JSONParamList ZDCPulseAnalyzer::JSONConfigParams
static

Definition at line 71 of file ZDCPulseAnalyzer.h.

◆ m_2ndDerivStep

size_t ZDCPulseAnalyzer::m_2ndDerivStep {1}
private

Definition at line 101 of file ZDCPulseAnalyzer.h.

◆ m_ADCPeakHG

float ZDCPulseAnalyzer::m_ADCPeakHG {}
private

Definition at line 281 of file ZDCPulseAnalyzer.h.

◆ m_ADCPeakLG

float ZDCPulseAnalyzer::m_ADCPeakLG {}
private

Definition at line 282 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHG
private

Definition at line 344 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesHGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesHGSub
private

Definition at line 346 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLG
private

Definition at line 345 of file ZDCPulseAnalyzer.h.

◆ m_ADCSamplesLGSub

std::vector<float> ZDCPulseAnalyzer::m_ADCSamplesLGSub
private

Definition at line 347 of file ZDCPulseAnalyzer.h.

◆ m_ADCSSampSigHG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigHG
private

Definition at line 352 of file ZDCPulseAnalyzer.h.

◆ m_ADCSSampSigLG

std::vector<float> ZDCPulseAnalyzer::m_ADCSSampSigLG
private

Definition at line 353 of file ZDCPulseAnalyzer.h.

◆ m_adjTimeRangeEvent

bool ZDCPulseAnalyzer::m_adjTimeRangeEvent {false}
private

Definition at line 212 of file ZDCPulseAnalyzer.h.

◆ m_ampError

float ZDCPulseAnalyzer::m_ampError {}
private

Definition at line 323 of file ZDCPulseAnalyzer.h.

◆ m_amplitude

float ZDCPulseAnalyzer::m_amplitude {}
private

Definition at line 321 of file ZDCPulseAnalyzer.h.

◆ m_ampNoNonLin

float ZDCPulseAnalyzer::m_ampNoNonLin {}
private

Definition at line 322 of file ZDCPulseAnalyzer.h.

◆ m_backToHG_pre

bool ZDCPulseAnalyzer::m_backToHG_pre {}
private

Definition at line 263 of file ZDCPulseAnalyzer.h.

◆ m_badChisq

bool ZDCPulseAnalyzer::m_badChisq {}
private

Definition at line 249 of file ZDCPulseAnalyzer.h.

◆ m_badT0

bool ZDCPulseAnalyzer::m_badT0 {}
private

Definition at line 251 of file ZDCPulseAnalyzer.h.

◆ m_baselineCorr

float ZDCPulseAnalyzer::m_baselineCorr {}
private

Definition at line 264 of file ZDCPulseAnalyzer.h.

◆ m_bkgdMaxFraction

float ZDCPulseAnalyzer::m_bkgdMaxFraction {}
private

Definition at line 328 of file ZDCPulseAnalyzer.h.

◆ m_chisqDivAmpCutHG

float ZDCPulseAnalyzer::m_chisqDivAmpCutHG {}
private

Definition at line 143 of file ZDCPulseAnalyzer.h.

◆ m_chisqDivAmpCutLG

float ZDCPulseAnalyzer::m_chisqDivAmpCutLG {}
private

Definition at line 142 of file ZDCPulseAnalyzer.h.

◆ m_defaultCombinedFitter

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

Definition at line 226 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitTMax

float ZDCPulseAnalyzer::m_defaultFitTMax {}
private

Definition at line 139 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitTMin

float ZDCPulseAnalyzer::m_defaultFitTMin {}
private

Definition at line 140 of file ZDCPulseAnalyzer.h.

◆ m_defaultFitWrapper

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

Definition at line 206 of file ZDCPulseAnalyzer.h.

◆ m_defaultT0Max

float ZDCPulseAnalyzer::m_defaultT0Max {}
private

Definition at line 156 of file ZDCPulseAnalyzer.h.

◆ m_defaultT0Min

float ZDCPulseAnalyzer::m_defaultT0Min {}
private

Definition at line 157 of file ZDCPulseAnalyzer.h.

◆ m_delayedBaselineShift

float ZDCPulseAnalyzer::m_delayedBaselineShift {}
private

Definition at line 329 of file ZDCPulseAnalyzer.h.

◆ m_delayedDeltaT

float ZDCPulseAnalyzer::m_delayedDeltaT {}
private

Definition at line 220 of file ZDCPulseAnalyzer.h.

◆ m_delayedHist

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

Definition at line 222 of file ZDCPulseAnalyzer.h.

◆ m_delayedHistLGRefit

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

Definition at line 223 of file ZDCPulseAnalyzer.h.

◆ m_delayedPedestalDiff

float ZDCPulseAnalyzer::m_delayedPedestalDiff {}
private

Definition at line 221 of file ZDCPulseAnalyzer.h.

◆ m_deltaTSample

float ZDCPulseAnalyzer::m_deltaTSample {}
private

Definition at line 94 of file ZDCPulseAnalyzer.h.

◆ m_enablePostExcl

bool ZDCPulseAnalyzer::m_enablePostExcl {false}
private

Definition at line 176 of file ZDCPulseAnalyzer.h.

◆ m_enablePreExcl

bool ZDCPulseAnalyzer::m_enablePreExcl {false}
private

Definition at line 171 of file ZDCPulseAnalyzer.h.

◆ m_enableRepass

bool ZDCPulseAnalyzer::m_enableRepass {false}
private

Definition at line 109 of file ZDCPulseAnalyzer.h.

◆ m_evtLGRefit

bool ZDCPulseAnalyzer::m_evtLGRefit {false}
private

Definition at line 331 of file ZDCPulseAnalyzer.h.

◆ m_ExcludeEarly

bool ZDCPulseAnalyzer::m_ExcludeEarly {}
private

Definition at line 252 of file ZDCPulseAnalyzer.h.

◆ m_ExcludeLate

bool ZDCPulseAnalyzer::m_ExcludeLate {}
private

Definition at line 253 of file ZDCPulseAnalyzer.h.

◆ m_expAmplitude

float ZDCPulseAnalyzer::m_expAmplitude {}
private

Definition at line 327 of file ZDCPulseAnalyzer.h.

◆ m_fadcCorrFileName

std::string ZDCPulseAnalyzer::m_fadcCorrFileName
private

Definition at line 195 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrHG

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

Definition at line 197 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrLG

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

Definition at line 198 of file ZDCPulseAnalyzer.h.

◆ m_FADCCorrPerSample

bool ZDCPulseAnalyzer::m_FADCCorrPerSample {false}
private

Definition at line 196 of file ZDCPulseAnalyzer.h.

◆ m_fail

bool ZDCPulseAnalyzer::m_fail {}
private

Definition at line 238 of file ZDCPulseAnalyzer.h.

◆ m_failSigCut

bool ZDCPulseAnalyzer::m_failSigCut {}
private

Definition at line 259 of file ZDCPulseAnalyzer.h.

◆ m_firstHGOverFlowSample

int ZDCPulseAnalyzer::m_firstHGOverFlowSample {-1}
private

Definition at line 341 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpError

float ZDCPulseAnalyzer::m_fitAmpError {}
private

Definition at line 306 of file ZDCPulseAnalyzer.h.

◆ m_fitAmplitude

float ZDCPulseAnalyzer::m_fitAmplitude {}
private

Definition at line 305 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMaxHG

float ZDCPulseAnalyzer::m_fitAmpMaxHG {}
private

Definition at line 162 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMaxLG

float ZDCPulseAnalyzer::m_fitAmpMaxLG {}
private

Definition at line 163 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMinHG

float ZDCPulseAnalyzer::m_fitAmpMinHG {}
private

Definition at line 159 of file ZDCPulseAnalyzer.h.

◆ m_fitAmpMinLG

float ZDCPulseAnalyzer::m_fitAmpMinLG {}
private

Definition at line 160 of file ZDCPulseAnalyzer.h.

◆ m_fitChisq

float ZDCPulseAnalyzer::m_fitChisq {}
private

Definition at line 314 of file ZDCPulseAnalyzer.h.

◆ m_fitExpAmp

float ZDCPulseAnalyzer::m_fitExpAmp {}
private

Definition at line 320 of file ZDCPulseAnalyzer.h.

◆ m_fitFailed

bool ZDCPulseAnalyzer::m_fitFailed {}
private

Definition at line 248 of file ZDCPulseAnalyzer.h.

◆ m_fitFunction

std::string ZDCPulseAnalyzer::m_fitFunction {}
private

Definition at line 100 of file ZDCPulseAnalyzer.h.

◆ m_fitHist

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

Definition at line 202 of file ZDCPulseAnalyzer.h.

◆ m_fitHistLGRefit

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

Definition at line 203 of file ZDCPulseAnalyzer.h.

◆ m_fitMinAmp

bool ZDCPulseAnalyzer::m_fitMinAmp {}
private

Definition at line 257 of file ZDCPulseAnalyzer.h.

◆ m_fitNDoF

float ZDCPulseAnalyzer::m_fitNDoF {}
private

Definition at line 315 of file ZDCPulseAnalyzer.h.

◆ m_fitOptions

std::string ZDCPulseAnalyzer::m_fitOptions {}
private

Definition at line 125 of file ZDCPulseAnalyzer.h.

◆ m_fitPostAmp

float ZDCPulseAnalyzer::m_fitPostAmp {}
private

Definition at line 319 of file ZDCPulseAnalyzer.h.

◆ m_fitPostT0

float ZDCPulseAnalyzer::m_fitPostT0 {}
private

Definition at line 318 of file ZDCPulseAnalyzer.h.

◆ m_fitPostT0lo

float ZDCPulseAnalyzer::m_fitPostT0lo {}
private

Definition at line 294 of file ZDCPulseAnalyzer.h.

◆ m_fitPreAmp

float ZDCPulseAnalyzer::m_fitPreAmp {}
private

Definition at line 317 of file ZDCPulseAnalyzer.h.

◆ m_fitPreT0

float ZDCPulseAnalyzer::m_fitPreT0 {}
private

Definition at line 316 of file ZDCPulseAnalyzer.h.

◆ m_fitPulls

std::vector<float> ZDCPulseAnalyzer::m_fitPulls
private

Definition at line 368 of file ZDCPulseAnalyzer.h.

◆ m_fitTau1

float ZDCPulseAnalyzer::m_fitTau1 {}
private

Definition at line 312 of file ZDCPulseAnalyzer.h.

◆ m_fitTau2

float ZDCPulseAnalyzer::m_fitTau2 {}
private

Definition at line 313 of file ZDCPulseAnalyzer.h.

◆ m_fitTCorr2nd

float ZDCPulseAnalyzer::m_fitTCorr2nd {}
private

Definition at line 311 of file ZDCPulseAnalyzer.h.

◆ m_fitTime

float ZDCPulseAnalyzer::m_fitTime {}
private

Definition at line 307 of file ZDCPulseAnalyzer.h.

◆ m_fitTimeCorr

float ZDCPulseAnalyzer::m_fitTimeCorr {}
private

Definition at line 309 of file ZDCPulseAnalyzer.h.

◆ m_fitTimeSub

float ZDCPulseAnalyzer::m_fitTimeSub {}
private

Definition at line 308 of file ZDCPulseAnalyzer.h.

◆ m_fitTMax

float ZDCPulseAnalyzer::m_fitTMax {}
private

Definition at line 291 of file ZDCPulseAnalyzer.h.

◆ m_fitTMin

float ZDCPulseAnalyzer::m_fitTMin {}
private

Definition at line 292 of file ZDCPulseAnalyzer.h.

◆ m_fixPrePulse

bool ZDCPulseAnalyzer::m_fixPrePulse {}
private

Definition at line 256 of file ZDCPulseAnalyzer.h.

◆ m_fixTau1

bool ZDCPulseAnalyzer::m_fixTau1 {}
private

Definition at line 136 of file ZDCPulseAnalyzer.h.

◆ m_fixTau2

bool ZDCPulseAnalyzer::m_fixTau2 {}
private

Definition at line 137 of file ZDCPulseAnalyzer.h.

◆ m_freqMHz

float ZDCPulseAnalyzer::m_freqMHz {}
private

Definition at line 93 of file ZDCPulseAnalyzer.h.

◆ m_gainFactorHG

float ZDCPulseAnalyzer::m_gainFactorHG {}
private

Definition at line 115 of file ZDCPulseAnalyzer.h.

◆ m_gainFactorLG

float ZDCPulseAnalyzer::m_gainFactorLG {}
private

Definition at line 116 of file ZDCPulseAnalyzer.h.

◆ m_haveData

bool ZDCPulseAnalyzer::m_haveData {}
private

Definition at line 234 of file ZDCPulseAnalyzer.h.

◆ m_haveFADCCorrections

bool ZDCPulseAnalyzer::m_haveFADCCorrections {false}
private

Definition at line 194 of file ZDCPulseAnalyzer.h.

◆ m_haveNonlinCorr

bool ZDCPulseAnalyzer::m_haveNonlinCorr {false}
private

Definition at line 188 of file ZDCPulseAnalyzer.h.

◆ m_havePulse

bool ZDCPulseAnalyzer::m_havePulse {}
private

Definition at line 236 of file ZDCPulseAnalyzer.h.

◆ m_haveSignifCuts

bool ZDCPulseAnalyzer::m_haveSignifCuts {false}
private

Definition at line 165 of file ZDCPulseAnalyzer.h.

◆ m_HGOverflow

bool ZDCPulseAnalyzer::m_HGOverflow {}
private

Definition at line 239 of file ZDCPulseAnalyzer.h.

◆ m_HGOverflowADC

int ZDCPulseAnalyzer::m_HGOverflowADC {}
private

Definition at line 126 of file ZDCPulseAnalyzer.h.

◆ m_HGT0CorrParams

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

Definition at line 186 of file ZDCPulseAnalyzer.h.

◆ m_HGUnderflow

bool ZDCPulseAnalyzer::m_HGUnderflow {}
private

Definition at line 241 of file ZDCPulseAnalyzer.h.

◆ m_HGUnderflowADC

int ZDCPulseAnalyzer::m_HGUnderflowADC {}
private

Definition at line 127 of file ZDCPulseAnalyzer.h.

◆ m_initialExpAmp

float ZDCPulseAnalyzer::m_initialExpAmp {}
private

Definition at line 287 of file ZDCPulseAnalyzer.h.

◆ m_initializedFits

bool ZDCPulseAnalyzer::m_initializedFits {false}
private

Definition at line 205 of file ZDCPulseAnalyzer.h.

◆ m_initialPostPulseT0

float ZDCPulseAnalyzer::m_initialPostPulseT0 {}
private

Definition at line 303 of file ZDCPulseAnalyzer.h.

◆ m_initialPrePulseAmp

float ZDCPulseAnalyzer::m_initialPrePulseAmp {}
private

Definition at line 301 of file ZDCPulseAnalyzer.h.

◆ m_initialPrePulseT0

float ZDCPulseAnalyzer::m_initialPrePulseT0 {}
private

Definition at line 300 of file ZDCPulseAnalyzer.h.

◆ m_lastHGOverFlowSample

int ZDCPulseAnalyzer::m_lastHGOverFlowSample {-1}
private

Definition at line 340 of file ZDCPulseAnalyzer.h.

◆ m_LGMode

unsigned int ZDCPulseAnalyzer::m_LGMode {LGModeNormal}
private

Definition at line 96 of file ZDCPulseAnalyzer.h.

◆ m_LGOverflow

bool ZDCPulseAnalyzer::m_LGOverflow {}
private

Definition at line 243 of file ZDCPulseAnalyzer.h.

◆ m_LGOverflowADC

int ZDCPulseAnalyzer::m_LGOverflowADC {}
private

Definition at line 128 of file ZDCPulseAnalyzer.h.

◆ m_LGT0CorrParams

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

Definition at line 185 of file ZDCPulseAnalyzer.h.

◆ m_LGUnderflow

bool ZDCPulseAnalyzer::m_LGUnderflow {}
private

Definition at line 244 of file ZDCPulseAnalyzer.h.

◆ m_maxADCHG

float ZDCPulseAnalyzer::m_maxADCHG {}
private

Definition at line 272 of file ZDCPulseAnalyzer.h.

◆ m_maxADCLG

float ZDCPulseAnalyzer::m_maxADCLG {}
private

Definition at line 276 of file ZDCPulseAnalyzer.h.

◆ m_maxADCSampleHG

int ZDCPulseAnalyzer::m_maxADCSampleHG
private

Definition at line 274 of file ZDCPulseAnalyzer.h.

◆ m_maxADCSampleLG

int ZDCPulseAnalyzer::m_maxADCSampleLG
private

Definition at line 279 of file ZDCPulseAnalyzer.h.

◆ m_maxDelta

float ZDCPulseAnalyzer::m_maxDelta {}
private

Definition at line 284 of file ZDCPulseAnalyzer.h.

◆ m_maxSampleEvt

unsigned int ZDCPulseAnalyzer::m_maxSampleEvt {}
private

Definition at line 215 of file ZDCPulseAnalyzer.h.

◆ m_maxSamplesPostExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPostExcl {0}
private

Definition at line 179 of file ZDCPulseAnalyzer.h.

◆ m_maxSamplesPreExcl

unsigned int ZDCPulseAnalyzer::m_maxSamplesPreExcl {0}
private

Definition at line 172 of file ZDCPulseAnalyzer.h.

◆ m_minADCHG

float ZDCPulseAnalyzer::m_minADCHG {}
private

Definition at line 271 of file ZDCPulseAnalyzer.h.

◆ m_minADCLG

float ZDCPulseAnalyzer::m_minADCLG {}
private

Definition at line 277 of file ZDCPulseAnalyzer.h.

◆ m_minADCSampleHG

int ZDCPulseAnalyzer::m_minADCSampleHG
private

Definition at line 273 of file ZDCPulseAnalyzer.h.

◆ m_minADCSampleLG

int ZDCPulseAnalyzer::m_minADCSampleLG
private

Definition at line 278 of file ZDCPulseAnalyzer.h.

◆ m_minDelta

float ZDCPulseAnalyzer::m_minDelta {}
private

Definition at line 285 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2nd

float ZDCPulseAnalyzer::m_minDeriv2nd {}
private

Definition at line 288 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2ndIndex

int ZDCPulseAnalyzer::m_minDeriv2ndIndex {}
private

Definition at line 289 of file ZDCPulseAnalyzer.h.

◆ m_minDeriv2ndSig

float ZDCPulseAnalyzer::m_minDeriv2ndSig
private

Definition at line 296 of file ZDCPulseAnalyzer.h.

◆ m_minSampleEvt

unsigned int ZDCPulseAnalyzer::m_minSampleEvt {}
private

Definition at line 214 of file ZDCPulseAnalyzer.h.

◆ m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCPulseAnalyzer::m_msgFunc_p {}
private

Definition at line 89 of file ZDCPulseAnalyzer.h.

◆ m_noiseSigHG

float ZDCPulseAnalyzer::m_noiseSigHG {}
private

Definition at line 120 of file ZDCPulseAnalyzer.h.

◆ m_noiseSigLG

float ZDCPulseAnalyzer::m_noiseSigLG {}
private

Definition at line 121 of file ZDCPulseAnalyzer.h.

◆ m_nominalT0HG

float ZDCPulseAnalyzer::m_nominalT0HG {}
private

Definition at line 130 of file ZDCPulseAnalyzer.h.

◆ m_nominalT0LG

float ZDCPulseAnalyzer::m_nominalT0LG {}
private

Definition at line 131 of file ZDCPulseAnalyzer.h.

◆ m_nominalTau1

float ZDCPulseAnalyzer::m_nominalTau1 {}
private

Definition at line 133 of file ZDCPulseAnalyzer.h.

◆ m_nominalTau2

float ZDCPulseAnalyzer::m_nominalTau2 {}
private

Definition at line 134 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrParamsHG

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

Definition at line 191 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrParamsLG

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

Definition at line 192 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrRefADC

float ZDCPulseAnalyzer::m_nonLinCorrRefADC {500}
private

Definition at line 189 of file ZDCPulseAnalyzer.h.

◆ m_nonLinCorrRefScale

float ZDCPulseAnalyzer::m_nonLinCorrRefScale {100}
private

Definition at line 190 of file ZDCPulseAnalyzer.h.

◆ m_Nsample

unsigned int ZDCPulseAnalyzer::m_Nsample {}
private

Definition at line 91 of file ZDCPulseAnalyzer.h.

◆ m_NSamplesAna

unsigned int ZDCPulseAnalyzer::m_NSamplesAna {0}
private

Definition at line 343 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinRepassHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassHG {}
private

Definition at line 111 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinRepassLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinRepassLG {}
private

Definition at line 110 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinSample

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinSample {}
private

Definition at line 102 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinThreshHG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshHG {}
private

Definition at line 105 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinThreshLG

float ZDCPulseAnalyzer::m_peak2ndDerivMinThreshLG {}
private

Definition at line 104 of file ZDCPulseAnalyzer.h.

◆ m_peak2ndDerivMinTolerance

size_t ZDCPulseAnalyzer::m_peak2ndDerivMinTolerance {1}
private

Definition at line 103 of file ZDCPulseAnalyzer.h.

◆ m_pedestal

int ZDCPulseAnalyzer::m_pedestal {}
private

Definition at line 95 of file ZDCPulseAnalyzer.h.

◆ m_postAmplitude

float ZDCPulseAnalyzer::m_postAmplitude {}
private

Definition at line 326 of file ZDCPulseAnalyzer.h.

◆ m_postExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclHGADCThresh {0}
private

Definition at line 177 of file ZDCPulseAnalyzer.h.

◆ m_postExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_postExclLGADCThresh {0}
private

Definition at line 178 of file ZDCPulseAnalyzer.h.

◆ m_postPulse

bool ZDCPulseAnalyzer::m_postPulse {}
private

Definition at line 247 of file ZDCPulseAnalyzer.h.

◆ m_preAmplitude

float ZDCPulseAnalyzer::m_preAmplitude {}
private

Definition at line 325 of file ZDCPulseAnalyzer.h.

◆ m_preExclHGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclHGADCThresh {0}
private

Definition at line 173 of file ZDCPulseAnalyzer.h.

◆ m_preExclLGADCThresh

unsigned int ZDCPulseAnalyzer::m_preExclLGADCThresh {0}
private

Definition at line 174 of file ZDCPulseAnalyzer.h.

◆ m_preExpFitWrapper

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

Definition at line 208 of file ZDCPulseAnalyzer.h.

◆ m_preExpSig

float ZDCPulseAnalyzer::m_preExpSig
private

Definition at line 297 of file ZDCPulseAnalyzer.h.

◆ m_preExpTail

bool ZDCPulseAnalyzer::m_preExpTail {}
private

Definition at line 254 of file ZDCPulseAnalyzer.h.

◆ m_prePulse

bool ZDCPulseAnalyzer::m_prePulse {}
private

Definition at line 246 of file ZDCPulseAnalyzer.h.

◆ m_prePulseCombinedFitter

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

Definition at line 225 of file ZDCPulseAnalyzer.h.

◆ m_prePulseFitWrapper

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

Definition at line 207 of file ZDCPulseAnalyzer.h.

◆ m_prePulseSig

float ZDCPulseAnalyzer::m_prePulseSig
private

Definition at line 298 of file ZDCPulseAnalyzer.h.

◆ m_preSample

float ZDCPulseAnalyzer::m_preSample {}
private

Definition at line 269 of file ZDCPulseAnalyzer.h.

◆ m_preSampleAmp

float ZDCPulseAnalyzer::m_preSampleAmp {}
private

Definition at line 324 of file ZDCPulseAnalyzer.h.

◆ m_preSampleIdx

unsigned int ZDCPulseAnalyzer::m_preSampleIdx {}
private

Definition at line 92 of file ZDCPulseAnalyzer.h.

◆ m_PSHGOverUnderflow

bool ZDCPulseAnalyzer::m_PSHGOverUnderflow {}
private

Definition at line 242 of file ZDCPulseAnalyzer.h.

◆ m_quietFits

bool ZDCPulseAnalyzer::m_quietFits {}
private

Definition at line 77 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmpError

float ZDCPulseAnalyzer::m_refitLGAmpError {0}
private

Definition at line 335 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmpl

float ZDCPulseAnalyzer::m_refitLGAmpl {0}
private

Definition at line 332 of file ZDCPulseAnalyzer.h.

◆ m_refitLGAmplCorr

float ZDCPulseAnalyzer::m_refitLGAmplCorr {0}
private

Definition at line 334 of file ZDCPulseAnalyzer.h.

◆ m_refitLGChisq

float ZDCPulseAnalyzer::m_refitLGChisq {0}
private

Definition at line 336 of file ZDCPulseAnalyzer.h.

◆ m_refitLGFitAmpl

float ZDCPulseAnalyzer::m_refitLGFitAmpl {0}
private

Definition at line 333 of file ZDCPulseAnalyzer.h.

◆ m_refitLGTime

float ZDCPulseAnalyzer::m_refitLGTime {0}
private

Definition at line 337 of file ZDCPulseAnalyzer.h.

◆ m_refitLGTimeSub

float ZDCPulseAnalyzer::m_refitLGTimeSub {0}
private

Definition at line 338 of file ZDCPulseAnalyzer.h.

◆ m_repassPulse

bool ZDCPulseAnalyzer::m_repassPulse {}
private

Definition at line 258 of file ZDCPulseAnalyzer.h.

◆ m_samplesDeriv2nd

std::vector<float> ZDCPulseAnalyzer::m_samplesDeriv2nd
private

Definition at line 361 of file ZDCPulseAnalyzer.h.

◆ m_samplesLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesLGRefit
private

Definition at line 358 of file ZDCPulseAnalyzer.h.

◆ m_samplesSig

std::vector<float> ZDCPulseAnalyzer::m_samplesSig
private

Definition at line 356 of file ZDCPulseAnalyzer.h.

◆ m_samplesSigLGRefit

std::vector<float> ZDCPulseAnalyzer::m_samplesSigLGRefit
private

Definition at line 359 of file ZDCPulseAnalyzer.h.

◆ m_samplesSub

std::vector<float> ZDCPulseAnalyzer::m_samplesSub
private

Definition at line 355 of file ZDCPulseAnalyzer.h.

◆ m_saveFitFunc

bool ZDCPulseAnalyzer::m_saveFitFunc {}
private

Definition at line 78 of file ZDCPulseAnalyzer.h.

◆ m_sigMinHG

float ZDCPulseAnalyzer::m_sigMinHG {}
private

Definition at line 166 of file ZDCPulseAnalyzer.h.

◆ m_sigMinLG

float ZDCPulseAnalyzer::m_sigMinLG {}
private

Definition at line 167 of file ZDCPulseAnalyzer.h.

◆ m_T0CutHighHG

float ZDCPulseAnalyzer::m_T0CutHighHG {}
private

Definition at line 149 of file ZDCPulseAnalyzer.h.

◆ m_T0CutHighLG

float ZDCPulseAnalyzer::m_T0CutHighLG {}
private

Definition at line 146 of file ZDCPulseAnalyzer.h.

◆ m_T0CutLowHG

float ZDCPulseAnalyzer::m_T0CutLowHG {}
private

Definition at line 148 of file ZDCPulseAnalyzer.h.

◆ m_T0CutLowLG

float ZDCPulseAnalyzer::m_T0CutLowLG {}
private

Definition at line 145 of file ZDCPulseAnalyzer.h.

◆ m_t0CutSig

float ZDCPulseAnalyzer::m_t0CutSig {}
private

Definition at line 153 of file ZDCPulseAnalyzer.h.

◆ m_tag

std::string ZDCPulseAnalyzer::m_tag {}
private

Definition at line 90 of file ZDCPulseAnalyzer.h.

◆ m_timeCutMode

unsigned int ZDCPulseAnalyzer::m_timeCutMode {0}
private

Definition at line 154 of file ZDCPulseAnalyzer.h.

◆ m_timeResFuncHG_p

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

Definition at line 151 of file ZDCPulseAnalyzer.h.

◆ m_timeResFuncLG_p

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

Definition at line 152 of file ZDCPulseAnalyzer.h.

◆ m_timeSig

float ZDCPulseAnalyzer::m_timeSig {}
private

Definition at line 310 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrMode

unsigned int ZDCPulseAnalyzer::m_timingCorrMode {NoTimingCorr}
private

Definition at line 182 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrRefADC

float ZDCPulseAnalyzer::m_timingCorrRefADC {500}
private

Definition at line 183 of file ZDCPulseAnalyzer.h.

◆ m_timingCorrScale

float ZDCPulseAnalyzer::m_timingCorrScale {100}
private

Definition at line 184 of file ZDCPulseAnalyzer.h.

◆ m_tmax

float ZDCPulseAnalyzer::m_tmax {}
private

Definition at line 98 of file ZDCPulseAnalyzer.h.

◆ m_tmin

float ZDCPulseAnalyzer::m_tmin {}
private

Definition at line 97 of file ZDCPulseAnalyzer.h.

◆ m_useDelayed

bool ZDCPulseAnalyzer::m_useDelayed {false}
private

Definition at line 107 of file ZDCPulseAnalyzer.h.

◆ m_usedPresampIdx

int ZDCPulseAnalyzer::m_usedPresampIdx {}
private

Definition at line 268 of file ZDCPulseAnalyzer.h.

◆ m_useFixedBaseline

bool ZDCPulseAnalyzer::m_useFixedBaseline {}
private

Definition at line 219 of file ZDCPulseAnalyzer.h.

◆ m_useLowGain

bool ZDCPulseAnalyzer::m_useLowGain {}
private

Definition at line 237 of file ZDCPulseAnalyzer.h.

◆ m_useSampleHG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleHG
private

Definition at line 350 of file ZDCPulseAnalyzer.h.

◆ m_useSampleLG

std::vector<bool> ZDCPulseAnalyzer::m_useSampleLG
private

Definition at line 349 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitFunc

TF1 * ZDCPulseAnalyzer::s_combinedFitFunc = nullptr
staticprivate

Definition at line 82 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitTMax

float ZDCPulseAnalyzer::s_combinedFitTMax = 1000
staticprivate

Definition at line 83 of file ZDCPulseAnalyzer.h.

◆ s_combinedFitTMin

float ZDCPulseAnalyzer::s_combinedFitTMin = -0.5
staticprivate

Definition at line 84 of file ZDCPulseAnalyzer.h.

◆ s_delayedFitHist

TH1 * ZDCPulseAnalyzer::s_delayedFitHist = nullptr
staticprivate

Definition at line 81 of file ZDCPulseAnalyzer.h.

◆ s_pullValues

std::vector< float > ZDCPulseAnalyzer::s_pullValues
staticprivate

Definition at line 85 of file ZDCPulseAnalyzer.h.

◆ s_undelayedFitHist

TH1 * ZDCPulseAnalyzer::s_undelayedFitHist = nullptr
staticprivate

Definition at line 80 of file ZDCPulseAnalyzer.h.

The documentation for this class was generated from the following files:
ZDCFitWrapper::GetAmplitude
virtual float GetAmplitude() const =0
ZDCPulseAnalyzer::PrePulseBit
@ PrePulseBit
Definition: ZDCPulseAnalyzer.h:38
ZDCPulseAnalyzer::SetupFitFunctions
void SetupFitFunctions()
Definition: ZDCPulseAnalyzer.cxx:651
ZDCPulseAnalyzer::m_LGOverflow
bool m_LGOverflow
Definition: ZDCPulseAnalyzer.h:243
ZDCPulseAnalyzer::m_fitTau2
float m_fitTau2
Definition: ZDCPulseAnalyzer.h:313
ZDCPulseAnalyzer::m_fitPostT0
float m_fitPostT0
Definition: ZDCPulseAnalyzer.h:318
ZDCPulseAnalyzer::m_defaultFitWrapper
std::unique_ptr< ZDCFitWrapper > m_defaultFitWrapper
Definition: ZDCPulseAnalyzer.h:206
covarianceTool.ndf
ndf
Definition: covarianceTool.py:678
ZDCPulseAnalyzer::m_failSigCut
bool m_failSigCut
Definition: ZDCPulseAnalyzer.h:259
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZDCPulseAnalyzer::m_defaultT0Max
float m_defaultT0Max
Definition: ZDCPulseAnalyzer.h:156
ZDCPulseAnalyzer::m_expAmplitude
float m_expAmplitude
Definition: ZDCPulseAnalyzer.h:327
ZDCPulseAnalyzer::m_minADCSampleLG
int m_minADCSampleLG
Definition: ZDCPulseAnalyzer.h:278
LArSamples::FitterData::fitter
const ShapeFitter * fitter
Definition: ShapeFitter.cxx:23
ZDCPulseAnalyzer::preExpTail
bool preExpTail() const
Definition: ZDCPulseAnalyzer.h:603
ZDCPulseAnalyzer::m_prePulseFitWrapper
std::unique_ptr< ZDCPrePulseFitWrapper > m_prePulseFitWrapper
Definition: ZDCPulseAnalyzer.h:207
ZDCPulseAnalyzer::m_useSampleHG
std::vector< bool > m_useSampleHG
Definition: ZDCPulseAnalyzer.h:350
ZDCPulseAnalyzer::m_enableRepass
bool m_enableRepass
Definition: ZDCPulseAnalyzer.h:109
ZDCPulseAnalyzer::m_ADCSamplesLG
std::vector< float > m_ADCSamplesLG
Definition: ZDCPulseAnalyzer.h:345
ZDCPulseAnalyzer::m_samplesSub
std::vector< float > m_samplesSub
Definition: ZDCPulseAnalyzer.h:355
ZDCPulseAnalyzer::m_fitPostAmp
float m_fitPostAmp
Definition: ZDCPulseAnalyzer.h:319
ZDCPulseAnalyzer::m_chisqDivAmpCutLG
float m_chisqDivAmpCutLG
Definition: ZDCPulseAnalyzer.h:142
ZDCPulseAnalyzer::m_NSamplesAna
unsigned int m_NSamplesAna
Definition: ZDCPulseAnalyzer.h:343
ZDCFitExpFermiVariableTausLHCf
Definition: ZDCFitWrapper.h:231
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ZDCPulseAnalyzer::m_HGOverflowADC
int m_HGOverflowADC
Definition: ZDCPulseAnalyzer.h:126
ZDCPulseAnalyzer::m_enablePreExcl
bool m_enablePreExcl
Definition: ZDCPulseAnalyzer.h:171
ZDCPulseAnalyzer::m_msgFunc_p
ZDCMsg::MessageFunctionPtr m_msgFunc_p
Definition: ZDCPulseAnalyzer.h:89
ZDCPulseAnalyzer::m_LGT0CorrParams
std::vector< float > m_LGT0CorrParams
Definition: ZDCPulseAnalyzer.h:185
tolerance
constexpr double tolerance
Definition: runMdtGeoComparison.cxx:104
get_generator_info.result
result
Definition: get_generator_info.py:21
ZDCPulseAnalyzer::m_fitAmplitude
float m_fitAmplitude
Definition: ZDCPulseAnalyzer.h:305
ZDCPulseAnalyzer::m_HGOverflow
bool m_HGOverflow
Definition: ZDCPulseAnalyzer.h:239
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
ZDCPulseAnalyzer::m_fitTau1
float m_fitTau1
Definition: ZDCPulseAnalyzer.h:312
ZDCPulseAnalyzer::m_useFixedBaseline
bool m_useFixedBaseline
Definition: ZDCPulseAnalyzer.h:219
ZDCPulseAnalyzer::RepassPulseBit
@ RepassPulseBit
Definition: ZDCPulseAnalyzer.h:49
ZDCPulseAnalyzer::m_postAmplitude
float m_postAmplitude
Definition: ZDCPulseAnalyzer.h:326
ZDCPulseAnalyzer::m_adjTimeRangeEvent
bool m_adjTimeRangeEvent
Definition: ZDCPulseAnalyzer.h:212
ZDCPulseAnalyzer::FillHistogram
void FillHistogram(bool refitLG)
Definition: ZDCPulseAnalyzer.h:404
ZDCPulseAnalyzer::m_haveFADCCorrections
bool m_haveFADCCorrections
Definition: ZDCPulseAnalyzer.h:194
ZDCPulseAnalyzer::m_minDeriv2nd
float m_minDeriv2nd
Definition: ZDCPulseAnalyzer.h:288
ZDCPrePulseFitWrapper
Definition: ZDCFitWrapper.h:116
ZDCPulseAnalyzer::m_FADCCorrHG
std::unique_ptr< const TH1 > m_FADCCorrHG
Definition: ZDCPulseAnalyzer.h:197
ZDCFitExpFermiFixedTaus
Definition: ZDCFitWrapper.h:298
ZDCPulseAnalyzer::m_peak2ndDerivMinThreshLG
float m_peak2ndDerivMinThreshLG
Definition: ZDCPulseAnalyzer.h:104
ZDCPulseAnalyzer::m_2ndDerivStep
size_t m_2ndDerivStep
Definition: ZDCPulseAnalyzer.h:101
ZDCPulseAnalyzer::m_quietFits
bool m_quietFits
Definition: ZDCPulseAnalyzer.h:77
ZDCPulseAnalyzer::m_nonLinCorrRefScale
float m_nonLinCorrRefScale
Definition: ZDCPulseAnalyzer.h:190
ZDCPulseAnalyzer::m_timeCutMode
unsigned int m_timeCutMode
Definition: ZDCPulseAnalyzer.h:154
ZDCPulseAnalyzer::GetHistogramPtr
const TH1 * GetHistogramPtr(bool refitLG=false)
Definition: ZDCPulseAnalyzer.h:715
ZDCPulseAnalyzer::MakeCombinedFitter
static std::unique_ptr< TFitter > MakeCombinedFitter(TF1 *func)
Definition: ZDCPulseAnalyzer.cxx:2029
ZDCPulseAnalyzer::m_fitAmpMaxHG
float m_fitAmpMaxHG
Definition: ZDCPulseAnalyzer.h:162
ZDCPulseAnalyzer::m_backToHG_pre
bool m_backToHG_pre
Definition: ZDCPulseAnalyzer.h:263
ZDCFitWrapper
Definition: ZDCFitWrapper.h:19
TRT::Track::chiSquare
@ chiSquare
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:67
ZDCPulseAnalyzer::FailSigCutBit
@ FailSigCutBit
Definition: ZDCPulseAnalyzer.h:51
ZDCPulseAnalyzer::m_refitLGAmpl
float m_refitLGAmpl
Definition: ZDCPulseAnalyzer.h:332
ZDCPulseAnalyzer::m_fitTimeSub
float m_fitTimeSub
Definition: ZDCPulseAnalyzer.h:308
ZDCPulseAnalyzer::m_delayedPedestalDiff
float m_delayedPedestalDiff
Definition: ZDCPulseAnalyzer.h:221
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ZDCPulseAnalyzer::ExcludeLateLGBit
@ ExcludeLateLGBit
Definition: ZDCPulseAnalyzer.h:45
ZDCPulseAnalyzer::DoFitCombined
void DoFitCombined(bool refitLG=false)
Definition: ZDCPulseAnalyzer.cxx:1726
ZDCFitWrapper::ConstrainFit
virtual void ConstrainFit()=0
ZDCPulseAnalyzer::m_sigMinHG
float m_sigMinHG
Definition: ZDCPulseAnalyzer.h:166
ZDCPulseAnalyzer::LGOverflow
bool LGOverflow() const
Definition: ZDCPulseAnalyzer.h:592
ZDCFitWrapper::GetTime
virtual float GetTime() const =0
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
ZDCPulseAnalyzer::m_timingCorrRefADC
float m_timingCorrRefADC
Definition: ZDCPulseAnalyzer.h:183
ZDCPulseAnalyzer::m_postPulse
bool m_postPulse
Definition: ZDCPulseAnalyzer.h:247
ZDCPulseAnalyzer::m_defaultCombinedFitter
std::unique_ptr< TFitter > m_defaultCombinedFitter
Definition: ZDCPulseAnalyzer.h:226
ZDCPulseAnalyzer::m_nominalT0HG
float m_nominalT0HG
Definition: ZDCPulseAnalyzer.h:130
ZDCPulseAnalyzer::m_minADCLG
float m_minADCLG
Definition: ZDCPulseAnalyzer.h:277
ZDCPulseAnalyzer::m_delayedHist
std::unique_ptr< TH1 > m_delayedHist
Definition: ZDCPulseAnalyzer.h:222
ZDCPulseAnalyzer::LGOverflowBit
@ LGOverflowBit
Definition: ZDCPulseAnalyzer.h:35
ZDCPulseAnalyzer::m_fitHistLGRefit
std::unique_ptr< TH1 > m_fitHistLGRefit
Definition: ZDCPulseAnalyzer.h:203
ZDCPulseAnalyzer::m_haveNonlinCorr
bool m_haveNonlinCorr
Definition: ZDCPulseAnalyzer.h:188
ZDCPulseAnalyzer::N_STATUS_BITS
@ N_STATUS_BITS
Definition: ZDCPulseAnalyzer.h:52
ZDCPulseAnalyzer::m_preExpTail
bool m_preExpTail
Definition: ZDCPulseAnalyzer.h:254
ZDCPulseAnalyzer::m_bkgdMaxFraction
float m_bkgdMaxFraction
Definition: ZDCPulseAnalyzer.h:328
ZDCPulseAnalyzer::m_tag
std::string m_tag
Definition: ZDCPulseAnalyzer.h:90
ZDCPulseAnalyzer::ScanAndSubtractSamples
bool ScanAndSubtractSamples()
Definition: ZDCPulseAnalyzer.cxx:833
ZDCFitExpFermiLinearPrePulse
Definition: ZDCFitWrapper.h:850
Root::AND
@ AND
Definition: TGRLCollection.h:32
ZDCPulseAnalyzer::m_sigMinLG
float m_sigMinLG
Definition: ZDCPulseAnalyzer.h:167
ZDCPulseAnalyzer::AnalyzeData
bool AnalyzeData(size_t nSamples, size_t preSample, const std::vector< float > &samples, const std::vector< bool > &useSamples, float peak2ndDerivMinThresh, float noiseSig, const std::vector< float > &toCorrParams, float maxChisqDivAmp, float minT0Corr, float maxT0Corr)
Definition: ZDCPulseAnalyzer.cxx:1123
athena.value
value
Definition: athena.py:124
ZDCPreExpFitWrapper
Definition: ZDCFitWrapper.h:144
ZDCPulseAnalyzer::m_prePulseSig
float m_prePulseSig
Definition: ZDCPulseAnalyzer.h:298
ZDCPulseAnalyzer::m_HGUnderflow
bool m_HGUnderflow
Definition: ZDCPulseAnalyzer.h:241
ZDCPulseAnalyzer::useLowGain
bool useLowGain() const
Definition: ZDCPulseAnalyzer.h:586
ZDCPulseAnalyzer::BadChisqBit
@ BadChisqBit
Definition: ZDCPulseAnalyzer.h:41
ZDCPulseAnalyzer::SetDefaults
void SetDefaults()
Definition: ZDCPulseAnalyzer.cxx:234
ZDCPulseAnalyzer::armSumInclude
bool armSumInclude() const
Definition: ZDCPulseAnalyzer.h:606
ZDCFitWrapper::GetWrapperTF1
virtual std::shared_ptr< TF1 > GetWrapperTF1()
Definition: ZDCFitWrapper.h:110
ZDCPulseAnalyzer::m_fixTau2
bool m_fixTau2
Definition: ZDCPulseAnalyzer.h:137
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ZDCPulseAnalyzer::m_defaultFitTMax
float m_defaultFitTMax
Definition: ZDCPulseAnalyzer.h:139
MuonR4::to_string
std::string to_string(const SectorProjector proj)
Definition: MsTrackSeeder.cxx:66
ZDCPulseAnalyzer::m_maxADCSampleHG
int m_maxADCSampleHG
Definition: ZDCPulseAnalyzer.h:274
ZDCPulseAnalyzer::m_delayedBaselineShift
float m_delayedBaselineShift
Definition: ZDCPulseAnalyzer.h:329
ZDCPulseAnalyzer::m_badT0
bool m_badT0
Definition: ZDCPulseAnalyzer.h:251
ZDCPulseAnalyzer::m_fitMinAmp
bool m_fitMinAmp
Definition: ZDCPulseAnalyzer.h:257
ZDCMsg::Info
@ Info
Definition: ZDCMsg.h:20
ZDCPulseAnalyzer::s_delayedFitHist
static TH1 * s_delayedFitHist
Definition: ZDCPulseAnalyzer.h:81
ZDCPulseAnalyzer::HGOverflowBit
@ HGOverflowBit
Definition: ZDCPulseAnalyzer.h:31
ReweightUtils.message
message
Definition: ReweightUtils.py:15
ZDCPulseAnalyzer::m_samplesDeriv2nd
std::vector< float > m_samplesDeriv2nd
Definition: ZDCPulseAnalyzer.h:361
ZDCFitExpFermiLHCfPreExp
Definition: ZDCFitWrapper.h:672
ZDCPulseAnalyzer::repassPulse
bool repassPulse() const
Definition: ZDCPulseAnalyzer.h:605
ZDCFitWrapper::GetTau2
virtual float GetTau2() const =0
ZDCPulseAnalyzer::m_haveData
bool m_haveData
Definition: ZDCPulseAnalyzer.h:234
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
ZDCPulseAnalyzer::badChisq
bool badChisq() const
Definition: ZDCPulseAnalyzer.h:598
ZDCPulseAnalyzer::HGOverflow
bool HGOverflow() const
Definition: ZDCPulseAnalyzer.h:588
ZDCPulseAnalyzer::m_maxADCSampleLG
int m_maxADCSampleLG
Definition: ZDCPulseAnalyzer.h:279
ZDCPulseAnalyzer::s_combinedFitFunc
static TF1 * s_combinedFitFunc
Definition: ZDCPulseAnalyzer.h:82
ZDCPulseAnalyzer::m_ADCPeakHG
float m_ADCPeakHG
Definition: ZDCPulseAnalyzer.h:281
ZDCPulseAnalyzer::m_nominalTau2
float m_nominalTau2
Definition: ZDCPulseAnalyzer.h:134
ZDCPulseAnalyzer::m_prePulse
bool m_prePulse
Definition: ZDCPulseAnalyzer.h:246
ZDCPulseAnalyzer::s_combinedFitTMin
static float s_combinedFitTMin
Definition: ZDCPulseAnalyzer.h:84
ZDCPulseAnalyzer::dumpConfiguration
void dumpConfiguration() const
Definition: ZDCPulseAnalyzer.cxx:2131
ZDCPulseAnalyzer::PulseBit
@ PulseBit
Definition: ZDCPulseAnalyzer.h:28
ZDCPulseAnalyzer::PSHGOverUnderflow
bool PSHGOverUnderflow() const
Definition: ZDCPulseAnalyzer.h:591
ZDCPulseAnalyzer::m_useSampleLG
std::vector< bool > m_useSampleLG
Definition: ZDCPulseAnalyzer.h:349
ZDCPulseAnalyzer::m_ampNoNonLin
float m_ampNoNonLin
Definition: ZDCPulseAnalyzer.h:322
ZDCPulseAnalyzer::m_fitFunction
std::string m_fitFunction
Definition: ZDCPulseAnalyzer.h:100
ZDCPulseAnalyzer::m_preExclHGADCThresh
unsigned int m_preExclHGADCThresh
Definition: ZDCPulseAnalyzer.h:173
ZDCPulseAnalyzer::m_pedestal
int m_pedestal
Definition: ZDCPulseAnalyzer.h:95
ZDCPulseAnalyzer::SampleCIter
std::vector< float >::const_iterator SampleCIter
Definition: ZDCPulseAnalyzer.h:73
ZDCPulseAnalyzer::m_fixPrePulse
bool m_fixPrePulse
Definition: ZDCPulseAnalyzer.h:256
ZDCPulseAnalyzer::m_fitPulls
std::vector< float > m_fitPulls
Definition: ZDCPulseAnalyzer.h:368
tools.zlumi_mc_cf.correction
def correction(mu, runmode, campaign, run=None)
Definition: zlumi_mc_cf.py:4
ZDCPulseAnalyzer::m_preSample
float m_preSample
Definition: ZDCPulseAnalyzer.h:269
ZDCPulseAnalyzer::TimingCorrLog
@ TimingCorrLog
Definition: ZDCPulseAnalyzer.h:61
ZDCPulseAnalyzer::m_fitOptions
std::string m_fitOptions
Definition: ZDCPulseAnalyzer.h:125
ZDCMsg::Verbose
@ Verbose
Definition: ZDCMsg.h:18
ZDCFitWrapper::UnconstrainFit
virtual void UnconstrainFit()=0
ZDCPulseAnalyzer::m_postExclHGADCThresh
unsigned int m_postExclHGADCThresh
Definition: ZDCPulseAnalyzer.h:177
ZDCPulseAnalyzer::m_minADCHG
float m_minADCHG
Definition: ZDCPulseAnalyzer.h:271
ZDCPulseAnalyzer::m_nominalT0LG
float m_nominalT0LG
Definition: ZDCPulseAnalyzer.h:131
ZDCPulseAnalyzer::m_fitAmpMinLG
float m_fitAmpMinLG
Definition: ZDCPulseAnalyzer.h:160
ZDCPulseAnalyzer::m_badChisq
bool m_badChisq
Definition: ZDCPulseAnalyzer.h:249
ZDCPulseAnalyzer::m_t0CutSig
float m_t0CutSig
Definition: ZDCPulseAnalyzer.h:153
ZDCPulseAnalyzer::m_saveFitFunc
bool m_saveFitFunc
Definition: ZDCPulseAnalyzer.h:78
ZDCFitWrapper::GetAmpError
virtual float GetAmpError() const =0
ZDCPulseAnalyzer::m_peak2ndDerivMinRepassHG
float m_peak2ndDerivMinRepassHG
Definition: ZDCPulseAnalyzer.h:111
ZDCPulseAnalyzer::m_initialPrePulseAmp
float m_initialPrePulseAmp
Definition: ZDCPulseAnalyzer.h:301
ZDCPulseAnalyzer::m_evtLGRefit
bool m_evtLGRefit
Definition: ZDCPulseAnalyzer.h:331
ZDCPulseAnalyzer::m_peak2ndDerivMinRepassLG
float m_peak2ndDerivMinRepassLG
Definition: ZDCPulseAnalyzer.h:110
ZDCPulseAnalyzer::m_fitPostT0lo
float m_fitPostT0lo
Definition: ZDCPulseAnalyzer.h:294
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
ZDCPulseAnalyzer::m_fixTau1
bool m_fixTau1
Definition: ZDCPulseAnalyzer.h:136
ZDCFitWrapper::GetWrapperTF1RawPtr
virtual TF1 * GetWrapperTF1RawPtr() const
Definition: ZDCFitWrapper.h:112
xmin
double xmin
Definition: listroot.cxx:60
ZDCPulseAnalyzer::m_fitTMax
float m_fitTMax
Definition: ZDCPulseAnalyzer.h:291
ZDCPulseAnalyzer::PostPulseBit
@ PostPulseBit
Definition: ZDCPulseAnalyzer.h:39
ZDCPulseAnalyzer::m_fitChisq
float m_fitChisq
Definition: ZDCPulseAnalyzer.h:314
ZDCPulseAnalyzer::CombinedPulsesFCN
static void CombinedPulsesFCN(int &numParam, double *, double &f, double *par, int flag)
Definition: ZDCPulseAnalyzer.cxx:84
ZDCPulseAnalyzer::m_noiseSigHG
float m_noiseSigHG
Definition: ZDCPulseAnalyzer.h:120
ZDCPulseAnalyzer::m_maxADCLG
float m_maxADCLG
Definition: ZDCPulseAnalyzer.h:276
ZDCPulseAnalyzer::excludeLateLG
bool excludeLateLG() const
Definition: ZDCPulseAnalyzer.h:602
ZDCPulseAnalyzer::m_fail
bool m_fail
Definition: ZDCPulseAnalyzer.h:238
ZDCPulseAnalyzer::m_fitPreAmp
float m_fitPreAmp
Definition: ZDCPulseAnalyzer.h:317
ZDCPulseAnalyzer::LGUnderflow
bool LGUnderflow() const
Definition: ZDCPulseAnalyzer.h:593
ZDCPulseAnalyzer::m_refitLGChisq
float m_refitLGChisq
Definition: ZDCPulseAnalyzer.h:336
master.flag
bool flag
Definition: master.py:29
ZDCPulseAnalyzer::m_deltaTSample
float m_deltaTSample
Definition: ZDCPulseAnalyzer.h:94
ZDCPulseAnalyzer::m_nonLinCorrParamsLG
std::vector< float > m_nonLinCorrParamsLG
Definition: ZDCPulseAnalyzer.h:192
ZDCPulseAnalyzer::m_gainFactorLG
float m_gainFactorLG
Definition: ZDCPulseAnalyzer.h:116
ZDCPulseAnalyzer::m_minSampleEvt
unsigned int m_minSampleEvt
Definition: ZDCPulseAnalyzer.h:214
ZDCPulseAnalyzer::m_noiseSigLG
float m_noiseSigLG
Definition: ZDCPulseAnalyzer.h:121
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
ZDCPulseAnalyzer::m_gainFactorHG
float m_gainFactorHG
Definition: ZDCPulseAnalyzer.h:115
ZDCPulseAnalyzer::m_fitFailed
bool m_fitFailed
Definition: ZDCPulseAnalyzer.h:248
ZDCPulseAnalyzer::fitFailed
bool fitFailed() const
Definition: ZDCPulseAnalyzer.h:597
ZDCPulseAnalyzer::m_maxSampleEvt
unsigned int m_maxSampleEvt
Definition: ZDCPulseAnalyzer.h:215
ZDCPulseAnalyzer::m_timingCorrScale
float m_timingCorrScale
Definition: ZDCPulseAnalyzer.h:184
ZDCPulseAnalyzer::m_initialExpAmp
float m_initialExpAmp
Definition: ZDCPulseAnalyzer.h:287
ZDCPulseAnalyzer::m_maxADCHG
float m_maxADCHG
Definition: ZDCPulseAnalyzer.h:272
ZDCPulseAnalyzer::m_freqMHz
float m_freqMHz
Definition: ZDCPulseAnalyzer.h:93
ZDCPulseAnalyzer::m_ADCSamplesHG
std::vector< float > m_ADCSamplesHG
Definition: ZDCPulseAnalyzer.h:344
ZDCPulseAnalyzer::LGModeForceLG
@ LGModeForceLG
Definition: ZDCPulseAnalyzer.h:57
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:309
ZDCPulseAnalyzer::m_T0CutLowHG
float m_T0CutLowHG
Definition: ZDCPulseAnalyzer.h:148
ZDCPulseAnalyzer::m_fitNDoF
float m_fitNDoF
Definition: ZDCPulseAnalyzer.h:315
Preparation.mode
mode
Definition: Preparation.py:107
add-xsec-uncert-quadrature-N.results
dictionary results
Definition: add-xsec-uncert-quadrature-N.py:39
ZDCFitWrapper::GetBkgdMaxFraction
virtual float GetBkgdMaxFraction() const =0
hist_file_dump.f
f
Definition: hist_file_dump.py:140
ZDCPulseAnalyzer::m_havePulse
bool m_havePulse
Definition: ZDCPulseAnalyzer.h:236
python.TransformConfig.descr
descr
print "%s.properties()" % self.__name__
Definition: TransformConfig.py:359
ZDCPulseAnalyzer::m_maxDelta
float m_maxDelta
Definition: ZDCPulseAnalyzer.h:284
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:378
ZDCPulseAnalyzer::m_refitLGAmplCorr
float m_refitLGAmplCorr
Definition: ZDCPulseAnalyzer.h:334
ZDCPulseAnalyzer::TimingCorrLin
@ TimingCorrLin
Definition: ZDCPulseAnalyzer.h:61
ZDCPulseAnalyzer::m_nonLinCorrRefADC
float m_nonLinCorrRefADC
Definition: ZDCPulseAnalyzer.h:189
ZDCPulseAnalyzer::m_T0CutHighLG
float m_T0CutHighLG
Definition: ZDCPulseAnalyzer.h:146
ZDCPulseAnalyzer::ConfigFromJSON
std::pair< bool, std::string > ConfigFromJSON(const JSON &config)
Definition: ZDCPulseAnalyzer.cxx:2459
ZDCFitExpFermiPrePulse
Definition: ZDCFitWrapper.h:361
ZDCPulseAnalyzer::m_ampError
float m_ampError
Definition: ZDCPulseAnalyzer.h:323
ZDCFitExpFermiVariableTaus
Definition: ZDCFitWrapper.h:164
ZDCPulseAnalyzer::m_ExcludeLate
bool m_ExcludeLate
Definition: ZDCPulseAnalyzer.h:253
ZDCPulseAnalyzer::m_preExclLGADCThresh
unsigned int m_preExclLGADCThresh
Definition: ZDCPulseAnalyzer.h:174
ZDCPulseAnalyzer::m_ADCPeakLG
float m_ADCPeakLG
Definition: ZDCPulseAnalyzer.h:282
ZDCPulseAnalyzer::m_refitLGFitAmpl
float m_refitLGFitAmpl
Definition: ZDCPulseAnalyzer.h:333
ZDCPulseAnalyzer::m_enablePostExcl
bool m_enablePostExcl
Definition: ZDCPulseAnalyzer.h:176
perfmonmt-printer.required
required
Definition: perfmonmt-printer.py:184
ZDCPulseAnalyzer::JSONConfigParams
static const ZDCJSONConfig::JSONParamList JSONConfigParams
Definition: ZDCPulseAnalyzer.h:71
ZDCPulseAnalyzer::preExpTailBit
@ preExpTailBit
Definition: ZDCPulseAnalyzer.h:46
ZDCPulseAnalyzer::obtainDelayedBaselineCorr
static float obtainDelayedBaselineCorr(const std::vector< float > &samples)
Definition: ZDCPulseAnalyzer.cxx:2343
ZDCPulseAnalyzer::m_ADCSamplesHGSub
std::vector< float > m_ADCSamplesHGSub
Definition: ZDCPulseAnalyzer.h:346
ZDCPulseAnalyzer::m_fitPreT0
float m_fitPreT0
Definition: ZDCPulseAnalyzer.h:316
ZDCPulseAnalyzer::m_useDelayed
bool m_useDelayed
Definition: ZDCPulseAnalyzer.h:107
ZDCMsg::Error
@ Error
Definition: ZDCMsg.h:22
ZDCPulseAnalyzer::HGUnderflow
bool HGUnderflow() const
Definition: ZDCPulseAnalyzer.h:590
ZDCPulseAnalyzer::m_LGMode
unsigned int m_LGMode
Definition: ZDCPulseAnalyzer.h:96
ZDCPulseAnalyzer::m_HGUnderflowADC
int m_HGUnderflowADC
Definition: ZDCPulseAnalyzer.h:127
ZDCPulseAnalyzer::checkTF1Limits
void checkTF1Limits(TF1 *func)
Definition: ZDCPulseAnalyzer.cxx:2000
ZDCPulseAnalyzer::m_useLowGain
bool m_useLowGain
Definition: ZDCPulseAnalyzer.h:237
ZDCPulseAnalyzer::LowGainBit
@ LowGainBit
Definition: ZDCPulseAnalyzer.h:29
ZDCPulseAnalyzer::m_ADCSSampSigLG
std::vector< float > m_ADCSSampSigLG
Definition: ZDCPulseAnalyzer.h:353
ZDCPulseAnalyzer::Calculate2ndDerivative
static std::vector< float > Calculate2ndDerivative(const std::vector< float > &inputData, unsigned int step)
Definition: ZDCPulseAnalyzer.cxx:2311
ZDCPulseAnalyzer::m_repassPulse
bool m_repassPulse
Definition: ZDCPulseAnalyzer.h:258
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:28
ZDCPulseAnalyzer::m_ExcludeEarly
bool m_ExcludeEarly
Definition: ZDCPulseAnalyzer.h:252
ZDCPulseAnalyzer::HGUnderflowBit
@ HGUnderflowBit
Definition: ZDCPulseAnalyzer.h:33
ZDCPulseAnalyzer::m_preSampleIdx
unsigned int m_preSampleIdx
Definition: ZDCPulseAnalyzer.h:92
ZDCPulseAnalyzer::m_delayedDeltaT
float m_delayedDeltaT
Definition: ZDCPulseAnalyzer.h:220
ZDCFitWrapper::Initialize
void Initialize(float initialAmp, float initialT0, float ampMin, float ampMax)
Definition: ZDCFitWrapper.cxx:9
ZDCPulseAnalyzer::m_preExpSig
float m_preExpSig
Definition: ZDCPulseAnalyzer.h:297
ZDCFitWrapper::GetTau1
virtual float GetTau1() const =0
ZDCPulseAnalyzer::m_timeResFuncLG_p
std::unique_ptr< const TF1 > m_timeResFuncLG_p
Definition: ZDCPulseAnalyzer.h:152
ZDCPulseAnalyzer::m_minDeriv2ndSig
float m_minDeriv2ndSig
Definition: ZDCPulseAnalyzer.h:296
ZDCPulseAnalyzer::m_fitTime
float m_fitTime
Definition: ZDCPulseAnalyzer.h:307
ZDCPulseAnalyzer::m_preExpFitWrapper
std::unique_ptr< ZDCPreExpFitWrapper > m_preExpFitWrapper
Definition: ZDCPulseAnalyzer.h:208
ZDCPulseAnalyzer::ArmSumIncludeBit
@ ArmSumIncludeBit
Definition: ZDCPulseAnalyzer.h:50
ZDCPulseAnalyzer::m_peak2ndDerivMinSample
size_t m_peak2ndDerivMinSample
Definition: ZDCPulseAnalyzer.h:102
ZDCPulseAnalyzer::m_delayedHistLGRefit
std::unique_ptr< TH1 > m_delayedHistLGRefit
Definition: ZDCPulseAnalyzer.h:223
ZDCPulseAnalyzer::failed
bool failed() const
Definition: ZDCPulseAnalyzer.h:587
ZDCFitComplexPrePulse
Definition: ZDCFitWrapper.h:963
ZDCPulseAnalyzer::m_usedPresampIdx
int m_usedPresampIdx
Definition: ZDCPulseAnalyzer.h:268
ZDCPulseAnalyzer::NoTimingCorr
@ NoTimingCorr
Definition: ZDCPulseAnalyzer.h:61
ZDCPulseAnalyzer::badT0
bool badT0() const
Definition: ZDCPulseAnalyzer.h:600
ZDCPulseAnalyzer::m_lastHGOverFlowSample
int m_lastHGOverFlowSample
Definition: ZDCPulseAnalyzer.h:340
ZDCPulseAnalyzer::BadT0Bit
@ BadT0Bit
Definition: ZDCPulseAnalyzer.h:43
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
ZDCPulseAnalyzer::m_samplesLGRefit
std::vector< float > m_samplesLGRefit
Definition: ZDCPulseAnalyzer.h:358
ReadOfcFromCool.nsamples
nsamples
Definition: ReadOfcFromCool.py:115
ZDCPulseAnalyzer::m_chisqDivAmpCutHG
float m_chisqDivAmpCutHG
Definition: ZDCPulseAnalyzer.h:143
ZDCPulseAnalyzer::m_peak2ndDerivMinTolerance
size_t m_peak2ndDerivMinTolerance
Definition: ZDCPulseAnalyzer.h:103
ZDCPulseAnalyzer::m_baselineCorr
float m_baselineCorr
Definition: ZDCPulseAnalyzer.h:264
ZDCPulseAnalyzer::ExcludeEarlyLGBit
@ ExcludeEarlyLGBit
Definition: ZDCPulseAnalyzer.h:44
ZDCPulseAnalyzer::m_PSHGOverUnderflow
bool m_PSHGOverUnderflow
Definition: ZDCPulseAnalyzer.h:242
ZDCFitExpFermiVariableTausRun3
Definition: ZDCFitWrapper.h:292
ZDCPulseAnalyzer::DoFit
void DoFit(bool refitLG=false)
Definition: ZDCPulseAnalyzer.cxx:1552
ZDCPulseAnalyzer::m_preAmplitude
float m_preAmplitude
Definition: ZDCPulseAnalyzer.h:325
ZDCPulseAnalyzer::m_tmin
float m_tmin
Definition: ZDCPulseAnalyzer.h:97
ZDCPulseAnalyzer::PSHGOverUnderflowBit
@ PSHGOverUnderflowBit
Definition: ZDCPulseAnalyzer.h:34
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
ZDCPulseAnalyzer::prepareLGRefit
void prepareLGRefit(const std::vector< float > &samplesLG, const std::vector< float > &samplesSig, const std::vector< bool > &useSamples)
Definition: ZDCPulseAnalyzer.cxx:1529
ZDCPulseAnalyzer::failSigCut
bool failSigCut() const
Definition: ZDCPulseAnalyzer.h:607
ZDCPulseAnalyzer::m_ADCSSampSigHG
std::vector< float > m_ADCSSampSigHG
Definition: ZDCPulseAnalyzer.h:352
ZDCPulseAnalyzer::m_fitAmpMaxLG
float m_fitAmpMaxLG
Definition: ZDCPulseAnalyzer.h:163
ZDCPulseAnalyzer::DoAnalysis
bool DoAnalysis(bool repass)
Definition: ZDCPulseAnalyzer.cxx:1017
ZDCPulseAnalyzer::Reset
void Reset(bool reanalyze=false)
Definition: ZDCPulseAnalyzer.cxx:297
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
ZDCPulseAnalyzer::m_minADCSampleHG
int m_minADCSampleHG
Definition: ZDCPulseAnalyzer.h:273
ZDCPulseAnalyzer::LGModeNormal
@ LGModeNormal
Definition: ZDCPulseAnalyzer.h:56
ZDCPulseAnalyzer::m_fitAmpError
float m_fitAmpError
Definition: ZDCPulseAnalyzer.h:306
ZDCPulseAnalyzer::m_fitTimeCorr
float m_fitTimeCorr
Definition: ZDCPulseAnalyzer.h:309
ZDCPulseAnalyzer::m_samplesSigLGRefit
std::vector< float > m_samplesSigLGRefit
Definition: ZDCPulseAnalyzer.h:359
ZDCPulseAnalyzer::m_peak2ndDerivMinThreshHG
float m_peak2ndDerivMinThreshHG
Definition: ZDCPulseAnalyzer.h:105
ZDCPulseAnalyzer::m_timeSig
float m_timeSig
Definition: ZDCPulseAnalyzer.h:310
ZDCPulseAnalyzer::prePulse
bool prePulse() const
Definition: ZDCPulseAnalyzer.h:595
ZDCPulseAnalyzer::m_T0CutLowLG
float m_T0CutLowLG
Definition: ZDCPulseAnalyzer.h:145
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ZDCPulseAnalyzer::m_defaultT0Min
float m_defaultT0Min
Definition: ZDCPulseAnalyzer.h:157
ZDCPulseAnalyzer::FitFailedBit
@ FitFailedBit
Definition: ZDCPulseAnalyzer.h:40
xmax
double xmax
Definition: listroot.cxx:61
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ZDCPulseAnalyzer::m_maxSamplesPostExcl
unsigned int m_maxSamplesPostExcl
Definition: ZDCPulseAnalyzer.h:179
ZDCPulseAnalyzer::m_amplitude
float m_amplitude
Definition: ZDCPulseAnalyzer.h:321
ZDCPulseAnalyzer::m_initializedFits
bool m_initializedFits
Definition: ZDCPulseAnalyzer.h:205
ZDCPulseAnalyzer::excludeEarlyLG
bool excludeEarlyLG() const
Definition: ZDCPulseAnalyzer.h:601
ZDCPulseAnalyzer::m_defaultFitTMin
float m_defaultFitTMin
Definition: ZDCPulseAnalyzer.h:140
ZDCPulseAnalyzer::m_fitTMin
float m_fitTMin
Definition: ZDCPulseAnalyzer.h:292
ZDCPulseAnalyzer::m_minDeriv2ndIndex
int m_minDeriv2ndIndex
Definition: ZDCPulseAnalyzer.h:289
ZDCPulseAnalyzer::m_LGUnderflow
bool m_LGUnderflow
Definition: ZDCPulseAnalyzer.h:244
ZDCPulseAnalyzer::m_LGOverflowADC
int m_LGOverflowADC
Definition: ZDCPulseAnalyzer.h:128
LArCellBinning.step
step
Definition: LArCellBinning.py:158
ZDCPulseAnalyzer::m_ADCSamplesLGSub
std::vector< float > m_ADCSamplesLGSub
Definition: ZDCPulseAnalyzer.h:347
ZDCPulseAnalyzer::LGModeRefitLG
@ LGModeRefitLG
Definition: ZDCPulseAnalyzer.h:58
ZDCPulseAnalyzer::m_T0CutHighHG
float m_T0CutHighHG
Definition: ZDCPulseAnalyzer.h:149
ZDCPulseAnalyzer::m_firstHGOverFlowSample
int m_firstHGOverFlowSample
Definition: ZDCPulseAnalyzer.h:341
ZDCPulseAnalyzer::s_undelayedFitHist
static TH1 * s_undelayedFitHist
Definition: ZDCPulseAnalyzer.h:80
ZDCMsg::Debug
@ Debug
Definition: ZDCMsg.h:19
ZDCPulseAnalyzer::m_fitAmpMinHG
float m_fitAmpMinHG
Definition: ZDCPulseAnalyzer.h:159
ZDCPulseAnalyzer::FitMinAmpBit
@ FitMinAmpBit
Definition: ZDCPulseAnalyzer.h:48
ZDCMsg::Fatal
@ Fatal
Definition: ZDCMsg.h:23
ZDCPulseAnalyzer::m_FADCCorrPerSample
bool m_FADCCorrPerSample
Definition: ZDCPulseAnalyzer.h:196
ZDCPulseAnalyzer::fitMinimumAmplitude
bool fitMinimumAmplitude() const
Definition: ZDCPulseAnalyzer.h:604
ZDCPulseAnalyzer::m_timingCorrMode
unsigned int m_timingCorrMode
Definition: ZDCPulseAnalyzer.h:182
ZDCPulseAnalyzer::m_maxSamplesPreExcl
unsigned int m_maxSamplesPreExcl
Definition: ZDCPulseAnalyzer.h:172
LArDigits2NtupleDumper.nSamples
nSamples
Definition: LArDigits2NtupleDumper.py:85
merge.status
status
Definition: merge.py:16
ZDCPulseAnalyzer::m_FADCCorrLG
std::unique_ptr< const TH1 > m_FADCCorrLG
Definition: ZDCPulseAnalyzer.h:198
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
ZDCPulseAnalyzer::m_initialPostPulseT0
float m_initialPostPulseT0
Definition: ZDCPulseAnalyzer.h:303
ZDCPulseAnalyzer::m_fitExpAmp
float m_fitExpAmp
Definition: ZDCPulseAnalyzer.h:320
ZDCPulseAnalyzer::m_prePulseCombinedFitter
std::unique_ptr< TFitter > m_prePulseCombinedFitter
Definition: ZDCPulseAnalyzer.h:225
ZDCPulseAnalyzer::m_fitHist
std::unique_ptr< TH1 > m_fitHist
Definition: ZDCPulseAnalyzer.h:202
ZDCPulseAnalyzer::m_timeResFuncHG_p
std::unique_ptr< const TF1 > m_timeResFuncHG_p
Definition: ZDCPulseAnalyzer.h:151
ZDCPulseAnalyzer::m_preSampleAmp
float m_preSampleAmp
Definition: ZDCPulseAnalyzer.h:324
ZDCPulseAnalyzer::m_nonLinCorrParamsHG
std::vector< float > m_nonLinCorrParamsHG
Definition: ZDCPulseAnalyzer.h:191
ZDCPulseAnalyzer::getAmplitudeCorrection
double getAmplitudeCorrection(bool highGain)
Definition: ZDCPulseAnalyzer.cxx:611
ZDCPulseAnalyzer::m_nominalTau1
float m_nominalTau1
Definition: ZDCPulseAnalyzer.h:133
ZDCPulseAnalyzer::m_minDelta
float m_minDelta
Definition: ZDCPulseAnalyzer.h:285
ZDCPulseAnalyzer::m_fitTCorr2nd
float m_fitTCorr2nd
Definition: ZDCPulseAnalyzer.h:311
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
ZDCPulseAnalyzer::s_combinedFitTMax
static float s_combinedFitTMax
Definition: ZDCPulseAnalyzer.h:83
ZDCPulseAnalyzer::m_postExclLGADCThresh
unsigned int m_postExclLGADCThresh
Definition: ZDCPulseAnalyzer.h:178
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
ZDCPulseAnalyzer::m_refitLGAmpError
float m_refitLGAmpError
Definition: ZDCPulseAnalyzer.h:335
ZDCPulseAnalyzer::m_samplesSig
std::vector< float > m_samplesSig
Definition: ZDCPulseAnalyzer.h:356
ZDCPulseAnalyzer::m_initialPrePulseT0
float m_initialPrePulseT0
Definition: ZDCPulseAnalyzer.h:300
ZDCPulseAnalyzer::postPulse
bool postPulse() const
Definition: ZDCPulseAnalyzer.h:596
ZDCPulseAnalyzer::m_refitLGTimeSub
float m_refitLGTimeSub
Definition: ZDCPulseAnalyzer.h:338
ZDCPulseAnalyzer::m_fadcCorrFileName
std::string m_fadcCorrFileName
Definition: ZDCPulseAnalyzer.h:195
ZDCFitExpFermiLHCfPrePulse
Definition: ZDCFitWrapper.h:465
ZDCPulseAnalyzer::havePulse
bool havePulse() const
Definition: ZDCPulseAnalyzer.h:585
ZDCPulseAnalyzer::m_HGT0CorrParams
std::vector< float > m_HGT0CorrParams
Definition: ZDCPulseAnalyzer.h:186
ZDCPulseAnalyzer::s_pullValues
static std::vector< float > s_pullValues
Definition: ZDCPulseAnalyzer.h:85
ZDCFitExpFermiPreExp
Definition: ZDCFitWrapper.h:581
ZDCPulseAnalyzer::FailBit
@ FailBit
Definition: ZDCPulseAnalyzer.h:30
ZDCFitExpFermiLinearFixedTaus
Definition: ZDCFitWrapper.h:785
ZDCPulseAnalyzer::m_tmax
float m_tmax
Definition: ZDCPulseAnalyzer.h:98
ZDCPulseAnalyzer::m_haveSignifCuts
bool m_haveSignifCuts
Definition: ZDCPulseAnalyzer.h:165
ZDCFitGeneralPulse
Definition: ZDCFitWrapper.h:1078
ZDCPulseAnalyzer::m_refitLGTime
float m_refitLGTime
Definition: ZDCPulseAnalyzer.h:337
ZDCPulseAnalyzer::m_Nsample
unsigned int m_Nsample
Definition: ZDCPulseAnalyzer.h:91
ZDCPulseAnalyzer::CalculateDerivative
static std::vector< float > CalculateDerivative(const std::vector< float > &inputData, unsigned int step)
Definition: ZDCPulseAnalyzer.cxx:2290
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
ZDCPulseAnalyzer::LGUnderflowBit
@ LGUnderflowBit
Definition: ZDCPulseAnalyzer.h:36
Generated on Sat Nov 15 2025 21:58:38 for ATLAS Offline Software by   doxygen 1.8.18