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

#include <ZDCDataAnalyzer.h>

Collaboration diagram for ZDCDataAnalyzer:

Public Types

typedef std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
 
typedef std::array< std::array< bool, 4 >, 2 > ZDCModuleBoolArray
 
typedef std::array< std::array< int, 4 >, 2 > ZDCModuleIntArray
 
using JSON = ZDCJSONConfig::JSON
 

Public Member Functions

 ZDCDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, int nSample, float deltaTSample, size_t preSampleIdx, std::string fitFunction, const ZDCModuleIntArray &peak2ndDerivMinSamples, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsHG, const ZDCModuleFloatArray &peak2ndDerivMinThresholdsLG, unsigned int LGMode=ZDCPulseAnalyzer::LGModeNormal)
 
 ZDCDataAnalyzer (ZDCMsg::MessageFunctionPtr messageFunc_p, const JSON &configJSON)
 
 ~ZDCDataAnalyzer ()
 
template<typename T >
bool getPulseAnalyzerGlobalPar (const std::string &key, T &value)
 
template<typename T >
void invokeAll (T functor)
 
void enableDelayed (float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
 
void enableDelayed (const ZDCModuleFloatArray &delayDeltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
 
void enableRepass (const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
 
void enablePreExclusion (unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
 
void enablePreExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)
 
void enablePostExclusion (unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
 
void enablePostExclusion (unsigned int maxSamplesExcl, unsigned int HGADCThresh, unsigned int LGADCThresh)
 
bool ModuleDisabled (unsigned int side, unsigned int module) const
 
bool moduleEnabled (unsigned int side, unsigned int module) const
 
unsigned int GetModuleMask () const
 
float GetModuleSum (size_t side) const
 
float GetModuleSumErr (size_t side) const
 
float GetSideBkgdFrac (size_t side) const
 
float GetCalibModuleSum (size_t side) const
 
float GetCalibModuleSumErr (size_t side) const
 
float GetSideCalibBkgdFrac (size_t side) const
 
void DoNLcalibModuleSum ()
 
float GetNLcalibModuleSum (size_t side) const
 
float GetNLcalibModuleSumErr (size_t side) const
 
float GetModuleSumPreSample (size_t side) const
 
float GetAverageTime (size_t side) const
 
bool SideFailed (size_t side) const
 
float GetModuleAmplitude (size_t side, size_t module) const
 
float GetModuleTime (size_t side, size_t module) const
 
float GetModuleChisq (size_t side, size_t module) const
 
float GetModuleCalibAmplitude (size_t side, size_t module) const
 
float GetModuleCalibTime (size_t side, size_t module) const
 
float GetModuleStatus (size_t side, size_t module) const
 
float GetdelayedBS (size_t side, size_t module) const
 
const ZDCPulseAnalyzer * GetPulseAnalyzer (size_t side, size_t module) const
 
ZDCPulseAnalyzer * GetPulseAnalyzer (size_t side, size_t module)
 
bool disableModule (size_t side, size_t module)
 
void set2ndDerivStep (size_t step)
 
void setMinimumSignificance (float sigMinHG, float sigMinLG)
 
void SetGainFactorsHGLG (float gainFactorHG, float gainFactorLG)
 
void SetGainFactorsHGLG (const ZDCModuleFloatArray &gainFactorsHG, const ZDCModuleFloatArray &gainFactorsLG)
 
void SetPeak2ndDerivMinTolerances (size_t tolerance)
 
void SetFitTimeMax (float tmax)
 
void SetSaveFitFunc (bool save)
 
void SetADCOverUnderflowValues (const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
 
void SetNoiseSigmas (const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
 
void SetTauT0Values (const ZDCModuleBoolArray &fxiTau1, const ZDCModuleBoolArray &fxiTau2, const ZDCModuleFloatArray &tau1, const ZDCModuleFloatArray &tau2, const ZDCModuleFloatArray &t0HG, const ZDCModuleFloatArray &t0LG)
 
void SetFitMinMaxAmpValues (const ZDCModuleFloatArray &minAmpHG, const ZDCModuleFloatArray &minAmpLG, const ZDCModuleFloatArray &maxAmpHG, const ZDCModuleFloatArray &maxAmpLG)
 
void SetFitMinMaxAmpValues (float minHG, float minLG, float maxHG, float maxLG)
 
void SetCutValues (const ZDCModuleFloatArray &chisqDivAmpCutHG, const ZDCModuleFloatArray &chisqDivAmpCutLG, const ZDCModuleFloatArray &deltaT0MinHG, const ZDCModuleFloatArray &deltaT0MaxHG, const ZDCModuleFloatArray &deltaT0MinLG, const ZDCModuleFloatArray &deltaT0MaxLG)
 
void SetTimingCorrParams (ZDCPulseAnalyzer::TimingCorrMode mode, float refADC, float refScale, const std::array< std::array< std::vector< float >, 4 >, 2 > &HGParamArr, const std::array< std::array< std::vector< float >, 4 >, 2 > &LGParamArr)
 
void SetNonlinCorrParams (float refADC, float refScale, const std::array< std::array< std::vector< float >, 4 >, 2 > &HGNonlinCorrParams, const std::array< std::array< std::vector< float >, 4 >, 2 > &LHGNonlinCorrParams)
 
void SetNLcalibParams (std::array< std::array< std::array< float, 6 >, 3 >, 2 > &nlcalibParams)
 
void SetModuleAmpFractionLG (const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
 
void enableTimeSigCut (bool AND, float sigCut, const std::string &TF1String, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsHGArr, const std::array< std::array< std::vector< double >, 4 >, 2 > &parsLGArr)
 
void enableFADCCorrections (bool correctPerSample, std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &correHistHG, std::array< std::array< std::unique_ptr< const TH1 >, 4 >, 2 > &correHistLG)
 
void disableFADCCorrections ()
 
void LoadEnergyCalibrations (std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&calibSplines)
 
void LoadT0Calibrations (std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&T0HGOffsetSplines, std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&T0LGOffsetSplines)
 
void StartEvent (int lumiBlock)
 
void LoadAndAnalyzeData (size_t side, size_t module, const std::vector< float > &HGSamples, const std::vector< float > &LGSamples)
 
void LoadAndAnalyzeData (size_t side, size_t module, const std::vector< float > &HGSamples, const std::vector< float > &LGSamples, const std::vector< float > &HGSamplesDelayed, const std::vector< float > &LGSamplesDelayed)
 
bool FinishEvent ()
 

Static Public Attributes

static const ZDCJSONConfig::JSONParamList JSONConfigParams
 

Private Member Functions

void init ()
 

Private Attributes

ZDCMsg::MessageFunctionPtr m_msgFunc_p
 
std::unique_ptr< ZDCJSONConfig > m_dataAnalyzerConfig {}
 
std::unique_ptr< ZDCJSONConfig > m_pulseAnalyzerConfig {}
 
bool m_repassEnabled {false}
 
std::array< std::array< int, 4 >, 2 > m_delayedOrder {}
 
ZDCModuleBoolArray m_moduleEnabled {}
 
std::array< std::array< std::unique_ptr< ZDCPulseAnalyzer >, 4 >, 2 > m_moduleAnalyzers {}
 
int m_eventCount {0}
 
ZDCModuleFloatArray m_HGGains {}
 
ZDCModuleFloatArray m_pedestals {}
 
bool m_haveECalib {false}
 
bool m_haveT0Calib {false}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_LBDepEcalibSplines {}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0HGOffsetSplines {}
 
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0LGOffsetSplines {}
 
int m_currentLB {-1}
 
ZDCModuleFloatArray m_currentECalibCoeff {}
 
ZDCModuleFloatArray m_currentT0OffsetsHG {}
 
ZDCModuleFloatArray m_currentT0OffsetsLG {}
 
std::array< std::array< bool, 4 >, 2 > m_dataLoaded {}
 
unsigned int m_moduleMask {0}
 
std::array< std::array< unsigned int, 4 >, 2 > m_moduleStatus {}
 
std::array< std::array< float, 4 >, 2 > m_calibAmplitude {}
 
std::array< std::array< float, 4 >, 2 > m_calibTime {}
 
std::array< float, 2 > m_moduleSum {}
 
std::array< float, 2 > m_moduleSumErrSq {}
 
std::array< float, 2 > m_moduleSumPreSample {}
 
std::array< float, 2 > m_moduleSumBkgdFrac {}
 
std::array< float, 2 > m_calibModuleSum {}
 
std::array< float, 2 > m_calibModuleSumErrSq {}
 
std::array< float, 2 > m_calibModSumBkgdFrac {}
 
bool m_haveNLcalib {false}
 
std::array< std::array< std::array< float, 6 >, 3 >, 2 > m_NLcalibFactors {}
 
std::array< float, 2 > m_NLcalibModuleSum {}
 
std::array< float, 2 > m_NLcalibModuleSumErrSq {}
 
std::array< float, 2 > m_NLcalibModSumBkgdFrac {}
 
std::array< float, 2 > m_averageTime {}
 
std::array< bool, 2 > m_fail {}
 
std::array< std::array< float, 4 >, 2 > m_moduleAmpFractionLG {}
 

Detailed Description

Definition at line 22 of file ZDCDataAnalyzer.h.

Member Typedef Documentation

◆ JSON

using ZDCDataAnalyzer::JSON = ZDCJSONConfig::JSON

Definition at line 29 of file ZDCDataAnalyzer.h.

◆ ZDCModuleBoolArray

typedef std::array<std::array<bool, 4>, 2> ZDCDataAnalyzer::ZDCModuleBoolArray

Definition at line 26 of file ZDCDataAnalyzer.h.

◆ ZDCModuleFloatArray

typedef std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::ZDCModuleFloatArray

Definition at line 25 of file ZDCDataAnalyzer.h.

◆ ZDCModuleIntArray

typedef std::array<std::array<int, 4>, 2> ZDCDataAnalyzer::ZDCModuleIntArray

Definition at line 27 of file ZDCDataAnalyzer.h.

Constructor & Destructor Documentation

◆ ZDCDataAnalyzer() [1/2]

ZDCDataAnalyzer::ZDCDataAnalyzer ( ZDCMsg::MessageFunctionPtr  messageFunc_p,
int  nSample,
float  deltaTSample,
size_t  preSampleIdx,
std::string  fitFunction,
const ZDCModuleIntArray &  peak2ndDerivMinSamples,
const ZDCModuleFloatArray &  peak2ndDerivMinThresholdsHG,
const ZDCModuleFloatArray &  peak2ndDerivMinThresholdsLG,
unsigned int  LGMode = ZDCPulseAnalyzer::LGModeNormal 
)

Definition at line 19 of file ZDCDataAnalyzer.cxx.

23  :
24  m_msgFunc_p(std::move(msgFunc_p))
25 {
26  m_moduleEnabled[0] = {{true, true, true, true}};
27  m_moduleEnabled[1] = {{true, true, true, true}};
28 
29  m_moduleAnalyzers[0] = {{0, 0, 0, 0}};
30  m_moduleAnalyzers[1] = {{0, 0, 0, 0}};
31 
32  m_calibAmplitude[0] = {{0, 0, 0, 0}};
33  m_calibAmplitude[1] = {{0, 0, 0, 0}};
34 
35  m_calibTime[0] = {{0, 0, 0, 0}};
36  m_calibTime[1] = {{0, 0, 0, 0}};
37 
38  m_dataLoaded[0] = {{false, false, false, false}};
39  m_dataLoaded[1] = {{false, false, false, false}};
40 
41  m_delayedOrder[0] = {0, 0, 0, 0};
42  m_delayedOrder[1] = {0, 0, 0, 0};
43 
44  // For now we are using hard-coded gain factors and pedestals
45  //
46  m_HGGains[0] = {{10, 10, 10, 10}};
47  m_HGGains[1] = {{10, 10, 10, 10}};
48 
49  m_pedestals[0] = {{100, 100, 100, 100}};
50  m_pedestals[1] = {{100, 100, 100, 100}};
51 
52  // Construct the per-module pulse analyzers
53  //
54  for (size_t side : {0, 1}) {
55  for (size_t module : {0, 1, 2, 3}) {
56  std::string moduleTag= "_s" + std::to_string(side) + "_m" +std::to_string(module);
57  m_moduleAnalyzers[side][module] = make_unique<ZDCPulseAnalyzer>(m_msgFunc_p, std::move(moduleTag), nSample, deltaTSample, preSampleIdx,
58  m_pedestals[side][module], fitFunction,
59  peak2ndDerivMinSamples[side][module],
60  peak2ndDerivMinThresholdsHG[side][module],
61  peak2ndDerivMinThresholdsLG[side][module]);
62  m_moduleAnalyzers[side][module]->setLGMode(LGMode);
63  }
64  }
65 }

◆ ZDCDataAnalyzer() [2/2]

ZDCDataAnalyzer::ZDCDataAnalyzer ( ZDCMsg::MessageFunctionPtr  messageFunc_p,
const JSON &  configJSON 
)

Definition at line 67 of file ZDCDataAnalyzer.cxx.

67  :
68  m_msgFunc_p(msgFunc_p)
69 {
70  init();
71 
72  // Construct the object that will extract the data and pulse analyzer
73  // configurations from the input JSON configuration
74  //
75  // For the data anlyzer we use 1 channel since the relevant
76  // configurations will all be per-side
77  //
78  m_dataAnalyzerConfig = std::make_unique<ZDCJSONConfig>(std::vector<std::string>{"C", "A"}, 1);
79  m_pulseAnalyzerConfig = std::make_unique<ZDCJSONConfig>(std::vector<std::string>{"C", "A"}, 4);
80 
81 
82  // Extract the JSON object for the pulse analyzer(s)
83  //
84  JSON DAconfig = configJSON["DataAnalyzer"];
85  if (DAconfig.is_null()) {
86  (*m_msgFunc_p)(ZDCMsg::Fatal, "JSON configuration object for ZDCDataAnalyzer not found");
87  return;
88  }
89 
90  auto [result, resultStr] = m_dataAnalyzerConfig->ParseConfig(DAconfig, ZDCDataAnalyzer::JSONConfigParams);
91  if (!result) {
92  (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, error = " + resultStr);
93  return;
94  }
95 
96  // The data analyzer configuration is simple enough we handle it inline
97  //
98  for (size_t side : {0, 1}) {
99  for (size_t module : {0, 1, 2, 3}) {
100  m_moduleEnabled[side][module] = true;
101  }
102 
103  // Now extract information from ZDCDataAnalyzer-specific configuration
104  //
105  JSON sideConfig = m_pulseAnalyzerConfig->getChannelConfig(side, 0);
106  JSON modEnable = sideConfig["moduleEnabled"];
107  if (!modEnable.is_null()) {
108  if (modEnable.size() != 4) {
109  (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCDataAnalyzer JSON config, incorrect size of moduleEnabled");
110  return;
111  }
112 
113  for (size_t module : {0, 1, 2, 3}) {
114  m_moduleEnabled[side][module] = modEnable[module];
115  }
116  }
117  }
118 
119  // Extract the JSON object for the pulse analyzer(s)
120  //
121  JSON PAconfig = configJSON["PulseAnalyzer"];
122  if (PAconfig.is_null()) {
123  (*m_msgFunc_p)(ZDCMsg::Fatal, "JSON configuration object for ZDCPulseAnalyzer not found");
124  return;
125  }
126 
127  // Do the parsing of the pulse analyzer JSON configuration
128  //
129  auto [result2, resultStr2] = m_pulseAnalyzerConfig->ParseConfig(PAconfig, ZDCPulseAnalyzer::JSONConfigParams);
130  if (!result2) {
131  (*m_msgFunc_p)(ZDCMsg::Fatal, "Error parsing ZDCPulseAnalyzer JSON config, error = " + resultStr2);
132  return;
133  }
134 
135  // Now set up each of the pulse analyzers
136  //
137  for (size_t side : {0, 1}) {
138  for (size_t module : {0, 1, 2, 3}) {
139 
140  (*m_msgFunc_p)(ZDCMsg::Info, "Setting up ZDCPulseAnalyzer for side " + std::to_string(side) +
141  ", module " + std::to_string(module));
142 
143  //
144  // Get the parsed configuration JSON object for this module
145  //
146  JSON moduleConfig = m_pulseAnalyzerConfig->getChannelConfig(side, module);
147 
148  std::ostringstream ostr;
149  ostr << "JSON configuration for ZDC pulse analyyzer for side " << std::to_string(side)
150  << ", module " << std::to_string(module) << "\n" << moduleConfig.dump(2);
151  (*m_msgFunc_p)(ZDCMsg::Verbose, ostr.str().c_str());
152 
153  // Construct the ZDCPulseAnalyzer object
154  //
155  m_moduleAnalyzers[side][module] = std::make_unique<ZDCPulseAnalyzer>(msgFunc_p, moduleConfig);
156 
157  (*m_msgFunc_p)(ZDCMsg::Info, "Finished constructing ZDCPulseAnalyzer for side " + std::to_string(side) +
158  ", module " + std::to_string(module));
159 
160  }
161  }
162 
163  // Check for the enabling of re-pass
164  //
165  getPulseAnalyzerGlobalPar("enableRepass", m_repassEnabled);
166 
167  (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer construction complete");
168 }

◆ ~ZDCDataAnalyzer()

ZDCDataAnalyzer::~ZDCDataAnalyzer ( )
inline

Definition at line 104 of file ZDCDataAnalyzer.h.

104 {};

Member Function Documentation

◆ disableFADCCorrections()

void ZDCDataAnalyzer::disableFADCCorrections ( )

Definition at line 482 of file ZDCDataAnalyzer.cxx.

483 {
484  for (size_t side : {0, 1}) {
485  for (size_t module : {0, 1, 2, 3}) {
486  m_moduleAnalyzers[side][module]->disableFADCCorrections();
487  }
488  }
489 }

◆ disableModule()

bool ZDCDataAnalyzer::disableModule ( size_t  side,
size_t  module 
)

Definition at line 207 of file ZDCDataAnalyzer.cxx.

208 {
209  if (side < 2 && module < 4) {
210  //
211  // Can't disable in the middle of analysis
212  //
213  if (m_dataLoaded[side][module]) return false;
214  else {
215  m_moduleEnabled[side][module] = false;
216  return true;
217  }
218  }
219  else {
220  return false;
221  }
222 }

◆ DoNLcalibModuleSum()

void ZDCDataAnalyzer::DoNLcalibModuleSum ( )

Definition at line 768 of file ZDCDataAnalyzer.cxx.

769 {
770  if (!m_haveNLcalib) return;
771 
772  for (int iside:{0,1})
773  {
774  if (m_calibModuleSum[iside]>0.)
775  {
776  float fEM = m_calibAmplitude[iside][0] / m_calibModuleSum[iside];
777  float fHad1 = m_calibAmplitude[iside][1] / m_calibModuleSum[iside];
778  float fHad2 = m_calibAmplitude[iside][2] / m_calibModuleSum[iside];
779 
780  float EMCorrFact = 0;
781 
782  for (size_t i=0;i<m_NLcalibFactors[iside][0].size()-1;i++)
783  {
784  EMCorrFact += std::pow(fEM - m_NLcalibFactors[iside][0][0],i)*m_NLcalibFactors[iside][0][i+1];
785  }
786 
787  float Had1CorrFact = 0;
788  for (size_t i=0;i<m_NLcalibFactors[iside][1].size()-1;i++)
789  {
790  Had1CorrFact += std::pow(fHad1 - m_NLcalibFactors[iside][1][0],i)*m_NLcalibFactors[iside][1][i+1];
791  }
792 
793  float Had2CorrFact = 0;
794  for (size_t i=0;i<m_NLcalibFactors[iside][2].size()-1;i++)
795  {
796  Had2CorrFact += std::pow(fHad2 - m_NLcalibFactors[iside][2][0],i)*m_NLcalibFactors[iside][2][i+1];
797  }
798 
799  std::ostringstream ostr;
800  ostr << "ZDCDataAnalyzer: " << m_calibModuleSum[iside] << " " << EMCorrFact << " " << Had1CorrFact << " " << Had2CorrFact << std::endl;
801  (*m_msgFunc_p)(ZDCMsg::Debug,ostr.str().c_str());
802 
803  float ECorrEM = m_calibModuleSum[iside]/EMCorrFact;
804  float ECorrEMHad1 = ECorrEM/Had1CorrFact;
805  float ECorrEMHad1Had2 = ECorrEMHad1/Had2CorrFact;
806 
807 
808  m_NLcalibModuleSum[iside] = ECorrEMHad1Had2;
809  m_NLcalibModuleSumErrSq[iside] = 0.; // no error for now
810  }
811  else
812  {
813  (*m_msgFunc_p)(ZDCMsg::Info,"SUM = 0!!");
814  m_NLcalibModuleSum[iside] = 0.;
815  m_NLcalibModuleSumErrSq[iside] = 0.; // no error for now
816  }
817  }
818 
819 }

◆ enableDelayed() [1/2]

void ZDCDataAnalyzer::enableDelayed ( const ZDCModuleFloatArray &  delayDeltaT,
const ZDCModuleFloatArray &  undelayedDelayedPedestalDiff 
)

Definition at line 235 of file ZDCDataAnalyzer.cxx.

236 {
237  for (size_t side : {0, 1}) {
238  for (size_t module : {0, 1, 2, 3}) {
239  if (delayDeltaTArray[side][module] < 0) m_delayedOrder[side][module] = -1;
240  else m_delayedOrder[side][module] = 1;
241 
242  (*m_msgFunc_p)(ZDCMsg::Verbose, "Enabling use of delayed samples on side, module = " + std::to_string(side) + ", " +
243  std::to_string(module) + ", delta t = " + std::to_string(delayDeltaTArray[side][module]));
244 
245  m_moduleAnalyzers[side][module]->enableDelayed(std::abs(delayDeltaTArray[side][module]), undelayedDelayedPedestalDiff[side][module]);
246  }
247  }
248 }

◆ enableDelayed() [2/2]

void ZDCDataAnalyzer::enableDelayed ( float  deltaT,
const ZDCModuleFloatArray &  undelayedDelayedPedestalDiff 
)

Definition at line 224 of file ZDCDataAnalyzer.cxx.

225 {
226  int delayedOrder = deltaT < 0 ? -1 : 1;
227  for (size_t side : {0, 1}) {
228  for (size_t module : {0, 1, 2, 3}) {
229  m_delayedOrder[side][module] = delayedOrder;
230  m_moduleAnalyzers[side][module]->enableDelayed(std::abs(deltaT), undelayedDelayedPedestalDiff[side][module]);
231  }
232  }
233 }

◆ enableFADCCorrections()

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

Definition at line 466 of file ZDCDataAnalyzer.cxx.

469 {
470  if (correctPerSample)
471  (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer::enabling FADC Corrections per sample");
472  else
473  (*m_msgFunc_p)(ZDCMsg::Info, "ZDCDataAnalyzer::enabling FADC Corrections per amplitude");
474 
475  for (size_t side : {0, 1}) {
476  for (size_t module : {0, 1, 2, 3}) {
477  m_moduleAnalyzers[side][module]->enableFADCCorrections(correctPerSample, corrHistHG[side][module], corrHistLG[side][module]);
478  }
479  }
480 }

◆ enablePostExclusion() [1/2]

void ZDCDataAnalyzer::enablePostExclusion ( unsigned int  maxSamplesExcl,
const ZDCModuleIntArray &  HGADCThresh,
const ZDCModuleIntArray &  LGADCThresh 
)

Definition at line 268 of file ZDCDataAnalyzer.cxx.

269 {
270  for (size_t side : {0, 1}) {
271  for (size_t module : {0, 1, 2, 3}) {
272  m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
273  }
274  }
275 }

◆ enablePostExclusion() [2/2]

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

Definition at line 277 of file ZDCDataAnalyzer.cxx.

278 {
279  for (size_t side : {0, 1}) {
280  for (size_t module : {0, 1, 2, 3}) {
281  m_moduleAnalyzers[side][module]->enablePostExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
282  }
283  }
284 }

◆ enablePreExclusion() [1/2]

void ZDCDataAnalyzer::enablePreExclusion ( unsigned int  maxSamplesExcl,
const ZDCModuleIntArray &  HGADCThresh,
const ZDCModuleIntArray &  LGADCThresh 
)

Definition at line 250 of file ZDCDataAnalyzer.cxx.

251 {
252  for (size_t side : {0, 1}) {
253  for (size_t module : {0, 1, 2, 3}) {
254  m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh[side][module], LGADCThresh[side][module]);
255  }
256  }
257 }

◆ enablePreExclusion() [2/2]

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

Definition at line 259 of file ZDCDataAnalyzer.cxx.

260 {
261  for (size_t side : {0, 1}) {
262  for (size_t module : {0, 1, 2, 3}) {
263  m_moduleAnalyzers[side][module]->enablePreExclusion(maxSamplesExcl, HGADCThresh, LGADCThresh);
264  }
265  }
266 }

◆ enableRepass()

void ZDCDataAnalyzer::enableRepass ( const ZDCModuleFloatArray &  peak2ndDerivMinRepassHG,
const ZDCModuleFloatArray &  peak2ndDerivMinRepassLG 
)

Definition at line 287 of file ZDCDataAnalyzer.cxx.

288 {
289  m_repassEnabled = true;
290  for (size_t side : {0, 1}) {
291  for (size_t module : {0, 1, 2, 3}) {
292  m_moduleAnalyzers[side][module]->enableRepass(peak2ndDerivMinRepassHG[side][module], peak2ndDerivMinRepassLG[side][module]);
293  }
294  }
295 }

◆ enableTimeSigCut()

void ZDCDataAnalyzer::enableTimeSigCut ( bool  AND,
float  sigCut,
const std::string &  TF1String,
const std::array< std::array< std::vector< double >, 4 >, 2 > &  parsHGArr,
const std::array< std::array< std::vector< double >, 4 >, 2 > &  parsLGArr 
)

Definition at line 491 of file ZDCDataAnalyzer.cxx.

494 {
495  for (size_t side : {0, 1}) {
496  for (size_t module : {0, 1, 2, 3}) {
497  m_moduleAnalyzers[side][module]->enableTimeSigCut(AND, sigCut, TF1String, parsHGArr[side][module], parsLGArr[side][module]);
498  }
499  }
500 }

◆ FinishEvent()

bool ZDCDataAnalyzer::FinishEvent ( )

Definition at line 663 of file ZDCDataAnalyzer.cxx.

664 {
665  // First make sure that all data is loaded. while we're at it, count how many modules on each side have a pulse
666  //
667  unsigned int sideNPulsesMod[2] = {0, 0};
668 
669  for (size_t side : {0, 1}) {
670  for (size_t module : {0, 1, 2, 3}) {
671  if (!m_dataLoaded[side][module] && m_moduleEnabled[side][module]) {return false;}
672  if (m_moduleAnalyzers[side][module]->armSumInclude()) {sideNPulsesMod[side]++;}
673  }
674  }
675 
676  // Are we doing a repass? If so, reanalyze modules for which no pulse was found the first time
677  // as long as we have one module with a pulse on the given side
678  //
679  if (m_repassEnabled) {
680  for (size_t side : {0, 1}) {
681  if (sideNPulsesMod[side] == 0) continue;
682 
683  for (size_t module : {0, 1, 2, 3}) {
684  if (!m_moduleEnabled[side][module]) continue;
685 
686  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
687 
688  // If this module had no pulse the first time, reanalyze it (with a lower 2nd derivative threshold)
689  //
690  if (!pulseAna_p->havePulse()) {
691  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer:: performing a repass on data for side, module = " + std::to_string(side) + ", " + std::to_string(module)));
692  pulseAna_p->ReanalyzeData();
693  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
694  }
695  }
696  }
697  }
698 
699  // Now sum up amplitudes etc
700  //
701  for (size_t side : {0, 1}) {
702  float tempFraction = 1.0;
703  double sumAmpTimesBkgdFrac = 0.0;
704  double sumCalibAmpTimesBkgdFrac = 0.0;
705 
706  for (size_t module : {0, 1, 2, 3}) {
707  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
708 
709  if (pulseAna_p->armSumInclude()) {
710  int moduleMaskBit = 4 * side + module;
711  m_moduleMask |= 1 << moduleMaskBit;
712 
713  float amplitude = pulseAna_p->GetAmplitude();
714  float ampError = pulseAna_p->GetAmpError();
715  float bkgdFraction = pulseAna_p->GetBkgdMaxFraction();
716 
717  m_calibAmplitude[side][module] = amplitude * m_currentECalibCoeff[side][module];
718 
719  float calibAmpError = ampError * m_currentECalibCoeff[side][module];
720 
721  float timeCalib = pulseAna_p->GetT0Corr();
722  if (pulseAna_p->useLowGain()) {timeCalib -= m_currentT0OffsetsLG[side][module];}
723  else {timeCalib -= m_currentT0OffsetsHG[side][module];}
724 
725  m_calibTime[side][module] = timeCalib;
726 
727  m_moduleSum[side] += amplitude;
728  m_moduleSumErrSq[side] += ampError * ampError;
729  sumAmpTimesBkgdFrac += amplitude*bkgdFraction;
730 
731  m_moduleSumPreSample[side] += pulseAna_p->GetPreSampleAmp();
732 
733  m_calibModuleSum[side] += m_calibAmplitude[side][module];
734  m_calibModuleSumErrSq[side] += calibAmpError * calibAmpError;
735 
736  m_averageTime[side] += m_calibTime[side][module] * m_calibAmplitude[side][module];
737  sumCalibAmpTimesBkgdFrac += amplitude*bkgdFraction;
738  }
739 
740  // subtract the fraction of LGOverflow events if we have fraction available (<0 means unavailable)
741  if (pulseAna_p->LGOverflow() && m_moduleAmpFractionLG[side][module] > 0) {tempFraction -= m_moduleAmpFractionLG[side][module];}
742  }
743 
744  {
745  CXXUTILS_TRAPPING_FP;
746  if (m_moduleSum[side] > 0) m_moduleSumBkgdFrac[side] = sumAmpTimesBkgdFrac/m_moduleSum[side];
747  else m_moduleSumBkgdFrac[side] = 0;
748  }
749 
750  if (m_calibModuleSum[side] > 1e-6) {
751  m_averageTime[side] /= m_calibModuleSum[side];
752  m_calibModSumBkgdFrac[side] = sumCalibAmpTimesBkgdFrac/m_calibModuleSum[side];
753  }
754  else {
755  m_averageTime[side] = 0;
756  m_calibModSumBkgdFrac[side] = 0;
757  }
758 
759  if (tempFraction < 1.0) {m_moduleSum[side] /= tempFraction;}
760  }
761 
762  DoNLcalibModuleSum();
763 
764  m_eventCount++;
765  return true;
766 }

◆ GetAverageTime()

float ZDCDataAnalyzer::GetAverageTime ( size_t  side) const
inline

Definition at line 150 of file ZDCDataAnalyzer.h.

150 {return m_averageTime.at(side);}

◆ GetCalibModuleSum()

float ZDCDataAnalyzer::GetCalibModuleSum ( size_t  side) const
inline

Definition at line 140 of file ZDCDataAnalyzer.h.

140 {return m_calibModuleSum.at(side);}

◆ GetCalibModuleSumErr()

float ZDCDataAnalyzer::GetCalibModuleSumErr ( size_t  side) const
inline

Definition at line 141 of file ZDCDataAnalyzer.h.

141 {return std::sqrt(m_calibModuleSumErrSq.at(side));}

◆ GetdelayedBS()

float ZDCDataAnalyzer::GetdelayedBS ( size_t  side,
size_t  module 
) const
inline

Definition at line 161 of file ZDCDataAnalyzer.h.

161 {return m_moduleAnalyzers.at(side).at(module)->GetdelayBS();}

◆ GetModuleAmplitude()

float ZDCDataAnalyzer::GetModuleAmplitude ( size_t  side,
size_t  module 
) const
inline

Definition at line 153 of file ZDCDataAnalyzer.h.

153 {return m_moduleAnalyzers.at(side).at(module)->GetAmplitude();}

◆ GetModuleCalibAmplitude()

float ZDCDataAnalyzer::GetModuleCalibAmplitude ( size_t  side,
size_t  module 
) const
inline

Definition at line 157 of file ZDCDataAnalyzer.h.

157 {return m_calibAmplitude.at(side).at(module);}

◆ GetModuleCalibTime()

float ZDCDataAnalyzer::GetModuleCalibTime ( size_t  side,
size_t  module 
) const
inline

Definition at line 158 of file ZDCDataAnalyzer.h.

158 {return m_calibTime.at(side).at(module);}

◆ GetModuleChisq()

float ZDCDataAnalyzer::GetModuleChisq ( size_t  side,
size_t  module 
) const
inline

Definition at line 155 of file ZDCDataAnalyzer.h.

155 {return m_moduleAnalyzers.at(side).at(module)->GetChisq();}

◆ GetModuleMask()

unsigned int ZDCDataAnalyzer::GetModuleMask ( ) const
inline

Definition at line 134 of file ZDCDataAnalyzer.h.

134 {return m_moduleMask;}

◆ GetModuleStatus()

float ZDCDataAnalyzer::GetModuleStatus ( size_t  side,
size_t  module 
) const
inline

Definition at line 159 of file ZDCDataAnalyzer.h.

159 {return m_moduleStatus.at(side).at(module);}

◆ GetModuleSum()

float ZDCDataAnalyzer::GetModuleSum ( size_t  side) const
inline

Definition at line 136 of file ZDCDataAnalyzer.h.

136 {return m_moduleSum.at(side);}

◆ GetModuleSumErr()

float ZDCDataAnalyzer::GetModuleSumErr ( size_t  side) const
inline

Definition at line 137 of file ZDCDataAnalyzer.h.

137 {return std::sqrt(m_moduleSumErrSq.at(side));}

◆ GetModuleSumPreSample()

float ZDCDataAnalyzer::GetModuleSumPreSample ( size_t  side) const
inline

Definition at line 148 of file ZDCDataAnalyzer.h.

148 {return m_moduleSumPreSample.at(side);}

◆ GetModuleTime()

float ZDCDataAnalyzer::GetModuleTime ( size_t  side,
size_t  module 
) const
inline

Definition at line 154 of file ZDCDataAnalyzer.h.

154 {return m_moduleAnalyzers.at(side).at(module)->GetT0Corr();}

◆ GetNLcalibModuleSum()

float ZDCDataAnalyzer::GetNLcalibModuleSum ( size_t  side) const
inline

Definition at line 145 of file ZDCDataAnalyzer.h.

145 {return m_NLcalibModuleSum.at(side);}

◆ GetNLcalibModuleSumErr()

float ZDCDataAnalyzer::GetNLcalibModuleSumErr ( size_t  side) const
inline

Definition at line 146 of file ZDCDataAnalyzer.h.

146 {return std::sqrt(m_NLcalibModuleSumErrSq.at(side));}

◆ GetPulseAnalyzer() [1/2]

ZDCPulseAnalyzer* ZDCDataAnalyzer::GetPulseAnalyzer ( size_t  side,
size_t  module 
)
inline

Definition at line 164 of file ZDCDataAnalyzer.h.

164 {return m_moduleAnalyzers.at(side).at(module).get();}

◆ GetPulseAnalyzer() [2/2]

const ZDCPulseAnalyzer* ZDCDataAnalyzer::GetPulseAnalyzer ( size_t  side,
size_t  module 
) const
inline

Definition at line 163 of file ZDCDataAnalyzer.h.

163 {return m_moduleAnalyzers.at(side).at(module).get();}

◆ getPulseAnalyzerGlobalPar()

template<typename T >
bool ZDCDataAnalyzer::getPulseAnalyzerGlobalPar ( const std::string &  key,
T &  value 
)
inline

Definition at line 106 of file ZDCDataAnalyzer.h.

106  {
107  if (m_pulseAnalyzerConfig.get()) return m_pulseAnalyzerConfig->getGlobalParam(key, value);
108  else return false;
109  }

◆ GetSideBkgdFrac()

float ZDCDataAnalyzer::GetSideBkgdFrac ( size_t  side) const
inline

Definition at line 138 of file ZDCDataAnalyzer.h.

138 {return m_moduleSumBkgdFrac.at(side);}

◆ GetSideCalibBkgdFrac()

float ZDCDataAnalyzer::GetSideCalibBkgdFrac ( size_t  side) const
inline

Definition at line 142 of file ZDCDataAnalyzer.h.

142 {return m_calibModSumBkgdFrac.at(side);}

◆ init()

void ZDCDataAnalyzer::init ( )
private

Definition at line 170 of file ZDCDataAnalyzer.cxx.

171 {
172  for (size_t side : {0, 1}) {
173  m_moduleSum[side] = 0;
174  m_moduleSumErrSq[side] = 0;
175  m_moduleSumPreSample[side] = 0;
176  m_calibModuleSum[side] = 0;
177  m_calibModuleSumErrSq[side] = 0;
178 
179  m_NLcalibModuleSum[side] = 0;
180  m_NLcalibModuleSumErrSq[side] = 0;
181  m_averageTime[side] = 0;
182  m_fail[side] = 0;
183 
184  for (size_t module : {0, 1, 2, 3}) {
185  m_moduleEnabled[side][module] = true;
186  m_calibAmplitude[side][module] = 0;
187  m_calibTime[side][module] = 0;
188 
189  m_dataLoaded[side][module] = false;
190  m_delayedOrder[side][module] = 0;
191 
192  // Default "calibrations"
193  //
194  m_currentECalibCoeff[side][module] = 1;
195  m_currentT0OffsetsHG[side][module] = 0;
196  m_currentT0OffsetsLG[side][module] = 0;
197 
198  }
199  }
200 
201  m_NLcalibFactors = {{
202  {{ {{0,0,0,0,0,0}},{{0,0,0,0,0,0}},{{0,0,0,0,0,0}} }},
203  {{ {{0,0,0,0,0,0}},{{0,0,0,0,0,0}},{{0,0,0,0,0,0}} }} }};
204 
205 }

◆ invokeAll()

template<typename T >
void ZDCDataAnalyzer::invokeAll ( T  functor)
inline

Definition at line 111 of file ZDCDataAnalyzer.h.

112  {
113  for (size_t side : {0, 1}) {
114  for (size_t module : {0, 1, 2, 3}) {
115  functor(m_moduleAnalyzers[side][module].get());
116  }
117  }
118  }

◆ LoadAndAnalyzeData() [1/2]

void ZDCDataAnalyzer::LoadAndAnalyzeData ( size_t  side,
size_t  module,
const std::vector< float > &  HGSamples,
const std::vector< float > &  LGSamples 
)

Definition at line 601 of file ZDCDataAnalyzer.cxx.

602 {
603 
604  // We immediately return if this module is disabled
605  //
606  if (!m_moduleEnabled[side][module]) {
607  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Skipping analysis of disabled module for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
608 
609  return;
610  }
611 
612  (*m_msgFunc_p)(ZDCMsg::Verbose, ("/n Loading data for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
613 
614  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
615  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples);
616  m_dataLoaded[side][module] = true;
617 
618  if (pulseAna_p->failed()) {
619  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer::LoadData() returned fail for event " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
620 
621  m_fail[side] = true;
622  }
623 
624  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
625 }

◆ LoadAndAnalyzeData() [2/2]

void ZDCDataAnalyzer::LoadAndAnalyzeData ( size_t  side,
size_t  module,
const std::vector< float > &  HGSamples,
const std::vector< float > &  LGSamples,
const std::vector< float > &  HGSamplesDelayed,
const std::vector< float > &  LGSamplesDelayed 
)

Definition at line 627 of file ZDCDataAnalyzer.cxx.

629 {
630  // We immediately return if this module is disabled
631  //
632  if (!m_moduleEnabled[side][module]) {
633  (*m_msgFunc_p)(ZDCMsg::Debug, ("Skipping analysis of disabled mofule for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
634 
635  return;
636  }
637 
638  if (m_delayedOrder[side][module] == 0) {
639  (*m_msgFunc_p)(ZDCMsg::Error, ("Handling of delayed pulses not enabled, on side, module = " + std::to_string(side) + ", " + std::to_string(module) + ", skipping processing for event index " + std::to_string(m_eventCount)));
640  return;
641  }
642 
643  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading undelayed and delayed data for event index " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
644 
645  ZDCPulseAnalyzer* pulseAna_p = m_moduleAnalyzers[side][module].get();
646  if (m_delayedOrder[side][module] > 0) {
647  pulseAna_p->LoadAndAnalyzeData(HGSamples, LGSamples, HGSamplesDelayed, LGSamplesDelayed);
648  }
649  else {
650  pulseAna_p->LoadAndAnalyzeData(HGSamplesDelayed, LGSamplesDelayed, HGSamples, LGSamples);
651  }
652  m_dataLoaded[side][module] = true;
653 
654  if (pulseAna_p->failed()) {
655  (*m_msgFunc_p)(ZDCMsg::Debug, ("ZDCPulseAnalyzer::LoadData() returned fail for event " + std::to_string(m_eventCount) + ", side, module = " + std::to_string(side) + ", " + std::to_string(module)));
656 
657  m_fail[side] = true;
658  }
659 
660  m_moduleStatus[side][module] = pulseAna_p->GetStatusMask();
661 }

◆ LoadEnergyCalibrations()

void ZDCDataAnalyzer::LoadEnergyCalibrations ( std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&  calibSplines)
inline

Definition at line 224 of file ZDCDataAnalyzer.h.

225  {
226  (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading energy calibrations");
227 
228  m_LBDepEcalibSplines = std::move (calibSplines);
229  m_haveECalib = true;
230  }

◆ LoadT0Calibrations()

void ZDCDataAnalyzer::LoadT0Calibrations ( std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&  T0HGOffsetSplines,
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > &&  T0LGOffsetSplines 
)
inline

Definition at line 232 of file ZDCDataAnalyzer.h.

234  {
235  (*m_msgFunc_p)(ZDCMsg::Verbose, "Loading timing calibrations");
236 
237  m_T0HGOffsetSplines = std::move (T0HGOffsetSplines);
238  m_T0LGOffsetSplines = std::move (T0LGOffsetSplines);
239 
240  m_haveT0Calib = true;
241  }

◆ ModuleDisabled()

bool ZDCDataAnalyzer::ModuleDisabled ( unsigned int  side,
unsigned int  module 
) const
inline

Definition at line 131 of file ZDCDataAnalyzer.h.

131 {return !m_moduleEnabled[side][module];}

◆ moduleEnabled()

bool ZDCDataAnalyzer::moduleEnabled ( unsigned int  side,
unsigned int  module 
) const
inline

Definition at line 132 of file ZDCDataAnalyzer.h.

132 {return m_moduleEnabled[side][module];}

◆ set2ndDerivStep()

void ZDCDataAnalyzer::set2ndDerivStep ( size_t  step)

Definition at line 306 of file ZDCDataAnalyzer.cxx.

307 {
308  for (size_t side : {0, 1}) {
309  for (size_t module : {0, 1, 2, 3}) {
310  m_moduleAnalyzers[side][module]->set2ndDerivStep(step);
311  }
312  }
313 }

◆ SetADCOverUnderflowValues()

void ZDCDataAnalyzer::SetADCOverUnderflowValues ( const ZDCModuleFloatArray &  HGOverflowADC,
const ZDCModuleFloatArray &  HGUnderflowADC,
const ZDCModuleFloatArray &  LGOverflowADC 
)

Definition at line 402 of file ZDCDataAnalyzer.cxx.

404 {
405  for (size_t side : {0, 1}) {
406  for (size_t module : {0, 1, 2, 3}) {
407  m_moduleAnalyzers[side][module]->SetADCOverUnderflowValues(HGOverflowADC[side][module], HGUnderflowADC[side][module], LGOverflowADC[side][module]);
408  }
409  }
410 }

◆ SetCutValues()

void ZDCDataAnalyzer::SetCutValues ( const ZDCModuleFloatArray &  chisqDivAmpCutHG,
const ZDCModuleFloatArray &  chisqDivAmpCutLG,
const ZDCModuleFloatArray &  deltaT0MinHG,
const ZDCModuleFloatArray &  deltaT0MaxHG,
const ZDCModuleFloatArray &  deltaT0MinLG,
const ZDCModuleFloatArray &  deltaT0MaxLG 
)

Definition at line 412 of file ZDCDataAnalyzer.cxx.

415 {
416  for (size_t side : {0, 1}) {
417  for (size_t module : {0, 1, 2, 3}) {
418  m_moduleAnalyzers[side][module]->SetCutValues(chisqDivAmpCutHG[side][module], chisqDivAmpCutLG[side][module],
419  deltaT0MinHG[side][module], deltaT0MaxHG[side][module],
420  deltaT0MinLG[side][module], deltaT0MaxLG[side][module]);
421  }
422  }
423 }

◆ SetFitMinMaxAmpValues() [1/2]

void ZDCDataAnalyzer::SetFitMinMaxAmpValues ( const ZDCModuleFloatArray &  minAmpHG,
const ZDCModuleFloatArray &  minAmpLG,
const ZDCModuleFloatArray &  maxAmpHG,
const ZDCModuleFloatArray &  maxAmpLG 
)

Definition at line 381 of file ZDCDataAnalyzer.cxx.

383 {
384  for (size_t side : {0, 1}) {
385  for (size_t module : {0, 1, 2, 3}) {
386  m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minAmpHG[side][module], minAmpLG[side][module],
387  maxAmpHG[side][module], maxAmpLG[side][module]);
388 
389  }
390  }
391 }

◆ SetFitMinMaxAmpValues() [2/2]

void ZDCDataAnalyzer::SetFitMinMaxAmpValues ( float  minHG,
float  minLG,
float  maxHG,
float  maxLG 
)

Definition at line 393 of file ZDCDataAnalyzer.cxx.

394 {
395  for (size_t side : {0, 1}) {
396  for (size_t module : {0, 1, 2, 3}) {
397  m_moduleAnalyzers[side][module]->SetFitMinMaxAmp(minHG, minLG, maxHG, maxLG);
398  }
399  }
400 }

◆ SetFitTimeMax()

void ZDCDataAnalyzer::SetFitTimeMax ( float  tmax)

Definition at line 342 of file ZDCDataAnalyzer.cxx.

342  {
343  for (size_t side : {0, 1}) {
344  for (size_t module : {0, 1, 2, 3}) {
345  m_moduleAnalyzers[side][module]->SetFitTimeMax(tmax);
346  }
347  }
348 }

◆ SetGainFactorsHGLG() [1/2]

void ZDCDataAnalyzer::SetGainFactorsHGLG ( const ZDCModuleFloatArray &  gainFactorsHG,
const ZDCModuleFloatArray &  gainFactorsLG 
)

Definition at line 324 of file ZDCDataAnalyzer.cxx.

325 {
326  for (size_t side : {0, 1}) {
327  for (size_t module : {0, 1, 2, 3}) {
328  m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorsHG[side][module], gainFactorsLG[side][module]);
329  }
330  }
331 }

◆ SetGainFactorsHGLG() [2/2]

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

Definition at line 315 of file ZDCDataAnalyzer.cxx.

316 {
317  for (size_t side : {0, 1}) {
318  for (size_t module : {0, 1, 2, 3}) {
319  m_moduleAnalyzers[side][module]->SetGainFactorsHGLG(gainFactorHG, gainFactorLG);
320  }
321  }
322 }

◆ setMinimumSignificance()

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

Definition at line 297 of file ZDCDataAnalyzer.cxx.

298 {
299  for (size_t side : {0, 1}) {
300  for (size_t module : {0, 1, 2, 3}) {
301  m_moduleAnalyzers[side][module]->setMinimumSignificance(sigMinHG, sigMinLG);
302  }
303  }
304 }

◆ SetModuleAmpFractionLG()

void ZDCDataAnalyzer::SetModuleAmpFractionLG ( const ZDCDataAnalyzer::ZDCModuleFloatArray &  moduleAmpFractionLG)

Definition at line 373 of file ZDCDataAnalyzer.cxx.

373  {
374  for (size_t side : {0, 1}) {
375  for (size_t module : {0, 1, 2, 3}) {
376  m_moduleAmpFractionLG[side][module] = moduleAmpFractionLG[side][module];
377  }
378  }
379 }

◆ SetNLcalibParams()

void ZDCDataAnalyzer::SetNLcalibParams ( std::array< std::array< std::array< float, 6 >, 3 >, 2 > &  nlcalibParams)

Definition at line 451 of file ZDCDataAnalyzer.cxx.

452 {
453  for (size_t side: {0,1})
454  {
455  for (size_t module: {0,1,2})
456  {
457  for (size_t val: {0,1,2,3,4,5})
458  {
459  m_NLcalibFactors[side][module][val] = nlcalibParams[side][module][val];
460  }
461  }
462  }
463  m_haveNLcalib = true;
464 }

◆ SetNoiseSigmas()

void ZDCDataAnalyzer::SetNoiseSigmas ( const ZDCModuleFloatArray &  noiseSigmasHG,
const ZDCModuleFloatArray &  noiseSigmasLG 
)

Definition at line 364 of file ZDCDataAnalyzer.cxx.

365 {
366  for (size_t side : {0, 1}) {
367  for (size_t module : {0, 1, 2, 3}) {
368  m_moduleAnalyzers[side][module]->SetNoiseSigmas(noiseSigmasHG[side][module], noiseSigmasLG[side][module]);
369  }
370  }
371 }

◆ SetNonlinCorrParams()

void ZDCDataAnalyzer::SetNonlinCorrParams ( float  refADC,
float  refScale,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  HGNonlinCorrParams,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  LHGNonlinCorrParams 
)

Definition at line 438 of file ZDCDataAnalyzer.cxx.

441 {
442  for (size_t side : {0, 1}) {
443  for (size_t module : {0, 1, 2, 3}) {
444  m_moduleAnalyzers[side][module]->SetNonlinCorrParams(refADC, refScale,
445  HGNonlinCorrParams[side][module],
446  LGNonlinCorrParams[side][module]);
447  }
448  }
449 }

◆ SetPeak2ndDerivMinTolerances()

void ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances ( size_t  tolerance)

Definition at line 333 of file ZDCDataAnalyzer.cxx.

333  {
334  for (size_t side : {0, 1}) {
335  for (size_t module : {0, 1, 2, 3}) {
336  m_moduleAnalyzers[side][module]->SetPeak2ndDerivMinTolerance(tolerance);
337  }
338  }
339 }

◆ SetSaveFitFunc()

void ZDCDataAnalyzer::SetSaveFitFunc ( bool  save)

◆ SetTauT0Values()

void ZDCDataAnalyzer::SetTauT0Values ( const ZDCModuleBoolArray &  fxiTau1,
const ZDCModuleBoolArray &  fxiTau2,
const ZDCModuleFloatArray &  tau1,
const ZDCModuleFloatArray &  tau2,
const ZDCModuleFloatArray &  t0HG,
const ZDCModuleFloatArray &  t0LG 
)

Definition at line 352 of file ZDCDataAnalyzer.cxx.

355 {
356  for (size_t side : {0, 1}) {
357  for (size_t module : {0, 1, 2, 3}) {
358  m_moduleAnalyzers[side][module]->SetTauT0Values(fixTau1[side][module], fixTau2[side][module],
359  tau1[side][module], tau2[side][module], t0HG[side][module], t0LG[side][module]);
360  }
361  }
362 }

◆ SetTimingCorrParams()

void ZDCDataAnalyzer::SetTimingCorrParams ( ZDCPulseAnalyzer::TimingCorrMode  mode,
float  refADC,
float  refScale,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  HGParamArr,
const std::array< std::array< std::vector< float >, 4 >, 2 > &  LGParamArr 
)

Definition at line 425 of file ZDCDataAnalyzer.cxx.

428 {
429  for (size_t side : {0, 1}) {
430  for (size_t module : {0, 1, 2, 3}) {
431  m_moduleAnalyzers[side][module]->SetTimingCorrParams(mode, refADC, refScale,
432  HGParamArr.at(side).at(module), LGParamArr.at(side).at(module));
433  }
434  }
435 
436 }

◆ SideFailed()

bool ZDCDataAnalyzer::SideFailed ( size_t  side) const
inline

Definition at line 151 of file ZDCDataAnalyzer.h.

151 {return m_fail.at(side);}

◆ StartEvent()

void ZDCDataAnalyzer::StartEvent ( int  lumiBlock)

Definition at line 502 of file ZDCDataAnalyzer.cxx.

503 {
504  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new event, event index = " + std::to_string(m_eventCount)));
505 
506  // By default we perform quiet pulse fits
507  //
508  /*
509  if ((*m_msgFunc_p)(ZDCMsg::Verbose, "")) {
510  invokeAll([](ZDCPulseAnalyzer* pa){pa->setQuietFits();});
511  }
512  else {
513  invokeAll([](ZDCPulseAnalyzer* pa){pa->setQuietFits();});
514  }
515  */
516 
517  // See if we have to load up new calibrations
518  //
519  if (lumiBlock != m_currentLB) {
520  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Starting new luminosity block " + std::to_string(lumiBlock)));
521 
522  if (m_haveECalib) {
523  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading energy calibrations for event " + std::to_string(m_eventCount) + ", lumi block " +
524  std::to_string(lumiBlock)));
525 
526  for (size_t side : {0, 1}) {
527  for (size_t module : {0, 1, 2, 3}) {
528  float splineLBMin = m_LBDepEcalibSplines[side][module]->GetXmin();
529  float splineLBMax = m_LBDepEcalibSplines[side][module]->GetXmax();
530 
531  if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
532  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(lumiBlock);
533  }
534  else if (lumiBlock < splineLBMin) {
535  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMin);
536  }
537  else {
538  m_currentECalibCoeff[side][module] = m_LBDepEcalibSplines[side][module]->Eval(splineLBMax);
539  }
540  }
541  }
542  } // end of if (_haveEcalib) {
543 
544  if (m_haveT0Calib) {
545  (*m_msgFunc_p)(ZDCMsg::Verbose, ("Loading timing calibrations for event " + std::to_string(m_eventCount) + ", lumi block " + std::to_string(lumiBlock)));
546 
547  for (size_t side : {0, 1}) {
548  for (size_t module : {0, 1, 2, 3}) {
549  float splineLBMin = m_T0HGOffsetSplines[side][module]->GetXmin();
550  float splineLBMax = m_T0HGOffsetSplines[side][module]->GetXmax();
551 
552  if (lumiBlock >= splineLBMin && lumiBlock <= splineLBMax) {
553  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(lumiBlock);
554  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(lumiBlock);
555  }
556  else if (lumiBlock < splineLBMin) {
557  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMin);
558  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMin);
559  }
560  else {
561  m_currentT0OffsetsHG[side][module] = m_T0HGOffsetSplines[side][module]->Eval(splineLBMax);
562  m_currentT0OffsetsLG[side][module] = m_T0LGOffsetSplines[side][module]->Eval(splineLBMax);
563  }
564  }
565  }
566  } // end of if (m_haveT0Calib)
567  }
568 
569  // Initialize transient results
570  //
571  for (size_t side : {0, 1}) {
572  for (size_t module : {0, 1, 2, 3}) {
573  m_dataLoaded[side][module] = false;
574  m_moduleStatus[side][module] = 0;
575  m_calibAmplitude[side][module] = 0;
576  m_calibTime[side][module] = 0;
577  // _moduleFail[side][module] = false;
578  }
579 
580  m_moduleSum[side] = 0;
581  m_moduleSumErrSq[side] = 0;
582  m_moduleSumPreSample[side] = 0;
583  m_moduleSumBkgdFrac[side] = 0;
584 
585  m_calibModuleSum[side] = 0;
586  m_calibModuleSumErrSq[side] = 0;
587  m_calibModSumBkgdFrac[side] = 0;
588 
589  m_NLcalibModuleSum[side] = 0;
590  m_NLcalibModuleSumErrSq[side] = 0;
591  m_NLcalibModSumBkgdFrac[side] = 0;
592 
593  m_averageTime[side] = 0;
594  m_fail[side] = false;
595  }
596 
597  m_moduleMask = 0;
598  m_currentLB = lumiBlock;
599 }

Member Data Documentation

◆ JSONConfigParams

const ZDCJSONConfig::JSONParamList ZDCDataAnalyzer::JSONConfigParams
static
Initial value:
= {
{"moduleEnabled", {JSON::value_t::array, 4, true, false}},
{"iterativeCalibCorr", {JSON::value_t::array, 4, true, false}}
}

Definition at line 30 of file ZDCDataAnalyzer.h.

◆ m_averageTime

std::array<float, 2> ZDCDataAnalyzer::m_averageTime {}
private

Definition at line 86 of file ZDCDataAnalyzer.h.

◆ m_calibAmplitude

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_calibAmplitude {}
private

Definition at line 67 of file ZDCDataAnalyzer.h.

◆ m_calibModSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_calibModSumBkgdFrac {}
private

Definition at line 77 of file ZDCDataAnalyzer.h.

◆ m_calibModuleSum

std::array<float, 2> ZDCDataAnalyzer::m_calibModuleSum {}
private

Definition at line 75 of file ZDCDataAnalyzer.h.

◆ m_calibModuleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_calibModuleSumErrSq {}
private

Definition at line 76 of file ZDCDataAnalyzer.h.

◆ m_calibTime

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_calibTime {}
private

Definition at line 68 of file ZDCDataAnalyzer.h.

◆ m_currentECalibCoeff

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentECalibCoeff {}
private

Definition at line 58 of file ZDCDataAnalyzer.h.

◆ m_currentLB

int ZDCDataAnalyzer::m_currentLB {-1}
private

Definition at line 57 of file ZDCDataAnalyzer.h.

◆ m_currentT0OffsetsHG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsHG {}
private

Definition at line 59 of file ZDCDataAnalyzer.h.

◆ m_currentT0OffsetsLG

ZDCModuleFloatArray ZDCDataAnalyzer::m_currentT0OffsetsLG {}
private

Definition at line 60 of file ZDCDataAnalyzer.h.

◆ m_dataAnalyzerConfig

std::unique_ptr<ZDCJSONConfig> ZDCDataAnalyzer::m_dataAnalyzerConfig {}
private

Definition at line 34 of file ZDCDataAnalyzer.h.

◆ m_dataLoaded

std::array<std::array<bool, 4>, 2> ZDCDataAnalyzer::m_dataLoaded {}
private

Definition at line 62 of file ZDCDataAnalyzer.h.

◆ m_delayedOrder

std::array<std::array<int, 4>, 2> ZDCDataAnalyzer::m_delayedOrder {}
private

Definition at line 39 of file ZDCDataAnalyzer.h.

◆ m_eventCount

int ZDCDataAnalyzer::m_eventCount {0}
private

Definition at line 44 of file ZDCDataAnalyzer.h.

◆ m_fail

std::array<bool, 2> ZDCDataAnalyzer::m_fail {}
private

Definition at line 87 of file ZDCDataAnalyzer.h.

◆ m_haveECalib

bool ZDCDataAnalyzer::m_haveECalib {false}
private

Definition at line 49 of file ZDCDataAnalyzer.h.

◆ m_haveNLcalib

bool ZDCDataAnalyzer::m_haveNLcalib {false}
private

Definition at line 79 of file ZDCDataAnalyzer.h.

◆ m_haveT0Calib

bool ZDCDataAnalyzer::m_haveT0Calib {false}
private

Definition at line 50 of file ZDCDataAnalyzer.h.

◆ m_HGGains

ZDCModuleFloatArray ZDCDataAnalyzer::m_HGGains {}
private

Definition at line 46 of file ZDCDataAnalyzer.h.

◆ m_LBDepEcalibSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_LBDepEcalibSplines {}
private

Definition at line 51 of file ZDCDataAnalyzer.h.

◆ m_moduleAmpFractionLG

std::array<std::array<float, 4>, 2> ZDCDataAnalyzer::m_moduleAmpFractionLG {}
private

Definition at line 89 of file ZDCDataAnalyzer.h.

◆ m_moduleAnalyzers

std::array<std::array<std::unique_ptr<ZDCPulseAnalyzer>, 4>, 2> ZDCDataAnalyzer::m_moduleAnalyzers {}
private

Definition at line 42 of file ZDCDataAnalyzer.h.

◆ m_moduleEnabled

ZDCModuleBoolArray ZDCDataAnalyzer::m_moduleEnabled {}
private

Definition at line 41 of file ZDCDataAnalyzer.h.

◆ m_moduleMask

unsigned int ZDCDataAnalyzer::m_moduleMask {0}
private

Definition at line 64 of file ZDCDataAnalyzer.h.

◆ m_moduleStatus

std::array<std::array<unsigned int, 4>, 2> ZDCDataAnalyzer::m_moduleStatus {}
private

Definition at line 66 of file ZDCDataAnalyzer.h.

◆ m_moduleSum

std::array<float, 2> ZDCDataAnalyzer::m_moduleSum {}
private

Definition at line 70 of file ZDCDataAnalyzer.h.

◆ m_moduleSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumBkgdFrac {}
private

Definition at line 73 of file ZDCDataAnalyzer.h.

◆ m_moduleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumErrSq {}
private

Definition at line 71 of file ZDCDataAnalyzer.h.

◆ m_moduleSumPreSample

std::array<float, 2> ZDCDataAnalyzer::m_moduleSumPreSample {}
private

Definition at line 72 of file ZDCDataAnalyzer.h.

◆ m_msgFunc_p

ZDCMsg::MessageFunctionPtr ZDCDataAnalyzer::m_msgFunc_p
private

Definition at line 33 of file ZDCDataAnalyzer.h.

◆ m_NLcalibFactors

std::array< std::array< std::array<float,6>, 3>, 2> ZDCDataAnalyzer::m_NLcalibFactors {}
private

Definition at line 80 of file ZDCDataAnalyzer.h.

◆ m_NLcalibModSumBkgdFrac

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModSumBkgdFrac {}
private

Definition at line 84 of file ZDCDataAnalyzer.h.

◆ m_NLcalibModuleSum

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModuleSum {}
private

Definition at line 82 of file ZDCDataAnalyzer.h.

◆ m_NLcalibModuleSumErrSq

std::array<float, 2> ZDCDataAnalyzer::m_NLcalibModuleSumErrSq {}
private

Definition at line 83 of file ZDCDataAnalyzer.h.

◆ m_pedestals

ZDCModuleFloatArray ZDCDataAnalyzer::m_pedestals {}
private

Definition at line 47 of file ZDCDataAnalyzer.h.

◆ m_pulseAnalyzerConfig

std::unique_ptr<ZDCJSONConfig> ZDCDataAnalyzer::m_pulseAnalyzerConfig {}
private

Definition at line 35 of file ZDCDataAnalyzer.h.

◆ m_repassEnabled

bool ZDCDataAnalyzer::m_repassEnabled {false}
private

Definition at line 37 of file ZDCDataAnalyzer.h.

◆ m_T0HGOffsetSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_T0HGOffsetSplines {}
private

Definition at line 52 of file ZDCDataAnalyzer.h.

◆ m_T0LGOffsetSplines

std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> ZDCDataAnalyzer::m_T0LGOffsetSplines {}
private

Definition at line 53 of file ZDCDataAnalyzer.h.

The documentation for this class was generated from the following files:
ZDCDataAnalyzer::m_T0LGOffsetSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0LGOffsetSplines
Definition: ZDCDataAnalyzer.h:53
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZDCDataAnalyzer::m_calibAmplitude
std::array< std::array< float, 4 >, 2 > m_calibAmplitude
Definition: ZDCDataAnalyzer.h:67
ZDCDataAnalyzer::m_dataLoaded
std::array< std::array< bool, 4 >, 2 > m_dataLoaded
Definition: ZDCDataAnalyzer.h:62
ZDCDataAnalyzer::m_moduleMask
unsigned int m_moduleMask
Definition: ZDCDataAnalyzer.h:64
get_generator_info.result
result
Definition: get_generator_info.py:21
ZDCPulseAnalyzer::ReanalyzeData
bool ReanalyzeData()
Definition: ZDCPulseAnalyzer.cxx:832
ZDCDataAnalyzer::m_moduleAnalyzers
std::array< std::array< std::unique_ptr< ZDCPulseAnalyzer >, 4 >, 2 > m_moduleAnalyzers
Definition: ZDCDataAnalyzer.h:42
ZDCDataAnalyzer::m_moduleEnabled
ZDCModuleBoolArray m_moduleEnabled
Definition: ZDCDataAnalyzer.h:41
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:638
ZDCPulseAnalyzer::LGOverflow
bool LGOverflow() const
Definition: ZDCPulseAnalyzer.h:598
ZDCPulseAnalyzer::GetStatusMask
unsigned int GetStatusMask() const
Definition: ZDCPulseAnalyzer.cxx:2223
ZDCDataAnalyzer::m_repassEnabled
bool m_repassEnabled
Definition: ZDCDataAnalyzer.h:37
ZDCDataAnalyzer::m_moduleSum
std::array< float, 2 > m_moduleSum
Definition: ZDCDataAnalyzer.h:70
ZDCDataAnalyzer::m_T0HGOffsetSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_T0HGOffsetSplines
Definition: ZDCDataAnalyzer.h:52
Root::AND
@ AND
Definition: TGRLCollection.h:32
athena.value
value
Definition: athena.py:124
ZDCPulseAnalyzer::useLowGain
bool useLowGain() const
Definition: ZDCPulseAnalyzer.h:592
ZDCPulseAnalyzer::armSumInclude
bool armSumInclude() const
Definition: ZDCPulseAnalyzer.h:612
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
ZDCPulseAnalyzer::GetAmplitude
float GetAmplitude() const
Definition: ZDCPulseAnalyzer.h:637
ZDCDataAnalyzer::m_NLcalibModuleSum
std::array< float, 2 > m_NLcalibModuleSum
Definition: ZDCDataAnalyzer.h:82
MuonR4::to_string
std::string to_string(const SectorProjector proj)
Definition: MsTrackSeeder.cxx:66
ZDCMsg::Info
@ Info
Definition: ZDCMsg.h:20
ZDCDataAnalyzer::m_haveNLcalib
bool m_haveNLcalib
Definition: ZDCDataAnalyzer.h:79
ZDCDataAnalyzer::m_msgFunc_p
ZDCMsg::MessageFunctionPtr m_msgFunc_p
Definition: ZDCDataAnalyzer.h:33
ZDCPulseAnalyzer::GetT0Corr
float GetT0Corr() const
Definition: ZDCPulseAnalyzer.h:624
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ZDCPulseAnalyzer::LoadAndAnalyzeData
bool LoadAndAnalyzeData(const std::vector< float > &ADCSamplesHG, const std::vector< float > &ADCSamplesLG)
Definition: ZDCPulseAnalyzer.cxx:755
ZDCDataAnalyzer::m_calibTime
std::array< std::array< float, 4 >, 2 > m_calibTime
Definition: ZDCDataAnalyzer.h:68
python.PyAthena.module
module
Definition: PyAthena.py:131
ZDCDataAnalyzer::m_haveECalib
bool m_haveECalib
Definition: ZDCDataAnalyzer.h:49
ZDCMsg::Verbose
@ Verbose
Definition: ZDCMsg.h:18
ZDCDataAnalyzer::m_eventCount
int m_eventCount
Definition: ZDCDataAnalyzer.h:44
ZDCDataAnalyzer::m_moduleSumBkgdFrac
std::array< float, 2 > m_moduleSumBkgdFrac
Definition: ZDCDataAnalyzer.h:73
ZDCDataAnalyzer::m_haveT0Calib
bool m_haveT0Calib
Definition: ZDCDataAnalyzer.h:50
ZDCDataAnalyzer::m_fail
std::array< bool, 2 > m_fail
Definition: ZDCDataAnalyzer.h:87
ZDCDataAnalyzer::m_calibModuleSumErrSq
std::array< float, 2 > m_calibModuleSumErrSq
Definition: ZDCDataAnalyzer.h:76
ZDCDataAnalyzer::m_averageTime
std::array< float, 2 > m_averageTime
Definition: ZDCDataAnalyzer.h:86
ZDCDataAnalyzer::m_dataAnalyzerConfig
std::unique_ptr< ZDCJSONConfig > m_dataAnalyzerConfig
Definition: ZDCDataAnalyzer.h:34
lumiFormat.i
int i
Definition: lumiFormat.py:85
ZDCDataAnalyzer::m_pedestals
ZDCModuleFloatArray m_pedestals
Definition: ZDCDataAnalyzer.h:47
ZDCDataAnalyzer::m_currentLB
int m_currentLB
Definition: ZDCDataAnalyzer.h:57
ZDCDataAnalyzer::m_moduleSumPreSample
std::array< float, 2 > m_moduleSumPreSample
Definition: ZDCDataAnalyzer.h:72
Preparation.mode
mode
Definition: Preparation.py:107
ZDCDataAnalyzer::m_calibModuleSum
std::array< float, 2 > m_calibModuleSum
Definition: ZDCDataAnalyzer.h:75
ZDCDataAnalyzer::m_NLcalibFactors
std::array< std::array< std::array< float, 6 >, 3 >, 2 > m_NLcalibFactors
Definition: ZDCDataAnalyzer.h:80
ZDCPulseAnalyzer::JSONConfigParams
static const ZDCJSONConfig::JSONParamList JSONConfigParams
Definition: ZDCPulseAnalyzer.h:71
ZDCDataAnalyzer::m_calibModSumBkgdFrac
std::array< float, 2 > m_calibModSumBkgdFrac
Definition: ZDCDataAnalyzer.h:77
ZDCDataAnalyzer::init
void init()
Definition: ZDCDataAnalyzer.cxx:170
lumiFormat.array
array
Definition: lumiFormat.py:91
ZDCMsg::Error
@ Error
Definition: ZDCMsg.h:22
tolerance
Definition: suep_shower.h:17
ZDCDataAnalyzer::m_NLcalibModSumBkgdFrac
std::array< float, 2 > m_NLcalibModSumBkgdFrac
Definition: ZDCDataAnalyzer.h:84
ZDCDataAnalyzer::m_moduleSumErrSq
std::array< float, 2 > m_moduleSumErrSq
Definition: ZDCDataAnalyzer.h:71
ZDCDataAnalyzer::m_currentT0OffsetsHG
ZDCModuleFloatArray m_currentT0OffsetsHG
Definition: ZDCDataAnalyzer.h:59
ZDCPulseAnalyzer::failed
bool failed() const
Definition: ZDCPulseAnalyzer.h:593
JSON
ZDCJSONConfig::JSON JSON
Definition: ZDCPulseAnalyzer.cxx:20
ZDCDataAnalyzer::m_moduleStatus
std::array< std::array< unsigned int, 4 >, 2 > m_moduleStatus
Definition: ZDCDataAnalyzer.h:66
ZDCDataAnalyzer::DoNLcalibModuleSum
void DoNLcalibModuleSum()
Definition: ZDCDataAnalyzer.cxx:768
CXXUTILS_TRAPPING_FP
CXXUTILS_TRAPPING_FP
Definition: SegmentLineFitter.cxx:8
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:716
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
ZDCDataAnalyzer::m_currentECalibCoeff
ZDCModuleFloatArray m_currentECalibCoeff
Definition: ZDCDataAnalyzer.h:58
ZDCDataAnalyzer::m_NLcalibModuleSumErrSq
std::array< float, 2 > m_NLcalibModuleSumErrSq
Definition: ZDCDataAnalyzer.h:83
ZDCDataAnalyzer::m_currentT0OffsetsLG
ZDCModuleFloatArray m_currentT0OffsetsLG
Definition: ZDCDataAnalyzer.h:60
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:130
ZDCDataAnalyzer::getPulseAnalyzerGlobalPar
bool getPulseAnalyzerGlobalPar(const std::string &key, T &value)
Definition: ZDCDataAnalyzer.h:106
ZDCDataAnalyzer::m_LBDepEcalibSplines
std::array< std::array< std::unique_ptr< TSpline >, 4 >, 2 > m_LBDepEcalibSplines
Definition: ZDCDataAnalyzer.h:51
LArCellBinning.step
step
Definition: LArCellBinning.py:158
ZDCMsg::Debug
@ Debug
Definition: ZDCMsg.h:19
ZDCMsg::Fatal
@ Fatal
Definition: ZDCMsg.h:23
ZDCDataAnalyzer::m_HGGains
ZDCModuleFloatArray m_HGGains
Definition: ZDCDataAnalyzer.h:46
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:328
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
ZDCPulseAnalyzer::havePulse
bool havePulse() const
Definition: ZDCPulseAnalyzer.h:591
ZDCDataAnalyzer::m_pulseAnalyzerConfig
std::unique_ptr< ZDCJSONConfig > m_pulseAnalyzerConfig
Definition: ZDCDataAnalyzer.h:35
ZDCDataAnalyzer::JSONConfigParams
static const ZDCJSONConfig::JSONParamList JSONConfigParams
Definition: ZDCDataAnalyzer.h:30
ZDCDataAnalyzer::m_moduleAmpFractionLG
std::array< std::array< float, 4 >, 2 > m_moduleAmpFractionLG
Definition: ZDCDataAnalyzer.h:89
ZDCDataAnalyzer::m_delayedOrder
std::array< std::array< int, 4 >, 2 > m_delayedOrder
Definition: ZDCDataAnalyzer.h:39
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:715
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Wed Nov 19 2025 21:56:46 for ATLAS Offline Software by   doxygen 1.8.18