ATLAS Offline Software
ZdcAnalysisTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "ZdcAnalysis/ZdcAnalysisTool.h"
6 #include "TGraph.h"
7 #include "TEnv.h"
8 #include "TSystem.h"
9 #include "ZdcAnalysis/ZdcSincInterp.h"
10 #include "xAODEventInfo/EventInfo.h"
11 #include "TFile.h"
12 #include <sstream>
13 #include <memory>
14 #include <xAODForward/ZdcModuleAuxContainer.h>
15 #include "PathResolver/PathResolver.h"
16 #include <AsgDataHandles/ReadHandle.h>
17 #include <AsgDataHandles/WriteHandle.h>
18 #include <AsgDataHandles/WriteDecorHandle.h>
19 #include "AthContainers/ConstAccessor.h"
20 
21 namespace ZDC
22 {
23 ZdcAnalysisTool::ZdcAnalysisTool(const std::string& name)
24  : asg::AsgTool(name), m_name(name), m_init(false),
25  m_writeAux(false), m_eventReady(false),
26  m_runNumber(0), m_lumiBlock(0),
27  m_zdcTriggerEfficiency(0)
28 {
29 
30 #ifndef XAOD_STANDALONE
31  declareInterface<IZdcAnalysisTool>(this);
32 #endif
33 
34  declareProperty("ZdcModuleContainerName", m_zdcModuleContainerName = "ZdcModules", "Location of ZDC processed data");
35  declareProperty("ZdcSumContainerName", m_zdcSumContainerName = "ZdcSums", "Location of ZDC processed sums");
36  declareProperty("Configuration", m_configuration = "PbPb2015");
37  declareProperty("FlipEMDelay", m_flipEMDelay = false);
38  declareProperty("LowGainOnly", m_lowGainOnly = false);
39  declareProperty("WriteAux", m_writeAux = true);
40  declareProperty("AuxSuffix", m_auxSuffix = "");
41 
42  // The following job properties enable/disable and affect the calibration of the ZDC energies
43  //
44  declareProperty("DoCalib", m_doCalib = true);
45  declareProperty("CalibVersion", m_calibVersion = "");
46  declareProperty("DoTrigEff", m_doTrigEff = true);
47  declareProperty("DoTimeCalib", m_doTimeCalib = true);
48  declareProperty("ZdcAnalysisConfigPath", m_zdcAnalysisConfigPath = "$ROOTCOREBIN/data/ZdcAnalysis", "ZDC Analysis config file path");
49  //declareProperty("ForceCalibRun",m_forceCalibRun=287931); // last run of Pb+Pb 2015
50  declareProperty("ForceCalibRun", m_forceCalibRun = -1); // last run of Pb+Pb 2015
51  declareProperty("ForceCalibLB", m_forceCalibLB = 814); // last LB of Pb+Pb 2015
52 
53  // The following parameters are primarily used for the "default" configuration, but also may be
54  // use to modify/tailor other configurations
55  //
56  declareProperty("NumSampl", m_numSample = 7);
57  declareProperty("DeltaTSample", m_deltaTSample = 25);
58  declareProperty("Presample", m_presample = 0);
59  declareProperty("CombineDelay", m_combineDelay = false);
60  declareProperty("DelayDeltaT", m_delayDeltaT = -12.5);
61 
62  declareProperty("PeakSample", m_peakSample = 11);
63  declareProperty("Peak2ndDerivThresh", m_Peak2ndDerivThresh = 20);
64 
65  declareProperty("T0", m_t0 = 30);
66  declareProperty("Tau1", m_tau1 = 5);
67  declareProperty("Tau2", m_tau2 = 25);
68  declareProperty("FixTau1", m_fixTau1 = false);
69  declareProperty("FixTau2", m_fixTau2 = false);
70 
71  declareProperty("DeltaTCut", m_deltaTCut = 10);
72  declareProperty("ChisqRatioCut", m_ChisqRatioCut = 10);
73 
74  declareProperty("RpdNbaselineSamples", m_rpdNbaselineSamples = 7, "Number of baseline samples; the sample equal to this number is the start of signal region");
75  declareProperty("RpdEndSignalSample", m_rpdEndSignalSample = 23, "Samples before (not including) this sample are the signal region; 0 or Nsamples goes to end of window");
76  declareProperty("RpdPulse2ndDerivThresh", m_rpdPulse2ndDerivThresh = -18, "Second differences less than or equal to this number indicate a pulse");
77  declareProperty("RpdPostPulseFracThresh", m_rpdPostPulseFracThresh = 0.15, "If there is a good pulse and post-pulse and size of post-pulse as a fraction of good pulse is less than or equal to this number, ignore post-pulse");
78  declareProperty("RpdGoodPulseSampleStart", m_rpdGoodPulseSampleStart = 8, "Pulses before this sample are considered pre-pulses");
79  declareProperty("RpdGoodPulseSampleStop", m_rpdGoodPulseSampleStop = 10, "Pulses after this sample are considered post-pulses");
80  declareProperty("RpdNominalBaseline", m_rpdNominalBaseline = 100, "The global nominal baseline; used when pileup is detected");
81  declareProperty("RpdPileupBaselineSumThresh", m_rpdPileupBaselineSumThresh = 53, "Baseline sum (after subtracting nominal baseline) less than this number indicates there is NO pileup");
82  declareProperty("RpdPileupBaselineStdDevThresh", m_rpdPileupBaselineStdDevThresh = 2, "Baseline standard deviations less than this number indicate there is NO pileup");
83  declareProperty("RpdNNegativesAllowed", m_rpdNNegativesAllowed = 2, "Maximum number of negative ADC values after baseline and pileup subtraction allowed in signal range");
84  declareProperty("RpdAdcOverflow", m_rpdAdcOverflow = 4095, "ADC values greater than or equal to this number are considered overflow");
85  declareProperty("RpdSideCCalibFactors", m_rpdSideCOutputCalibFactors = std::vector<float>(16, 1.0), "Multiplicative calibration factors to apply to RPD output, e.g., sum/max ADC, per channel on side C");
86  declareProperty("RpdSideACalibFactors", m_rpdSideAOutputCalibFactors = std::vector<float>(16, 1.0), "Multiplicative calibration factors to apply to RPD output, e.g., sum/max ADC, per channel on side A");
87 
88  declareProperty("LHCRun", m_LHCRun = 3);
89 
90 }
91 
92 ZdcAnalysisTool::~ZdcAnalysisTool()
93 {
94  ATH_MSG_DEBUG("Deleting ZdcAnalysisTool named " << m_name);
95 }
96 
97 void ZdcAnalysisTool::initializeTriggerEffs(unsigned int runNumber)
98 {
99  if (!m_doTrigEff) return;
100 
101  if (!m_zdcTriggerEfficiency)
102  {
103  ATH_MSG_DEBUG("Creating new ZDCTriggerEfficiency");
104  m_zdcTriggerEfficiency.reset (new ZDCTriggerEfficiency());
105  }
106 
107  std::string filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcTriggerEffParamsFileName) );
108  ATH_MSG_DEBUG ("Found trigger config file " << filename);
109  ATH_MSG_DEBUG("Opening trigger efficiency file " << filename);
110 
111  std::unique_ptr<TFile> file (TFile::Open(filename.c_str(), "READ"));
112  if (file == nullptr || file->IsZombie())
113  {
114  ATH_MSG_WARNING("No trigger efficiencies at " << filename);
115  return;
116  }
117 
118  //file->Print();
119 
120  ATH_MSG_DEBUG("Reading in trigger efficiencies");
121 
122  std::stringstream Aalpha_name;
123  Aalpha_name << "A_alpha_" << runNumber;
124  TSpline3* par_A_alpha = (TSpline3*)file->GetObjectChecked(Aalpha_name.str().c_str(), "TSpline3");
125 
126  if (!par_A_alpha)
127  {
128  ATH_MSG_WARNING("No trigger efficiencies for run number " << runNumber);
129  m_doCalib = false;
130  }
131 
132  std::stringstream Abeta_name;
133  Abeta_name << "A_beta_" << runNumber;
134  TSpline3* par_A_beta = (TSpline3*)file->GetObjectChecked(Abeta_name.str().c_str(), "TSpline3");
135  std::stringstream Atheta_name;
136  Atheta_name << "A_theta_" << runNumber;
137  TSpline3* par_A_theta = (TSpline3*)file->GetObjectChecked(Atheta_name.str().c_str(), "TSpline3");
138 
139  std::stringstream Calpha_name;
140  Calpha_name << "C_alpha_" << runNumber;
141  TSpline3* par_C_alpha = (TSpline3*)file->GetObjectChecked(Calpha_name.str().c_str(), "TSpline3");
142  std::stringstream Cbeta_name;
143  Cbeta_name << "C_beta_" << runNumber;
144  TSpline3* par_C_beta = (TSpline3*)file->GetObjectChecked(Cbeta_name.str().c_str(), "TSpline3");
145  std::stringstream Ctheta_name;
146  Ctheta_name << "C_theta_" << runNumber;
147  TSpline3* par_C_theta = (TSpline3*)file->GetObjectChecked(Ctheta_name.str().c_str(), "TSpline3");
148 
149  std::stringstream Err_Aalpha_name;
150  Err_Aalpha_name << "A_alpha_error_" << runNumber;
151  TSpline3* parErr_A_alpha = (TSpline3*)file->GetObjectChecked(Err_Aalpha_name.str().c_str(), "TSpline3");
152  std::stringstream Err_Abeta_name;
153  Err_Abeta_name << "A_beta_error_" << runNumber;
154  TSpline3* parErr_A_beta = (TSpline3*)file->GetObjectChecked(Err_Abeta_name.str().c_str(), "TSpline3");
155  std::stringstream Err_Atheta_name;
156  Err_Atheta_name << "A_theta_error_" << runNumber;
157  TSpline3* parErr_A_theta = (TSpline3*)file->GetObjectChecked(Err_Atheta_name.str().c_str(), "TSpline3");
158 
159  std::stringstream Err_Calpha_name;
160  Err_Calpha_name << "C_alpha_error_" << runNumber;
161  TSpline3* parErr_C_alpha = (TSpline3*)file->GetObjectChecked(Err_Calpha_name.str().c_str(), "TSpline3");
162  std::stringstream Err_Cbeta_name;
163  Err_Cbeta_name << "C_beta_error_" << runNumber;
164  TSpline3* parErr_C_beta = (TSpline3*)file->GetObjectChecked(Err_Cbeta_name.str().c_str(), "TSpline3");
165  std::stringstream Err_Ctheta_name;
166  Err_Ctheta_name << "C_theta_error_" << runNumber;
167  TSpline3* parErr_C_theta = (TSpline3*)file->GetObjectChecked(Err_Ctheta_name.str().c_str(), "TSpline3");
168 
169 
170  std::stringstream Cov_A_alpha_beta_name;
171  Cov_A_alpha_beta_name << "cov_A_alpha_beta_" << runNumber;
172  TSpline3* cov_A_alpha_beta = (TSpline3*)file->GetObjectChecked(Cov_A_alpha_beta_name.str().c_str(), "TSpline3");
173  std::stringstream Cov_A_alpha_theta_name;
174  Cov_A_alpha_theta_name << "cov_A_alpha_theta_" << runNumber;
175  TSpline3* cov_A_alpha_theta = (TSpline3*)file->GetObjectChecked(Cov_A_alpha_theta_name.str().c_str(), "TSpline3");
176  std::stringstream Cov_A_beta_theta_name;
177  Cov_A_beta_theta_name << "cov_A_beta_theta_" << runNumber;
178  TSpline3* cov_A_beta_theta = (TSpline3*)file->GetObjectChecked(Cov_A_beta_theta_name.str().c_str(), "TSpline3");
179 
180  std::stringstream Cov_C_alpha_beta_name;
181  Cov_C_alpha_beta_name << "cov_C_alpha_beta_" << runNumber;
182  TSpline3* cov_C_alpha_beta = (TSpline3*)file->GetObjectChecked(Cov_C_alpha_beta_name.str().c_str(), "TSpline3");
183  std::stringstream Cov_C_alpha_theta_name;
184  Cov_C_alpha_theta_name << "cov_C_alpha_theta_" << runNumber;
185  TSpline3* cov_C_alpha_theta = (TSpline3*)file->GetObjectChecked(Cov_C_alpha_theta_name.str().c_str(), "TSpline3");
186  std::stringstream Cov_C_beta_theta_name;
187  Cov_C_beta_theta_name << "cov_C_beta_theta_" << runNumber;
188  TSpline3* cov_C_beta_theta = (TSpline3*)file->GetObjectChecked(Cov_C_beta_theta_name.str().c_str(), "TSpline3");
189 
190  std::array<std::vector<TSpline3*>, 2> effparams;
191  std::array<std::vector<TSpline3*>, 2> effparamErrors;
192  std::array<std::vector<TSpline3*>, 2> effparamsCorrCoeffs;
193  //side0: C; side1: A
194  effparams[0] = {par_C_alpha, par_C_beta, par_C_theta};
195  effparams[1] = {par_A_alpha, par_A_beta, par_A_theta};
196  effparamErrors[0] = {parErr_C_alpha, parErr_C_beta, parErr_C_theta};
197  effparamErrors[1] = {parErr_A_alpha, parErr_A_beta, parErr_A_theta};
198  effparamsCorrCoeffs[0] = {cov_C_alpha_beta, cov_C_alpha_theta, cov_C_beta_theta};
199  effparamsCorrCoeffs[1] = {cov_A_alpha_beta, cov_A_alpha_theta, cov_A_beta_theta};
200 
201  ATH_MSG_DEBUG("Trying to set parameters and errors at " << m_zdcTriggerEfficiency);
202 
203  m_zdcTriggerEfficiency->SetEffParamsAndErrors(effparams, effparamErrors);
204  m_zdcTriggerEfficiency->SetEffParamCorrCoeffs(effparamsCorrCoeffs);
205 
206  return;
207 
208 }
209 
210 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializeLHCf2022()
211 {
212 
213  m_deltaTSample = 3.125;
214  m_numSample = 24;
215 
216  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{0, 9, 9, 9}, {0, 9, 10, 8}}};
217 
218  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
219  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
220  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
221 
222  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{0, 1.1, 1.1, 1.1},
223  {0, 1.1, 1.1, 1.1}}};
224 
225  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{6, 5, 5, 5}, {5.5, 5.5, 5.5, 5.5}}};
226 
227  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{0, 26.3, 26.5, 26.8}, {32, 32, 32, 32}}};
228 
229  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{0, 31.1, 28.1, 27.0}, {0, 26.6, 26.3, 25.3}}};
230 
231  for (size_t side : {0, 1}) {
232  for (size_t module : {0, 1, 2, 3}) {
233  fixTau1Arr[side][module] = true;
234  fixTau2Arr[side][module] = false;
235 
236  peak2ndDerivMinThresholdsHG[side][module] = -35;
237  peak2ndDerivMinThresholdsLG[side][module] = -16;
238 
239  deltaT0CutLow[side][module] = -10;
240  deltaT0CutHigh[side][module] = 10;
241  chisqDivAmpCut[side][module] = 20;
242  }
243  }
244 
245  ATH_MSG_DEBUG( "LHCF2022: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
246 
247  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
248  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
249  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
250 
251  // For the LHCf run, use low gain samples
252  //
253  m_lowGainOnly = true;
254 
255  // Construct the data analyzer
256  //
257  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
258  m_numSample, m_deltaTSample,
259  m_presample, "FermiExpLHCf",
260  peak2ndDerivMinSamples,
261  peak2ndDerivMinThresholdsHG,
262  peak2ndDerivMinThresholdsLG,
263  m_lowGainOnly));
264 
265  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(2);
266  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
267  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
268  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
269 
270  zdcDataAnalyzer->SetGainFactorsHGLG(0.1, 1); // a gain adjustment of unity applied to LG ADC, 0.1 to HG ADC values
271 
272  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
273  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{20, 20, 20, 20}, {20, 20, 20, 20}}};
274 
275  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
276 
277  // Enable two-pass analysis
278  //
279  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
280  {-12, -12, -12, -12}}};
281 
282  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
283  {-8, -8, -8, -8}}};
284 
285  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
286 
287  // Set the amplitude fit range limits
288  //
289  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
290 
291  // disable EM module on each side
292  zdcDataAnalyzer->disableModule(0, 0);
293  zdcDataAnalyzer->disableModule(1, 0);
294 
295 
296  RPDConfig rpdConfig{};
297  rpdConfig.nRows = 4;
298  rpdConfig.nColumns = 4;
299  rpdConfig.nSamples = m_numSample;
300  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
301  rpdConfig.endSignalSample = m_rpdEndSignalSample;
302  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
303  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
304  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
305  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
306  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
307  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
308  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
309  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
310  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
311  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
312  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
313 
314  return zdcDataAnalyzer;
315 
316 }
317 
318 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializepp2023()
319 {
320 
321  m_deltaTSample = 3.125;
322  m_numSample = 24;
323 
324  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
325 
326  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
327  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
328  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
329 
330  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
331  {1.1, 1.1, 1.1, 1.1}}};
332 
333  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{5.5, 5.5, 5.5, 5.5}, {5.5, 5.5, 5.5, 5.5}}};
334 
335  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
336 
337  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{36, 36, 36, 36}, {36, 36, 36, 36}}};
338 
339  const int deriv2ndThreshDSHG = -35;
340  const int deriv2ndThreshDSLG = -10;
341 
342  const float deltaTcutLow = -10;
343  const float deltaTcutHigh = 10;
344  const float chisqDivAmpCutVal = 10;
345 
346  for (size_t side : {0, 1}) {
347  for (size_t module : {0, 1, 2, 3}) {
348  fixTau1Arr[side][module] = true;
349  fixTau2Arr[side][module] = false;
350 
351  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
352  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
353 
354  deltaT0CutLow[side][module] = deltaTcutLow;
355  deltaT0CutHigh[side][module] = deltaTcutHigh;
356  chisqDivAmpCut[side][module] = chisqDivAmpCutVal;
357  }
358  }
359 
360  ATH_MSG_DEBUG( "pp2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
361 
362  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
363  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
364  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
365 
366  // Construct the data analyzer
367  //
368  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
369  m_numSample, m_deltaTSample,
370  m_presample, "FermiExpLHCf",
371  peak2ndDerivMinSamples,
372  peak2ndDerivMinThresholdsHG,
373  peak2ndDerivMinThresholdsLG,
374  m_lowGainOnly));
375 
376  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
377  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
378  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
379  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
380 
381  zdcDataAnalyzer->SetGainFactorsHGLG(1, 10); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
382 
383  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{0.5, 0.5, 0.5, 0.5}, {0.5, 0.5, 0.5, 0.5}}};
384  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{2, 2, 2, 2}, {2, 2, 2, 2}}};
385 
386  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
387 
388  // Enable two-pass analysis
389  //
390  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-12, -12, -12, -12},
391  {-12, -12, -12, -12}}};
392 
393  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
394  {-8, -8, -8, -8}}};
395 
396  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
397 
398  // Set the amplitude fit range limits
399  //
400  zdcDataAnalyzer->SetFitMinMaxAmpValues(5, 2, 5000, 5000);
401 
402 
403  RPDConfig rpdConfig{};
404  rpdConfig.nRows = 4;
405  rpdConfig.nColumns = 4;
406  rpdConfig.nSamples = m_numSample;
407  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
408  rpdConfig.endSignalSample = m_rpdEndSignalSample;
409  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
410  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
411  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
412  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
413  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
414  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
415  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
416  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
417  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
418  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
419  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
420 
421  return zdcDataAnalyzer;
422 
423 }
424 
425 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializePbPb2023()
426 {
427  // Key configuration parameters needed for the data analyzer construction
428  //
429  m_deltaTSample = 3.125;
430  m_numSample = 24;
431 
432  const int deriv2ndThreshDSHG = -25;
433  const int deriv2ndThreshDSLG = -10;
434  const unsigned int peakSample = 10;
435 
436  const float deltaTcutLow = -10;
437  const float deltaTcutHigh = 10;
438  const float chisqDivAmpCutHGVal = 30;
439  const float chisqDivAmpCutLGVal = 50;
440 
441  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
442  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
443 
444  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{};
445  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG{}, chisqDivAmpCutLG{};
446  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
447 
448  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{1.1, 1.1, 1.1, 1.1},
449  {1.1, 1.1, 1.1, 1.1}}};
450 
451  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{4.4, 4.7, 4.5, 4.6}, {4.8, 4.6, 4.4, 4.2}}};
452 
453  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
454  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{31.25, 31.25, 31.25, 31.25}, {31.25, 31.25, 31.25, 31.25}}};
455 
456  for (size_t side : {0, 1}) {
457  for (size_t module : {0, 1, 2, 3}) {
458  fixTau1Arr[side][module] = true;
459  fixTau2Arr[side][module] = false;
460 
461  peak2ndDerivMinSamples[side][module] = peakSample;
462  peak2ndDerivMinThresholdsHG[side][module] = deriv2ndThreshDSHG;
463  peak2ndDerivMinThresholdsLG[side][module] = deriv2ndThreshDSLG;
464 
465  deltaT0CutLow[side][module] = deltaTcutLow;
466  deltaT0CutHigh[side][module] = deltaTcutHigh;
467  chisqDivAmpCutLG[side][module] = chisqDivAmpCutLGVal;
468  chisqDivAmpCutHG[side][module] = chisqDivAmpCutHGVal;
469  }
470  }
471 
472  ATH_MSG_DEBUG( "PbPb2023: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
473 
474  // Construct the data analyzer
475  //
476  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(),
477  m_numSample, m_deltaTSample,
478  m_presample, "FermiExpLHCf",
479  peak2ndDerivMinSamples,
480  peak2ndDerivMinThresholdsHG,
481  peak2ndDerivMinThresholdsLG,
482  m_lowGainOnly));
483  zdcDataAnalyzer->set2ndDerivStep(2);
484  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(3);
485 
486  ZDCDataAnalyzer::ZDCModuleFloatArray gainsHG = {{{1, 1, 1, 1},{1, 1, 1, 1}}};
487  ZDCDataAnalyzer::ZDCModuleFloatArray gainsLG = {{{9.63, 9.29, 10.08, 9.34},{9.79, 9.45, 9.94, 10.36}}};
488 
489  zdcDataAnalyzer->SetGainFactorsHGLG(gainsHG, gainsLG); // a gain adjustment of 10 applied to LG ADC, 1 to HG ADC values
490 
491  // These noise sigmas we read off from the ch_x_BaselineStdev monitoring histograms with our
492  // final readout configuration for the Pb+Pb run by BAC on 25-09-2023
493  //
494  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1.0, 1.0, 1.0, 1.0}, {1.0, 1.0, 1.0, 1.0}}};
495  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{1.5, 1.7, 3, 1.7}, {1.7, 1.6, 2.2, 1.8}}};
496 
497  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
498 
499  // Now set cuts and default fit parameters
500  //
501  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{3500, 3500, 3500, 3500}}, {{3500, 3500, 3500, 3500}}}};
502  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{1, 1, 1, 1}}, {{1, 1, 1, 1}}}};
503  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{4000, 4000, 4000, 4000}}, {{4000, 4000, 4000, 4000}}}};
504 
505  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
506  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
507  zdcDataAnalyzer->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
508 
509  // Enable two-pass analysis
510  //
511  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassHG = {{{-10, -10, -10, -10},
512  {-10, -10, -10, -10}}};
513 
514  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinRepassLG = {{{-8, -8, -8, -8},
515  {-8, -8, -8, -8}}};
516 
517  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG);
518 
519  // Turn on exclusion of early and late samples to address OOT pileup
520  //
521  zdcDataAnalyzer->enablePreExclusion(4, 500, 200);
522  zdcDataAnalyzer->enablePostExclusion(4, 300, 200);
523 
524  // Set up non-linear corrections for the ZDC
525  //
526  std::array<std::array<std::vector<float>, 4>, 2> nonLinearCorrCoefficHG, nonLinearCorrCoefficLG;
527 
528  nonLinearCorrCoefficHG = {{ {{{-0.039464, 0.013250, -0.003676},
529  {-0.050573, 0.019664, -0.004340},
530  {-0.052816, 0.016221, -0.003364},
531  {-0.014327, 0.000226, -0.000943}}},
532  {{{-0.059663, 0.019482, -0.004615},
533  {-0.036908, 0.008920, -0.002805},
534  {-0.046814, 0.019434, -0.004207},
535  {-0.060879, 0.026635, -0.004833}}} }};
536 
537  // For now we don't use corrections on the LG as it's much harder to measure them
538  //
539  nonLinearCorrCoefficLG = {{ {{{0},
540  {0},
541  {0},
542  {0}}},
543  {{{0},
544  {0},
545  {0},
546  {0}}} }};
547 
548  zdcDataAnalyzer->SetNonlinCorrParams(0, 1000, nonLinearCorrCoefficHG, nonLinearCorrCoefficLG);
549 
550  std::array<std::array<std::vector<float>, 4>, 2> timeCorrCoefficHG, timeCorrCoefficLG;
551  timeCorrCoefficHG[0][0] = {0.07, -0.020672, 0.070206, 0.004961, -0.010821, -0.001835};
552  timeCorrCoefficHG[0][1] = {0.04, -0.012961, 0.008204, 0.010771, 0.011593, 0.002045};
553  timeCorrCoefficHG[0][2] = {0.04, 0.017393, 0.017597, 0.003736, -0.001696, -0.000465};
554  timeCorrCoefficHG[0][3] = {0.04, 0.018463, 0.009862, -0.000277, -0.000268, 0.000192};
555 
556  timeCorrCoefficHG[1][0] = {0.13, -0.106068, 0.078153, 0.034479, -0.004964, -0.001688};
557  timeCorrCoefficHG[1][1] = {0.03, -0.007518, 0.008937, 0.015319, 0.012290, 0.001889};
558  timeCorrCoefficHG[1][2] = {-0.01, 0.006711, -0.001652, -0.004223, -0.000573, 0.000161};
559  timeCorrCoefficHG[1][3] = {0.015, 0.017993, 0.006339, 0.003122, 0.002980, 0.000735};
560 
561  timeCorrCoefficLG[0][0] = {0.035, -0.126189, 0.022724, 0.039116, -0.098255};
562  timeCorrCoefficLG[0][1] = {0.022, -0.165988, -0.014125, 0.057323, -0.205109};
563  timeCorrCoefficLG[0][2] = {0.01, -0.136087, -0.007248, -0.014452, -0.060469};
564  timeCorrCoefficLG[0][3] = {0.0, -0.131067, 0.025579, 0.059994, -0.065595};
565 
566  timeCorrCoefficLG[1][0] = {0.076, -0.300587, -0.041827, 0.641108, -0.594157};
567  timeCorrCoefficLG[1][1] = {0.057, -0.223443, -0.125013, -0.176900, 0.348081};
568  timeCorrCoefficLG[1][2] = {0.015, -0.141721, 0.023936, 0.099657, -0.188526};
569  timeCorrCoefficLG[1][3] = {0.01, -0.152589, 0.016122, -0.086580, 0.563625};
570 
571  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLog, 0, 700, timeCorrCoefficHG, timeCorrCoefficLG);
572 
573  // Set the amplitude fit range limits
574  //
575  zdcDataAnalyzer->SetFitMinMaxAmpValues(2, 2, 6000, 6000);
576 
577  RPDConfig rpdConfig{};
578  rpdConfig.nRows = 4;
579  rpdConfig.nColumns = 4;
580  rpdConfig.nSamples = m_numSample;
581  rpdConfig.nBaselineSamples = m_rpdNbaselineSamples;
582  rpdConfig.endSignalSample = m_rpdEndSignalSample;
583  rpdConfig.pulse2ndDerivThresh = m_rpdPulse2ndDerivThresh;
584  rpdConfig.postPulseFracThresh = m_rpdPostPulseFracThresh;
585  rpdConfig.goodPulseSampleStart = m_rpdGoodPulseSampleStart;
586  rpdConfig.goodPulseSampleStop = m_rpdGoodPulseSampleStop;
587  rpdConfig.nominalBaseline = m_rpdNominalBaseline;
588  rpdConfig.pileupBaselineSumThresh = m_rpdPileupBaselineSumThresh;
589  rpdConfig.pileupBaselineStdDevThresh = m_rpdPileupBaselineStdDevThresh;
590  rpdConfig.nNegativesAllowed = m_rpdNNegativesAllowed;
591  rpdConfig.AdcOverflow = m_rpdAdcOverflow;
592  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdC", rpdConfig, m_rpdSideCOutputCalibFactors));
593  m_rpdDataAnalyzer.push_back(std::make_unique<RPDDataAnalyzer>(MakeMessageFunction(), "rpdA", rpdConfig, m_rpdSideAOutputCalibFactors));
594 
595  return zdcDataAnalyzer;
596 }
597 
598 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializeDefault()
599 {
600  // We rely completely on the default parameters specified in the job properties to control:
601  // # samples
602  // frequency (more precisely, time/sample)
603  // which sample to use as the pre-sample
604  // where to expact the maxim of the peak (min 2nd derivative)
605  // thresholds on the 2nd derivative for valid pulses
606  // whether to fix the tau values in the pulse fitting
607  // the default tau values
608  // the nominal T0
609  // delta T and chisq/amp cuts
610  //
611  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
612  // For now we also use the FermiExp pulse model.
613  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
614  ZDCDataAnalyzer::ZDCModuleFloatArray tau1{}, tau2{}, t0{};
615  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
616  ZDCDataAnalyzer::ZDCModuleFloatArray deltaT0CutLow{}, deltaT0CutHigh{}, chisqDivAmpCut{};
617  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
618 
619  for (size_t side : {0, 1}) {
620  for (size_t module : {0, 1, 2, 3}) {
621  fixTau1Arr[side][module] = m_fixTau1;
622  fixTau2Arr[side][module] = m_fixTau2;
623  tau1[side][module] = m_tau1;
624  tau2[side][module] = m_tau2;
625 
626  peak2ndDerivMinSamples[side][module] = m_peakSample;
627  peak2ndDerivMinThresholdsHG[side][module] = -m_Peak2ndDerivThresh;
628  peak2ndDerivMinThresholdsLG[side][module] = -m_Peak2ndDerivThresh / 2;
629 
630  t0[side][module] = m_t0;
631  deltaT0CutLow[side][module] = -m_deltaTCut;
632  deltaT0CutHigh[side][module] = m_deltaTCut;
633  chisqDivAmpCut[side][module] = m_ChisqRatioCut;
634  }
635  }
636 
637  ATH_MSG_DEBUG( "Default: delta t cut, value low = " << deltaT0CutLow[0][0] << ", high = " << deltaT0CutHigh[0][0] );
638 
639  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
640  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
641  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
642 
643  // Construct the data analyzer
644  //
645  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), m_numSample, m_deltaTSample, m_presample, "FermiExp", peak2ndDerivMinSamples,
646  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
647 
648  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
649  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0, t0);
650  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, deltaT0CutLow, deltaT0CutHigh, deltaT0CutLow, deltaT0CutHigh);
651 
652  if (m_combineDelay) {
653  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
654 
655  zdcDataAnalyzer->enableDelayed(m_delayDeltaT, defaultPedestalShifts);
656  }
657 
658  return zdcDataAnalyzer;
659 }
660 
661 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializePbPb2015G4()
662 {
663  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
664  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
665  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
666  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
667  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
668 
669  const int peakSample = 4;
670  const float peak2ndDerivThreshHG = -12;
671  const float peak2ndDerivThreshLG = -10;
672  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 4.000, 4.000, 4.000},
673  {4.000, 4.000, 4.000, 4.000}}};
674  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{25.36, 25.05, 25.43, 25.60},
675  {25.11, 25.08, 25.18, 25.48}}};
676 
677  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{57.31, 57.28, 57.30, 57.28},
678  {57.28, 57.29, 57.31, 57.33}}};
679  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{57.31, 57.28, 57.30, 57.28},
680  {57.28, 57.29, 57.31, 57.33}}};
681 
682  // Delta T0 cut
683  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
684  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
685  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{-10, -10, -10, -10}, {-10, -10, -10, -10}}};
686  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{ 10, 10, 10, 10}, { 10, 10, 10, 10}}};
687 
688  for (size_t side : {0, 1}) {
689  for (size_t module : {0, 1, 2, 3}) {
690  fixTau1Arr[side][module] = true;
691  fixTau2Arr[side][module] = true;
692 
693  peak2ndDerivMinSamples[side][module] = peakSample;
694  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
695  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
696 
697  chisqDivAmpCut[side][module] = 15;
698  }
699  }
700 
701  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{ 800, 800, 800, 800}}, {{ 800, 800, 800, 800}}}};
702  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{ 10, 10, 10, 10}}, {{ 10, 10, 10, 10}}}};
703  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
704 
705  m_deltaTSample = 12.5;
706 
707  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, m_deltaTSample, 0, "FermiExp", peak2ndDerivMinSamples,
708  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
709 
710  // Open up tolerances on the position of the peak for now
711  //
712  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
713 
714  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
715  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
716  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
717 
718  zdcDataAnalyzer->SetFitTimeMax(85);
719  zdcDataAnalyzer->SetSaveFitFunc(false);
720 
721  return zdcDataAnalyzer;
722 }
723 
724 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializepPb2016()
725 {
726  //
727  // For now, we continue to use hard-coded values for the maximum and minimum ADC values
728  // For now we also use the FermiExp pulse model.
729 
730  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
731  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{};
732  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
733  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
734 
735  // For now we allow the tau values to be controlled by the job properties until they are better determined
736  //
737  const int peakSample = 5;
738  const float peak2ndDerivThreshHG = -12;
739  const float peak2ndDerivThreshLG = -10;
740  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{4.000, 3.380, 3.661, 3.679},
741  {4.472, 4.656, 3.871, 4.061}
742  }};
743 
744  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{22, 24.81, 24.48, 24.45},
745  {24.17, 24.22, 25.46, 24.45}
746  }};
747 
748  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.00, 72.74, 73.09, 72.25},
749  {75.11, 74.94, 73.93, 74.45}
750  }};
751  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.00, 73.41, 74.27, 73.30},
752  {76.28, 76.07, 74.98, 76.54}
753  }};
754 
755  // Delta T0 cut
756  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
757  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
758  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
759  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
760 
761 
762  for (size_t side : {0, 1}) {
763  for (size_t module : {0, 1, 2, 3}) {
764  fixTau1Arr[side][module] = true;
765  fixTau2Arr[side][module] = true;
766 
767  peak2ndDerivMinSamples[side][module] = peakSample;
768  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
769  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
770 
771  chisqDivAmpCut[side][module] = 15;
772  }
773  }
774 
775  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
776  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
777  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
778 
779  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
780  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
781  slewingParamsHG[0][0] = {0, 0, 0, 0};
782  slewingParamsHG[0][1] = { -4.780244e-01, -7.150874e-02, 4.614585e-02, 8.015731e-04};
783  slewingParamsHG[0][2] = { -5.253412e-01, -5.718167e-02, 5.243121e-02, 2.128398e-03};
784  slewingParamsHG[0][3] = { -5.773952e-01, -5.687478e-02, 4.564267e-02, 1.462294e-03};
785 
786  slewingParamsHG[1][0] = { 7.105115e-01, -3.686143e-02, 7.727447e-02, 5.924152e-03};
787  slewingParamsHG[1][1] = { 4.052120e-02, 4.450686e-03, 8.031615e-02, 4.038097e-03};
788  slewingParamsHG[1][2] = { 3.389476e-02, -2.056782e-02, 4.805321e-02, -2.627999e-03};
789  slewingParamsHG[1][3] = { 2.069765e-01, -2.890419e-02, 6.084375e-02, 3.742011e-03};
790 
791  slewingParamsLG[0][0] = {0, 0, 0, 0};
792  slewingParamsLG[0][1] = { -1.632547e+00, -4.827813e-01, -1.379131e-01, -2.522607e-02};
793  slewingParamsLG[0][2] = { -7.254288e+00, -5.454064e+00, -1.619126e+00, -1.739665e-01};
794  slewingParamsLG[0][3] = { -1.548400e+01, -1.277708e+01, -3.729333e+00, -3.700458e-01};
795 
796  slewingParamsLG[1][0] = { 1.142767e-01, -3.608906e-02, 9.642735e-02, -3.097043e-03};
797  slewingParamsLG[1][1] = { -5.615388e-01, -1.655047e-02, 8.327350e-02, -4.231348e-03};
798  slewingParamsLG[1][2] = { -7.370728e-01, -2.887482e-02, 8.293875e-02, -4.482743e-03};
799  slewingParamsLG[1][3] = { -1.270636e+00, -2.791777e-01, -5.807295e-02, -2.332612e-02};
800 
801  // Construct the data analyzer
802  //
803  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
804  //
805  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples,
806  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
807 
808  // Open up tolerances on the position of the peak for now
809  //
810  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
811 
812  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
813  //
814  zdcDataAnalyzer->disableModule(0, 0);
815 
816  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
817  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
818  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
819 
820  // We allow the combineDelay to be controlled by the properties
821  //
822  // if (m_combineDelay) {
823  m_combineDelay = true;
824  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
825 
826  zdcDataAnalyzer->enableDelayed(-12.5, defaultPedestalShifts);
827  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting
828  zdcDataAnalyzer->SetSaveFitFunc(false);
829  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
830  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
831  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
832 
833  return zdcDataAnalyzer;
834 }
835 
836 std::unique_ptr<ZDCDataAnalyzer> ZdcAnalysisTool::initializePbPb2018()
837 {
838  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples{};
839  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG{}, peak2ndDerivMinThresholdsLG{}, peak2ndDerivMinRepassHG{}, peak2ndDerivMinRepassLG{};
840  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCut{};
841  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
842 
843  static constexpr int peakSample = 5;
844  static constexpr float peak2ndDerivThreshHG = -35;
845  static constexpr float peak2ndDerivThreshLG = -20;
846  static constexpr float peak2ndDerivRepassHG = -10;
847  static constexpr float peak2ndDerivRepassLG = -6;
848 
849  ZDCDataAnalyzer::ZDCModuleFloatArray tau1Arr = {{{3.877, 3.998, 3.821, 3.858},
850  {4.296, 4.064, 3.497, 3.642}
851  }};
852 
853  ZDCDataAnalyzer::ZDCModuleFloatArray tau2Arr = {{{24.40, 25.28, 25.66, 24.12},
854  {24.42, 24.99, 25.72, 25.29}
855  }};
856 
857  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{70.51, 70.57, 70.13, 69.98},
858  {74.18, 72.79, 71.77, 72.62}
859  }};
860  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{70.70, 70.78, 70.76, 70.91},
861  {75.16, 73.71, 72.25, 73.61}
862  }};
863 
864  ZDCDataAnalyzer::ZDCModuleFloatArray moduleAmpFractionLG = {{{0.2760, 0.3045, 0.2369, 0.1826},
865  {0.3216, 0.2593, 0.2511, 0.1680}
866  }};
867 
868  // Delta T0 cut
869  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
870  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
871  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{ -6, -5, -5, -5}, {-5, -5, -5, -5}}};
872  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{8, 8, 8, 11}, {8, 10, 8, 12}}};
873 
874  for (size_t side : {0, 1}) {
875  for (size_t module : {0, 1, 2, 3}) {
876  fixTau1Arr[side][module] = true;
877  fixTau2Arr[side][module] = true;
878 
879  peak2ndDerivMinSamples[side][module] = peakSample;
880  peak2ndDerivMinThresholdsHG[side][module] = peak2ndDerivThreshHG;
881  peak2ndDerivMinThresholdsLG[side][module] = peak2ndDerivThreshLG;
882  peak2ndDerivMinRepassHG [side][module] = peak2ndDerivRepassHG;
883  peak2ndDerivMinRepassLG [side][module] = peak2ndDerivRepassLG;
884 
885  chisqDivAmpCut[side][module] = 15;
886  }
887  }
888 
889  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
890  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
891  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
892 
893  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasLG = {{{1, 1, 1, 1}, {1, 1, 1, 1}}};
894  ZDCDataAnalyzer::ZDCModuleFloatArray noiseSigmasHG = {{{12, 12, 12, 12}, {12, 12, 12, 12}}};
895 
896 
897  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
898  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
899  slewingParamsHG[0][0] = { -1.335560e-01, -6.071869e-03, 5.858193e-02, 2.473300e-03};
900  slewingParamsHG[0][1] = { -1.223062e-01, -4.379469e-02, 4.452285e-02, 2.130210e-03};
901  slewingParamsHG[0][2] = { -1.021415e-01, -4.254239e-02, 4.939866e-02, 3.849738e-03};
902  slewingParamsHG[0][3] = { -8.234056e-02, -3.938803e-02, 4.689029e-02, 2.784816e-03};
903 
904  slewingParamsHG[1][0] = { -1.640979e-01, -2.780350e-02, 5.755065e-02, -4.244651e-04};
905  slewingParamsHG[1][1] = { -1.422324e-01, 2.663803e-02, 7.295366e-02, 3.740496e-03};
906  slewingParamsHG[1][2] = { -9.858124e-02, -2.426132e-02, 4.895967e-02, 2.291393e-03};
907  slewingParamsHG[1][3] = { -1.070401e-01, -2.256383e-03, 5.833770e-02, 2.255208e-03};
908 
909  slewingParamsLG[0][0] = { -2.588446e-01, -3.241086e-02, 7.828661e-02, 1.945547e-03};
910  slewingParamsLG[0][1] = { -3.112495e-01, -7.419508e-02, 6.825776e-02, 2.148860e-03};
911  slewingParamsLG[0][2] = { -3.470650e-01, -5.836748e-02, 6.204396e-02, 1.550421e-03};
912  slewingParamsLG[0][3] = { -4.485435e-01, -4.603790e-02, 5.944799e-02, -1.174585e-03};
913 
914  slewingParamsLG[1][0] = { -3.291676e-01, -4.023732e-02, 8.608755e-02, -3.958167e-03};
915  slewingParamsLG[1][1] = { -2.608969e-01, -2.129786e-03, 6.930791e-02, -4.141910e-03};
916  slewingParamsLG[1][2] = { -2.505712e-01, -2.195804e-02, 5.137261e-02, -4.058378e-03};
917  slewingParamsLG[1][3] = { -5.083206e-01, 3.776601e-02, 1.284275e-01, 1.014067e-02};
918 
919  // Construct the data analyzer
920  //
921  // We adopt hard-coded values for the number of samples and the frequency which we kept fixed for all physics data
922  //
923  std::unique_ptr<ZDCDataAnalyzer> zdcDataAnalyzer = std::make_unique<ZDCDataAnalyzer>(MakeMessageFunction(), 7, 25, 0, "FermiExpLinear", peak2ndDerivMinSamples, // presample index changed to zero 4/6/19
924  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly);
925 
926  // Open up tolerances on the position of the peak for now
927  //
928  zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(1);
929 
930  // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
931  //
932 
933  zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
934  zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0HG, t0LG);
935  zdcDataAnalyzer->SetModuleAmpFractionLG(moduleAmpFractionLG); // fraction calculation for LGOverflows added Nov 23, 2020
936  zdcDataAnalyzer->SetCutValues(chisqDivAmpCut, chisqDivAmpCut, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
937 
938  // We allow the combineDelay to be controlled by the properties
939  //
940  m_combineDelay = true;
941  ZDCDataAnalyzer::ZDCModuleFloatArray defaultPedestalShifts = {{{{0, 0, 0, 0}}, {{0, 0, 0, 0}}}};
942 
943  // We use per-module delays to handle the delayed-undelayed swap on EMC
944  //
945  ZDCDataAnalyzer::ZDCModuleFloatArray delayDeltaTs = {{{{12.5, -12.5, -12.5, -12.5}},
946  {{ -12.5, -12.5, -12.5, -12.5}}
947  }
948  };
949 
950  zdcDataAnalyzer->enableDelayed(delayDeltaTs, defaultPedestalShifts);
951  zdcDataAnalyzer->SetFitTimeMax(140); // This restrict the fit range of the pulse fitting, requested by BAC 4/6/19
952  zdcDataAnalyzer->SetSaveFitFunc(false);
953  zdcDataAnalyzer->enableRepass(peak2ndDerivMinRepassHG, peak2ndDerivMinRepassLG); // add repass as default Jul 21 2020 Bill
954  zdcDataAnalyzer->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
955  slewingParamsHG, slewingParamsLG); // add time slewing correction Sep 17 2019 Bill
956  // ref. https://indico.cern.ch/event/849143/contributions/3568263/attachments/1909759/3155352/ZDCWeekly_20190917_PengqiYin.pdf
957 
958  zdcDataAnalyzer->SetNoiseSigmas(noiseSigmasHG, noiseSigmasLG);
959 
960  return zdcDataAnalyzer;
961 }
962 
963 void ZdcAnalysisTool::initialize40MHz()
964 {
965  // We have a complete configuration and so we override all of the default parameters
966  //
967 
968  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{4.2, 3.8, 5.2, 5.0}},
969  {{5.0, 3.7, 3.5, 3.5}}
970  }
971  };
972 
973  // identical to 80 MHz -- is this right
974  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
975  {{19.1, 21.9, 22.6, 23.4}}
976  }
977  };
978 
979  ZDCDataAnalyzer::ZDCModuleIntArray peak2ndDerivMinSamples = {{{{1, 1, 2, 1}},
980  {{1, 1, 1, 1}}
981  }
982  };
983 
984  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
985  {{ -8, -8, -8, -8}}
986  }
987  };
988 
989  ZDCDataAnalyzer::ZDCModuleFloatArray peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
990  {{ -4, -4, -4, -4}}
991  }
992  };
993 
994  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
995  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
996  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{1020, 1020, 1020, 1020}}, {{1020, 1020, 1020, 1020}}}};
997 
998  // Set Tau and nominal timing offsets
999  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1000 
1001  bool fixTau1 = true;
1002  bool fixTau2 = true;
1003 
1004  for (size_t side : {0, 1}) {
1005  for (size_t module : {0, 1, 2, 3}) {
1006  fixTau1Arr[side][module] = fixTau1;
1007  fixTau2Arr[side][module] = fixTau2;
1008  }
1009  }
1010 
1011  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{53.942, 49.887, 59.633, 46.497}},
1012  {{46.314, 42.267, 50.327, 41.605}}
1013  }
1014  };
1015  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{51.771, 47.936, 57.438, 44.191}},
1016  {{44.295, 41.755, 48.081, 40.175}}
1017  }
1018  };
1019 
1020 
1021  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1022  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1023  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1024  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1025  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1026  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1027 
1028  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1029 
1030  slewingParamsHG[0][0] = {0, -7.904e-02, 4.686e-02, 1.530e-03 };
1031  slewingParamsHG[0][1] = {0, 2.250e-02, 4.732e-02, 6.050e-03 };
1032  slewingParamsHG[0][2] = {0, 4.388e-02, 6.707e-02, -5.526e-05 };
1033  slewingParamsHG[0][3] = {0, 1.205e-01, 2.726e-02, 2.610e-03 };
1034 
1035  slewingParamsHG[1][0] = {0, 6.861e-02, 5.175e-03, -9.018e-04 };
1036  slewingParamsHG[1][1] = {0, 3.855e-01, -4.442e-02, -2.022e-02 };
1037  slewingParamsHG[1][2] = {0, -4.337e-03, 3.841e-02, 4.661e-03 };
1038  slewingParamsHG[1][3] = {0, 3.623e-01, -3.882e-02, -1.805e-02 };
1039 
1040  slewingParamsLG[0][0] = {0, 1.708e-02, 7.929e-02, 5.079e-03 };
1041  slewingParamsLG[0][1] = {0, 1.406e-01, 1.209e-01, -1.922e-04 };
1042  slewingParamsLG[0][2] = {0, 1.762e-01, 1.118e-01, 1.679e-04 };
1043  slewingParamsLG[0][3] = {0, 1.361e-02, -2.685e-02, -4.168e-02 };
1044 
1045  slewingParamsLG[1][0] = {0, 1.962e-01, -5.025e-03, -2.001e-02 };
1046  slewingParamsLG[1][1] = {0, 3.258e-01, 1.229e-02, -2.925e-02 };
1047  slewingParamsLG[1][2] = {0, 1.393e-01, 8.113e-02, -2.594e-03 };
1048  slewingParamsLG[1][3] = {0, 1.939e-01, 2.188e-02, -5.579e-02 };
1049 
1050  m_zdcDataAnalyzer_40MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7, 25, 0, "FermiExp", peak2ndDerivMinSamples,
1051  peak2ndDerivMinThresholdsHG, peak2ndDerivMinThresholdsLG, m_lowGainOnly));
1052 
1053  m_zdcDataAnalyzer_40MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1054  m_zdcDataAnalyzer_40MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1055  m_zdcDataAnalyzer_40MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1056  m_zdcDataAnalyzer_40MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1057  slewingParamsHG, slewingParamsLG);
1058 
1059  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1060  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1061  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1062  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1063  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1064  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1065  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1066  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1067  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1068 
1069  moduleLGNonLinCorr = {{ {{{0},
1070  {0},
1071  {0},
1072  {0}}},
1073  {{{0},
1074  {0},
1075  {0},
1076  {0}}} }};
1077 
1078  m_zdcDataAnalyzer_40MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1079  m_zdcDataAnalyzer_40MHz->SetSaveFitFunc(false);
1080 
1081 }
1082 
1083 void ZdcAnalysisTool::initialize80MHz()
1084 {
1085  // We have a complete configuration and so we override all of the default parameters
1086  //
1087 
1088  m_peak2ndDerivMinSamples = {{{{3, 2, 3, 2}},
1089  {{2, 2, 2, 2}}
1090  }
1091  };
1092 
1093  m_peak2ndDerivMinThresholdsHG = {{{{ -8, -8, -8, -8}},
1094  {{ -8, -8, -8, -8}}
1095  }
1096  };
1097 
1098  m_peak2ndDerivMinThresholdsLG = {{{{ -4, -4, -4, -4}},
1099  {{ -4, -4, -4, -4}}
1100  }
1101  };
1102 
1103  ZDCDataAnalyzer::ZDCModuleFloatArray HGOverFlowADC = {{{{800, 800, 800, 800}}, {{800, 800, 800, 800}}}};
1104  ZDCDataAnalyzer::ZDCModuleFloatArray HGUnderFlowADC = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1105  ZDCDataAnalyzer::ZDCModuleFloatArray LGOverFlowADC = {{{{950, 950, 950, 950}}, {{950, 950, 950, 950}}}};
1106 
1107  // Set Tau and nominal timing offsets
1108  ZDCDataAnalyzer::ZDCModuleBoolArray fixTau1Arr{}, fixTau2Arr{};
1109 
1110  bool fixTau1 = true;
1111  bool fixTau2 = true;
1112 
1113  for (size_t side : {0, 1}) {
1114  for (size_t module : {0, 1, 2, 3}) {
1115  fixTau1Arr[side][module] = fixTau1;
1116  fixTau2Arr[side][module] = fixTau2;
1117  }
1118  }
1119 
1120  ZDCDataAnalyzer::ZDCModuleFloatArray tau1 = {{{{3.9, 3.4, 4.1, 4.2}},
1121  {{4.2, 3.6, 3.3, 3.4}}
1122  }
1123  };
1124 
1125  ZDCDataAnalyzer::ZDCModuleFloatArray tau2 = {{{{20.0, 20.4, 18.9, 20.8}},
1126  {{19.1, 21.9, 22.6, 23.4}}
1127  }
1128  };
1129 
1130  ZDCDataAnalyzer::ZDCModuleFloatArray t0HG = {{{{44.24, 40.35, 49.3, 36.0}},
1131  {{36.0, 31.1, 40.75, 30.5}}
1132  }
1133  };
1134 
1135  ZDCDataAnalyzer::ZDCModuleFloatArray t0LG = {{{{42.65, 38.5, 47.4, 34}},
1136  {{33.7, 29.9, 39.0, 29.3}}
1137  }
1138  };
1139 
1140  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutHG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1141  ZDCDataAnalyzer::ZDCModuleFloatArray chisqDivAmpCutLG = {{{{10, 10, 10, 10}}, {{10, 10, 10, 10}}}};
1142  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowHG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1143  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighHG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1144  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutLowLG = {{{{ -6, -5, -5, -5}}, {{ -5, -5, -5, -5}}}};
1145  ZDCDataAnalyzer::ZDCModuleFloatArray DeltaT0CutHighLG = {{{{8, 8, 8, 11}}, {{8, 10, 8, 12}}}};
1146 
1147  std::array<std::array<std::vector<float>, 4>, 2> slewingParamsHG, slewingParamsLG;
1148 
1149  slewingParamsHG[0][0] = {0, -6.5e-2, 2.85e-2, -2.83e-3};
1150  slewingParamsHG[0][1] = {0, -5.5e-2, 5.13e-2, 5.6e-3};
1151  slewingParamsHG[0][2] = {0, -1.45e-3, 9.3e-2, 3.9e-3};
1152  slewingParamsHG[0][3] = {0, -2.36e-2, 8.3e-2, 1.1e-3};
1153 
1154  slewingParamsHG[1][0] = {0, -6.5e-2, 4.84e-2, -3.7e-3};
1155  slewingParamsHG[1][1] = {0, 1.34e-2, 6.57e-2, 5.37e-3};
1156  slewingParamsHG[1][2] = {0, -5.37e-2, 3.49e-2, 3.8e-3};
1157  slewingParamsHG[1][3] = {0, -3.3e-2, 3.9e-2, 2.2e-3};
1158 
1159  slewingParamsLG[0][0] = {0, -9.6e-2, 4.39e-2, 2.93e-3 };
1160  slewingParamsLG[0][1] = {0, -5.0e-2, 14.9e-2, 20.6e-3 };
1161  slewingParamsLG[0][2] = {0, -4.4e-2, 5.3e-2, 0, };
1162  slewingParamsLG[0][3] = {0, -9.90e-2, 4.08e-2, 0, };
1163 
1164  slewingParamsLG[1][0] = {0, -8.7e-2, 4.2e-2, -3.2e-3 };
1165  slewingParamsLG[1][1] = {0, -3.26e-2, 3.84e-2, -2.32e-3};
1166  slewingParamsLG[1][2] = {0, -26.8e-2, -2.64e-2, -5.3e-3 };
1167  slewingParamsLG[1][3] = {0, -13.2e-2, 0.45e-2, -2.4e-3 };
1168 
1169 
1170  m_zdcDataAnalyzer_80MHz.reset (new ZDCDataAnalyzer(MakeMessageFunction(), 7 , 12.5, 0, "FermiExp", m_peak2ndDerivMinSamples,
1171  m_peak2ndDerivMinThresholdsHG, m_peak2ndDerivMinThresholdsLG, m_lowGainOnly));
1172 
1173  m_zdcDataAnalyzer_80MHz->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
1174  m_zdcDataAnalyzer_80MHz->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1, tau2, t0HG, t0LG);
1175  m_zdcDataAnalyzer_80MHz->SetCutValues(chisqDivAmpCutHG, chisqDivAmpCutLG, DeltaT0CutLowHG, DeltaT0CutHighHG, DeltaT0CutLowLG, DeltaT0CutHighLG);
1176  m_zdcDataAnalyzer_80MHz->SetTimingCorrParams(ZDCPulseAnalyzer::TimingCorrLin, 500, 100,
1177  slewingParamsHG, slewingParamsLG);
1178 
1179  std::array<std::array<std::vector<float>, 4>, 2> moduleHGNonLinCorr, moduleLGNonLinCorr;
1180  moduleHGNonLinCorr[0][0] = { -3.76800e-02, 4.63597e-02};
1181  moduleHGNonLinCorr[0][1] = { -1.02185e-01, -1.17548e-01};
1182  moduleHGNonLinCorr[0][2] = { -8.78451e-02, -1.52174e-01};
1183  moduleHGNonLinCorr[0][3] = { -1.04835e-01, -1.96514e-01};
1184  moduleHGNonLinCorr[1][0] = { -6.83115e-02, 3.57802e-02};
1185  moduleHGNonLinCorr[1][1] = { -1.08162e-01, -1.91413e-01};
1186  moduleHGNonLinCorr[1][2] = { -7.82514e-02, -1.21218e-01};
1187  moduleHGNonLinCorr[1][3] = { -2.34354e-02, -2.52033e-01};
1188 
1189  moduleLGNonLinCorr = {{ {{{0},
1190  {0},
1191  {0},
1192  {0}}},
1193  {{{0},
1194  {0},
1195  {0},
1196  {0}}} }};
1197 
1198  m_zdcDataAnalyzer_80MHz->SetNonlinCorrParams(500, 1000, moduleHGNonLinCorr, moduleLGNonLinCorr);
1199  m_zdcDataAnalyzer_80MHz->SetSaveFitFunc(false);
1200 }
1201 
1202 StatusCode ZdcAnalysisTool::initialize()
1203 {
1204  m_tf1SincInterp.reset (new TF1("SincInterp", ZDC::SincInterp, -5., 160., 8));
1205  m_tf1SincInterp->SetNpx(300);
1206 
1207  // Set up calibrations
1208  //
1209  std::string filename = PathResolverFindCalibFile( "ZdcAnalysis/ZdcAnalysisConfig.conf" );
1210  TEnv env(filename.c_str());
1211 
1212  m_zdcEnergyCalibFileName = std::string(env.GetValue("ZdcEnergyCalibFileName", "ZdcCalibrations_v1.root"));
1213  ATH_MSG_INFO("ZDC energy calibration filename " << m_zdcEnergyCalibFileName);
1214  m_zdcTimeCalibFileName = std::string(env.GetValue("ZdcTimeCalibFileName", "ZdcTimeCalibrations_v1.root"));
1215  ATH_MSG_INFO("ZDC time calibration filename " << m_zdcTimeCalibFileName);
1216  m_zdcTriggerEffParamsFileName = std::string(env.GetValue("ZdcTriggerEffFileName", "ZdcTriggerEffParameters_v6.root"));
1217  ATH_MSG_INFO("ZDC trigger efficiencies filename " << m_zdcTriggerEffParamsFileName);
1218 
1219 
1220  if (m_forceCalibRun > -1) {
1221  ATH_MSG_DEBUG("CAREFUL: forcing calibration run/LB =" << m_forceCalibRun << "/" << m_forceCalibLB);
1222 
1223  if (m_forceCalibLB < 0) {
1224  ATH_MSG_ERROR("Invalid settings: Forced run > 0 but lumi block < 0");
1225  return StatusCode::FAILURE;
1226  }
1227  }
1228 
1229  // Use configuration to direct initialization
1230  //
1231  if (m_configuration == "default") {
1232  m_zdcDataAnalyzer = initializeDefault();
1233  }
1234  else if (m_configuration == "PbPb2015") {
1235  initialize80MHz();
1236  initialize40MHz();
1237 
1238  m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz; // default
1239  }
1240  else if (m_configuration == "pPb2016") {
1241  m_zdcDataAnalyzer = initializepPb2016();
1242  }
1243  else if (m_configuration == "PbPb2018") {
1244  m_zdcDataAnalyzer = initializePbPb2018();
1245  }
1246  else if (m_configuration == "PbPb2015G4") {
1247  m_zdcDataAnalyzer = initializePbPb2015G4();
1248  }
1249  else if (m_configuration == "LHCf2022") {
1250  m_zdcDataAnalyzer = initializeLHCf2022();
1251  }
1252  else if (m_configuration == "pp2023") {
1253  m_zdcDataAnalyzer = initializepp2023();
1254  }
1255  else if (m_configuration == "PbPb2023") {
1256  m_zdcDataAnalyzer = initializePbPb2023();
1257  }
1258  else {
1259  ATH_MSG_ERROR("Unknown configuration: " << m_configuration);
1260  return StatusCode::FAILURE;
1261  }
1262 
1263  // If an aux suffix is provided, prepend it with "_" so we don't have to do so at each use
1264  //
1265 
1266  ATH_MSG_INFO("Configuration: " << m_configuration);
1267  ATH_MSG_DEBUG("FlipEMDelay: " << m_flipEMDelay);
1268  ATH_MSG_DEBUG("LowGainOnly: " << m_lowGainOnly);
1269 
1270  ATH_MSG_DEBUG("Using Combined delayed and undelayed samples: " << m_combineDelay);
1271 
1272  ATH_MSG_DEBUG("WriteAux: " << m_writeAux);
1273  ATH_MSG_DEBUG("AuxSuffix: " << m_auxSuffix);
1274  ATH_MSG_DEBUG("DoCalib: " << m_doCalib);
1275  ATH_MSG_DEBUG("ForceCalibRun: " << m_forceCalibRun);
1276  ATH_MSG_DEBUG("ForceCalibLB: " << m_forceCalibLB);
1277  ATH_MSG_DEBUG("NumSampl: " << m_numSample);
1278  ATH_MSG_DEBUG("DeltaTSample: " << m_deltaTSample);
1279  ATH_MSG_DEBUG("Presample: " << m_presample);
1280  ATH_MSG_DEBUG("PeakSample: " << m_peakSample);
1281  ATH_MSG_DEBUG("Peak2ndDerivThresh: " << m_Peak2ndDerivThresh);
1282 
1283  if (m_combineDelay) ATH_MSG_DEBUG("DelayDeltaT: " << m_delayDeltaT);
1284 
1285  ATH_MSG_DEBUG("T0: " << m_t0);
1286  ATH_MSG_DEBUG("Tau1: " << m_tau1);
1287  ATH_MSG_DEBUG("Tau2: " << m_tau2);
1288  ATH_MSG_DEBUG("FixTau1: " << m_fixTau1);
1289  ATH_MSG_DEBUG("FixTau2: " << m_fixTau2);
1290  ATH_MSG_DEBUG("DeltaTCut: " << m_deltaTCut);
1291  ATH_MSG_DEBUG("ChisqRatioCut: " << m_ChisqRatioCut);
1292 
1293  ATH_CHECK( m_eventInfoKey.initialize());
1294 
1295  // Initialize decorations
1296 
1297  m_zdcModuleAmplitude = m_zdcModuleContainerName+".Amplitude"+m_auxSuffix;
1298  ATH_CHECK( m_zdcModuleAmplitude.initialize());
1299  m_zdcModuleCalibEnergy = m_zdcModuleContainerName+".CalibEnergy"+m_auxSuffix;
1300  ATH_CHECK( m_zdcModuleCalibEnergy.initialize());
1301  m_zdcModuleCalibTime = m_zdcModuleContainerName+".CalibTime"+m_auxSuffix;
1302  ATH_CHECK( m_zdcModuleCalibTime.initialize());
1303  m_zdcModuleStatus = m_zdcModuleContainerName+".Status"+m_auxSuffix;
1304  ATH_CHECK( m_zdcModuleStatus.initialize());
1305  m_zdcModuleTime = m_zdcModuleContainerName+".Time"+m_auxSuffix;
1306  ATH_CHECK( m_zdcModuleTime.initialize());
1307  m_zdcModuleChisq = m_zdcModuleContainerName+".Chisq"+m_auxSuffix;
1308  ATH_CHECK( m_zdcModuleChisq.initialize());
1309  m_zdcModuleFitAmp = m_zdcModuleContainerName+".FitAmp"+m_auxSuffix;
1310  ATH_CHECK( m_zdcModuleFitAmp.initialize());
1311  m_zdcModuleFitAmpError = m_zdcModuleContainerName+".FitAmpError"+m_auxSuffix;
1312  ATH_CHECK( m_zdcModuleFitAmpError.initialize());
1313  m_zdcModuleFitT0 = m_zdcModuleContainerName+".FitT0"+m_auxSuffix;
1314  ATH_CHECK( m_zdcModuleFitT0.initialize());
1315  m_zdcModuleBkgdMaxFraction = m_zdcModuleContainerName+".BkgdMaxFraction"+m_auxSuffix;
1316  ATH_CHECK( m_zdcModuleBkgdMaxFraction.initialize());
1317  m_zdcModulePreSampleAmp = m_zdcModuleContainerName+".PreSampleAmp"+m_auxSuffix;
1318  ATH_CHECK( m_zdcModulePreSampleAmp.initialize());
1319  m_zdcModulePresample = m_zdcModuleContainerName+".Presample"+m_auxSuffix;
1320  ATH_CHECK( m_zdcModulePresample.initialize());
1321  m_zdcModuleMinDeriv2nd = m_zdcModuleContainerName+".MinDeriv2nd"+m_auxSuffix;
1322  ATH_CHECK( m_zdcModuleMinDeriv2nd.initialize());
1323  m_zdcModuleMaxADC = m_zdcModuleContainerName+".MaxADC"+m_auxSuffix;
1324  ATH_CHECK( m_zdcModuleMaxADC.initialize());
1325  m_rpdChannelBaseline = m_zdcModuleContainerName+".RPDChannelBaseline"+m_auxSuffix;
1326  ATH_CHECK( m_rpdChannelBaseline.initialize());
1327  m_rpdChannelPileupExpFitParams = m_zdcModuleContainerName+".RPDChannelPileupExpFitParams"+m_auxSuffix;
1328  ATH_CHECK( m_rpdChannelPileupExpFitParams.initialize());
1329  m_rpdChannelPileupStretchedExpFitParams = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitParams"+m_auxSuffix;
1330  ATH_CHECK( m_rpdChannelPileupStretchedExpFitParams.initialize());
1331  m_rpdChannelPileupExpFitParamErrs = m_zdcModuleContainerName+".RPDChannelPileupExpFitParamErrs"+m_auxSuffix;
1332  ATH_CHECK( m_rpdChannelPileupExpFitParamErrs.initialize());
1333  m_rpdChannelPileupStretchedExpFitParamErrs = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitParamErrs"+m_auxSuffix;
1334  ATH_CHECK( m_rpdChannelPileupStretchedExpFitParamErrs.initialize());
1335  m_rpdChannelPileupExpFitMSE = m_zdcModuleContainerName+".RPDChannelPileupExpFitMSE"+m_auxSuffix;
1336  ATH_CHECK( m_rpdChannelPileupExpFitMSE.initialize());
1337  m_rpdChannelPileupStretchedExpFitMSE = m_zdcModuleContainerName+".RPDChannelPileupStretchedExpFitMSE"+m_auxSuffix;
1338  ATH_CHECK( m_rpdChannelPileupStretchedExpFitMSE.initialize());
1339  m_rpdChannelAmplitude = m_zdcModuleContainerName+".RPDChannelAmplitude"+m_auxSuffix;
1340  ATH_CHECK( m_rpdChannelAmplitude.initialize());
1341  m_rpdChannelAmplitudeCalib = m_zdcModuleContainerName+".RPDChannelAmplitudeCalib"+m_auxSuffix;
1342  ATH_CHECK( m_rpdChannelAmplitudeCalib.initialize());
1343  m_rpdChannelMaxADC = m_zdcModuleContainerName+".RPDChannelMaxADC"+m_auxSuffix;
1344  ATH_CHECK( m_rpdChannelMaxADC.initialize());
1345  m_rpdChannelMaxADCCalib = m_zdcModuleContainerName+".RPDChannelMaxADCCalib"+m_auxSuffix;
1346  ATH_CHECK( m_rpdChannelMaxADCCalib.initialize());
1347  m_rpdChannelMaxSample = m_zdcModuleContainerName+".RPDChannelMaxSample"+m_auxSuffix;
1348  ATH_CHECK( m_rpdChannelMaxSample.initialize());
1349  m_rpdChannelStatus = m_zdcModuleContainerName+".RPDChannelStatus"+m_auxSuffix;
1350  ATH_CHECK( m_rpdChannelStatus.initialize());
1351  m_rpdChannelPileupFrac = m_zdcModuleContainerName+".RPDChannelPileupFrac"+m_auxSuffix;
1352  ATH_CHECK( m_rpdChannelPileupFrac.initialize());
1353 
1354  m_zdcSumUncalibSum = m_zdcSumContainerName+".UncalibSum"+m_auxSuffix;
1355  ATH_CHECK( m_zdcSumUncalibSum.initialize());
1356  m_zdcSumCalibEnergy = m_zdcSumContainerName+".CalibEnergy"+m_auxSuffix;
1357  ATH_CHECK( m_zdcSumCalibEnergy.initialize());
1358  m_zdcSumCalibEnergyErr = m_zdcSumContainerName+".CalibEnergyErr"+m_auxSuffix;
1359  ATH_CHECK( m_zdcSumCalibEnergyErr.initialize());
1360  m_zdcSumUncalibSumErr = m_zdcSumContainerName+".UncalibSumErr"+m_auxSuffix;
1361  ATH_CHECK( m_zdcSumUncalibSumErr.initialize());
1362  m_zdcSumFinalEnergy = m_zdcSumContainerName+".FinalEnergy"+m_auxSuffix;
1363  ATH_CHECK( m_zdcSumFinalEnergy.initialize());
1364  m_zdcSumAverageTime = m_zdcSumContainerName+".AverageTime"+m_auxSuffix;
1365  ATH_CHECK( m_zdcSumAverageTime.initialize());
1366  m_zdcSumStatus = m_zdcSumContainerName+".Status"+m_auxSuffix;
1367  ATH_CHECK( m_zdcSumStatus.initialize());
1368  m_zdcSumModuleMask = m_zdcSumContainerName+".ModuleMask"+m_auxSuffix;
1369  ATH_CHECK( m_zdcSumModuleMask.initialize());
1370  m_zdcSumRPDStatus = m_zdcSumContainerName+".RPDStatus"+m_auxSuffix;
1371  ATH_CHECK( m_zdcSumRPDStatus.initialize());
1372 
1373  if (m_writeAux && m_auxSuffix != "") {
1374  ATH_MSG_DEBUG("suffix string = " << m_auxSuffix);
1375  }
1376 
1377  m_init = true;
1378 
1379  return StatusCode::SUCCESS;
1380 }
1381 
1382 void ZdcAnalysisTool::initializeDecorations()
1383 {
1384 
1385 }
1386 
1387 StatusCode ZdcAnalysisTool::configureNewRun(unsigned int runNumber)
1388 {
1389  ATH_MSG_DEBUG("Setting up new run " << runNumber);
1390 
1391  // We do nothing for the default configuration
1392  //
1393  if (m_configuration != "default") {
1394  if (m_configuration == "PbPb2015") {
1395  //
1396  // Two periods, 40 MHz and 80 MHz readout
1397  //
1398  if (runNumber < 287222) m_zdcDataAnalyzer = m_zdcDataAnalyzer_40MHz;
1399  else m_zdcDataAnalyzer = m_zdcDataAnalyzer_80MHz;
1400  }
1401  }
1402 
1403  return StatusCode::SUCCESS;
1404 }
1405 
1406 
1407 StatusCode ZdcAnalysisTool::recoZdcModules(const xAOD::ZdcModuleContainer& moduleContainer, const xAOD::ZdcModuleContainer& moduleSumContainer)
1408 {
1409 
1410  if (moduleContainer.size()==0) return StatusCode::SUCCESS; // if no modules, do nothing
1411 
1412  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
1413  if (!eventInfo.isValid()) return StatusCode::FAILURE;
1414 
1415  // check for new run number, if new, possibly update configuration and/or calibrations
1416  //
1417  unsigned int thisRunNumber = eventInfo->runNumber();
1418  if (thisRunNumber != m_runNumber) {
1419  ATH_MSG_DEBUG("ZDC analysis tool will be configured for run " << thisRunNumber);
1420 
1421  ATH_CHECK(configureNewRun(thisRunNumber)); // ALWAYS check methods that return StatusCode
1422 
1423  ATH_MSG_DEBUG("Setting up calibrations");
1424 
1425  if (m_doCalib) {
1426  //
1427  // Check for calibration override
1428  //
1429  unsigned int calibRunNumber = thisRunNumber;
1430  if (m_forceCalibRun > -1) calibRunNumber = m_forceCalibRun;
1431 
1432  setEnergyCalibrations(calibRunNumber);
1433  if (m_doTrigEff) initializeTriggerEffs(calibRunNumber); // if energy calibrations fail to load, then so will trigger efficiencies
1434  if (m_doTimeCalib) setTimeCalibrations(calibRunNumber);
1435  }
1436 
1437  m_runNumber = thisRunNumber;
1438  }
1439 
1440  m_lumiBlock = eventInfo->lumiBlock();
1441 
1442  unsigned int calibLumiBlock = m_lumiBlock;
1443  if (m_doCalib) {
1444  if (m_forceCalibRun > 0) calibLumiBlock = m_forceCalibLB;
1445  }
1446 
1447  ATH_MSG_DEBUG("Starting event processing");
1448  ATH_MSG_DEBUG("LB=" << calibLumiBlock);
1449 
1450  m_zdcDataAnalyzer->StartEvent(calibLumiBlock);
1451 
1452  if (m_LHCRun==3)
1453  {
1454  m_rpdDataAnalyzer.at(0)->reset();
1455  m_rpdDataAnalyzer.at(1)->reset();
1456  }
1457 
1458  static const SG::ConstAccessor<std::vector<uint16_t> > g0dataAcc ("g0data");
1459  static const SG::ConstAccessor<std::vector<uint16_t> > g1dataAcc ("g1data");
1460 
1461  const std::vector<unsigned short>* adcUndelayLG = 0;
1462  const std::vector<unsigned short>* adcUndelayHG = 0;
1463 
1464  const std::vector<unsigned short>* adcDelayLG = 0;
1465  const std::vector<unsigned short>* adcDelayHG = 0;
1466 
1467  ATH_MSG_DEBUG("Processing modules");
1468  for (const auto zdcModule : moduleContainer)
1469  {
1470  int side = -1;
1471  if (zdcModule->zdcSide() == -1) side = 0;
1472  else if (zdcModule->zdcSide() == 1) side = 1;
1473  else {
1474  // Invalid side
1475  //
1476  ATH_MSG_WARNING("Invalid side value found for module number: " << zdcModule->zdcModule() << ", side value = " << side);
1477  continue;
1478  }
1479  // Ignore MC only modules
1480  if(zdcModule->zdcModule() > 4) continue;
1481 
1482  if (zdcModule->zdcType() == 1) {
1483  // This is RPD data in Run 3
1484  //
1485  if (m_LHCRun < 3) continue; // type == 1 -> pixel data in runs 2 and 3, skip
1486  ATH_MSG_DEBUG("RPD side " << side << " chan " << zdcModule->zdcChannel() );
1487 
1488  unsigned int rpdChannel = zdcModule->zdcChannel(); // channel numbers are fixed in mapping, numbered 0-15
1489  if (rpdChannel > 15) {
1490  //
1491  // The data is somehow corrupt, spit out an error
1492  //
1493  ATH_MSG_WARNING("Invalid RPD channel found on side " << side << ", channel number = " << rpdChannel << ", skipping this module");
1494  continue;
1495  }
1496  else {
1497  //
1498  // Pass the data to the RPD analysis tool
1499  //
1500  m_rpdDataAnalyzer.at(side)->loadChannelData(rpdChannel,
1501  g0dataAcc (*zdcModule));
1502  }
1503  }
1504  else {
1505  //
1506  // This is ZDC data
1507  //
1508  if (m_LHCRun==3) // no delay channels, so we drop the index
1509  {
1510  adcUndelayLG = &g0dataAcc(*zdcModule); // g0
1511  adcUndelayHG = &g1dataAcc(*zdcModule); // g1
1512  }
1513  else if (m_LHCRun==2)
1514  {
1515  if (zdcModule->zdcType() == 1) continue; // skip position sensitive modules
1516 
1517  static const SG::ConstAccessor<std::vector<uint16_t> > g0d1dataAcc ("g0d1data");
1518  static const SG::ConstAccessor<std::vector<uint16_t> > g1d1dataAcc ("g1d1data");
1519  static const SG::ConstAccessor<std::vector<uint16_t> > g0d0dataAcc ("g0d0data");
1520  static const SG::ConstAccessor<std::vector<uint16_t> > g1d0dataAcc ("g1d0data");
1521 
1522  if (zdcModule->zdcModule() == 0 && m_flipEMDelay) // flip delay/non-delay for 2015 ONLY
1523  {
1524  adcUndelayLG = &g0d1dataAcc(*zdcModule); // g0d1
1525  adcUndelayHG = &g1d1dataAcc(*zdcModule); // g1d1
1526  adcDelayLG = &g0d0dataAcc(*zdcModule); // g0d0
1527  adcDelayHG = &g1d0dataAcc(*zdcModule); // g1d0
1528  }
1529  else // nominal configuation
1530  {
1531  adcUndelayLG = &g0d0dataAcc(*zdcModule); // g0d0
1532  adcUndelayHG = &g1d0dataAcc(*zdcModule); // g1d0
1533  adcDelayLG = &g0d1dataAcc(*zdcModule); // g0d1
1534  adcDelayHG = &g1d1dataAcc(*zdcModule); // g1d1
1535  }
1536  }
1537  else
1538  {
1539  ATH_MSG_WARNING("Unknown LHC Run " << m_LHCRun);
1540  return StatusCode::FAILURE;
1541  }
1542 
1543  // Why were these static? to optimize processing time
1544  std::vector<float> HGUndelADCSamples(m_numSample);
1545  std::vector<float> LGUndelADCSamples(m_numSample);
1546 
1547  std::copy(adcUndelayLG->begin(), adcUndelayLG->end(), LGUndelADCSamples.begin());
1548  std::copy(adcUndelayHG->begin(), adcUndelayHG->end(), HGUndelADCSamples.begin());
1549 
1550  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
1551 
1552  if (!m_combineDelay) {
1553  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(), HGUndelADCSamples, LGUndelADCSamples);
1554  }
1555  else {
1556  std::vector<float> HGDelayADCSamples(m_numSample);
1557  std::vector<float> LGDelayADCSamples(m_numSample);
1558  if (adcDelayLG and adcDelayHG){
1559  std::copy(adcDelayLG->begin(), adcDelayLG->end(), LGDelayADCSamples.begin());
1560  std::copy(adcDelayHG->begin(), adcDelayHG->end(), HGDelayADCSamples.begin());
1561  }else{
1562  ATH_MSG_ERROR("adcDelayLG or adcDelayHG pointers are null");
1563  return StatusCode::FAILURE;
1564  }
1565  // If the delayed channels actually come earlier (as in the pPb in 2016), we invert the meaning of delayed and undelayed
1566  // see the initialization sections for similar inversion on the sign of the pedestal difference
1567  //
1568 
1569  m_zdcDataAnalyzer->LoadAndAnalyzeData(side, zdcModule->zdcModule(),
1570  HGUndelADCSamples, LGUndelADCSamples,
1571  HGDelayADCSamples, LGDelayADCSamples);
1572  }
1573  }
1574  }
1575 
1576  // analyze RPD data only once all channels have been loaded
1577  if (m_LHCRun==3)
1578  {
1579  m_rpdDataAnalyzer.at(0)->analyzeData();
1580  m_rpdDataAnalyzer.at(1)->analyzeData();
1581  }
1582 
1583  ATH_MSG_DEBUG("Finishing event processing");
1584 
1585  m_zdcDataAnalyzer->FinishEvent();
1586 
1587  ATH_MSG_DEBUG("Adding variables with suffix=" + m_auxSuffix);
1588 
1589  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleAmplitude(m_zdcModuleAmplitude);
1590  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibEnergy(m_zdcModuleCalibEnergy);
1591  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleCalibTime(m_zdcModuleCalibTime);
1592  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcModuleStatus(m_zdcModuleStatus);
1593  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleTime(m_zdcModuleTime);
1594  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleChisq(m_zdcModuleChisq);
1595  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmp(m_zdcModuleFitAmp);
1596  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitAmpError(m_zdcModuleFitAmpError);
1597  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleFitT0(m_zdcModuleFitT0);
1598  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleBkgdMaxFraction(m_zdcModuleBkgdMaxFraction);
1599  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePreSampleAmp(m_zdcModulePreSampleAmp);
1600  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModulePresample(m_zdcModulePresample);
1601  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMinDeriv2nd(m_zdcModuleMinDeriv2nd);
1602  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcModuleMaxADC(m_zdcModuleMaxADC);
1603  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelBaseline(m_rpdChannelBaseline);
1604  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupExpFitParams(m_rpdChannelPileupExpFitParams);
1605  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupStretchedExpFitParams(m_rpdChannelPileupStretchedExpFitParams);
1606  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupExpFitParamErrs(m_rpdChannelPileupExpFitParamErrs);
1607  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,std::vector<float>> rpdChannelPileupStretchedExpFitParamErrs(m_rpdChannelPileupStretchedExpFitParamErrs);
1608  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupExpFitMSE(m_rpdChannelPileupExpFitMSE);
1609  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupStretchedExpFitMSE(m_rpdChannelPileupStretchedExpFitMSE);
1610  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelAmplitude(m_rpdChannelAmplitude);
1611  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelAmplitudeCalib(m_rpdChannelAmplitudeCalib);
1612  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelMaxADC(m_rpdChannelMaxADC);
1613  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelMaxADCCalib(m_rpdChannelMaxADCCalib);
1614  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> rpdChannelMaxSample(m_rpdChannelMaxSample);
1615  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> rpdChannelStatus(m_rpdChannelStatus);
1616  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> rpdChannelPileupFrac(m_rpdChannelPileupFrac);
1617 
1618  // CalibTime
1619  // Status
1620  // Time
1621  // Chisq
1622  // FitAmp
1623  // FitAmpError
1624  // FitT0
1625  // BkgdMaxFraction
1626  // PreSampleAmp
1627  // Presample
1628  // MinDeriv2nd
1629  // MaxADC
1630 
1631  for (const auto zdcModule : moduleContainer)
1632  {
1633  int side = (zdcModule->zdcSide() == -1) ? 0 : 1 ;
1634  int mod = zdcModule->zdcModule();
1635  // Ignore MC only modules
1636  if(mod > 4) continue;
1637 
1638  if (zdcModule->zdcType() == 1 && m_LHCRun==3) {
1639  // this is the RPD
1640  if (m_writeAux) {
1641  int rpdChannel = zdcModule->zdcChannel(); // channel numbers are fixed in mapping, numbered 0-15
1642  rpdChannelBaseline(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChBaseline(rpdChannel);
1643  rpdChannelPileupExpFitParams(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitParams(rpdChannel);
1644  rpdChannelPileupStretchedExpFitParams(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitParams(rpdChannel);
1645  rpdChannelPileupExpFitParamErrs(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitParamErrs(rpdChannel);
1646  rpdChannelPileupStretchedExpFitParamErrs(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitParamErrs(rpdChannel);
1647  rpdChannelPileupExpFitMSE(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupExpFitMSE(rpdChannel);
1648  rpdChannelPileupStretchedExpFitMSE(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupStretchedExpFitMSE(rpdChannel);
1649  rpdChannelAmplitude(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChSumAdc(rpdChannel);
1650  rpdChannelAmplitudeCalib(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChSumAdcCalib(rpdChannel);
1651  rpdChannelMaxADC(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxAdc(rpdChannel);
1652  rpdChannelMaxADCCalib(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxAdcCalib(rpdChannel);
1653  rpdChannelMaxSample(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChMaxSample(rpdChannel);
1654  rpdChannelStatus(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChStatus(rpdChannel);
1655  rpdChannelPileupFrac(*zdcModule) = m_rpdDataAnalyzer.at(side)->getChPileupFrac(rpdChannel);
1656  }
1657  } else if (zdcModule->zdcType() == 0) {
1658  // this is the main ZDC
1659  if (m_writeAux) {
1660  if (m_doCalib) {
1661  float calibEnergy = m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod);
1662  zdcModuleCalibEnergy(*zdcModule) = calibEnergy;
1663  zdcModuleCalibTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleCalibTime(side, mod);
1664  }
1665  else
1666  {
1667  zdcModuleCalibEnergy(*zdcModule) = -1000;
1668  zdcModuleCalibTime(*zdcModule) = -1000;
1669  }
1670 
1671  zdcModuleAmplitude(*zdcModule) = m_zdcDataAnalyzer->GetModuleAmplitude(side, mod);
1672  zdcModuleStatus(*zdcModule) = m_zdcDataAnalyzer->GetModuleStatus(side, mod);
1673  zdcModuleTime(*zdcModule) = m_zdcDataAnalyzer->GetModuleTime(side, mod);
1674 
1675  const ZDCPulseAnalyzer* pulseAna_p = m_zdcDataAnalyzer->GetPulseAnalyzer(side, mod);
1676  zdcModuleChisq(*zdcModule) = pulseAna_p->GetChisq();
1677  zdcModuleFitAmp(*zdcModule) = pulseAna_p->GetFitAmplitude();
1678  zdcModuleFitAmpError(*zdcModule) = pulseAna_p->GetAmpError();
1679  zdcModuleFitT0(*zdcModule) = pulseAna_p->GetFitT0();
1680  zdcModuleBkgdMaxFraction(*zdcModule) = pulseAna_p->GetBkgdMaxFraction();
1681  zdcModulePreSampleAmp(*zdcModule) = pulseAna_p->GetPreSampleAmp();
1682  zdcModulePresample(*zdcModule) = pulseAna_p->GetPresample();
1683  zdcModuleMinDeriv2nd(*zdcModule) = pulseAna_p->GetMinDeriv2nd();
1684  zdcModuleMaxADC(*zdcModule) = pulseAna_p->GetMaxADC();
1685  }
1686  //ATH_MSG_DEBUG ("side = " << side << " module=" << zdcModule->zdcModule() << " CalibEnergy=" << zdcModule->auxdecor<float>("CalibEnergy")
1687  // << " should be " << m_zdcDataAnalyzer->GetModuleCalibAmplitude(side, mod));
1688  }
1689  }
1690 
1691  // Output sum information
1692  // In Run 3 - we have to assume the container already exists (since it is needed to store the per-side trigger info)
1693  // reprocessing will add new variables with the suffix
1694 
1695  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSum(m_zdcSumUncalibSum);
1696  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumUncalibSumErr(m_zdcSumUncalibSumErr);
1697  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergy(m_zdcSumCalibEnergy);
1698  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumCalibEnergyErr(m_zdcSumCalibEnergyErr);
1699  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumFinalEnergy(m_zdcSumFinalEnergy);
1700  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,float> zdcSumAverageTime(m_zdcSumAverageTime);
1701  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumStatus(m_zdcSumStatus);
1702  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumModuleMask(m_zdcSumModuleMask);
1703  SG::WriteDecorHandle<xAOD::ZdcModuleContainer,unsigned int> zdcSumRPDStatus(m_zdcSumRPDStatus);
1704 
1705  for (const auto zdc_sum: moduleSumContainer)
1706  {
1707  ATH_MSG_DEBUG("Extracting ZDC side " << zdc_sum->zdcSide());
1708 
1709  if (zdc_sum->zdcSide()==0) continue; // skip new global sum
1710 
1711  int iside = (zdc_sum->zdcSide()==-1) ? 0 : 1;
1712 
1713  float uncalibSum = getUncalibModuleSum(iside);
1714  zdcSumUncalibSum(*zdc_sum) = uncalibSum;
1715  float uncalibSumErr = getUncalibModuleSumErr(iside);
1716  zdcSumUncalibSumErr(*zdc_sum) = uncalibSumErr;
1717 
1718  float calibEnergy = getCalibModuleSum(iside);
1719  zdcSumCalibEnergy(*zdc_sum) = calibEnergy;
1720  float calibEnergyErr = getCalibModuleSumErr(iside);
1721  zdcSumCalibEnergyErr(*zdc_sum) = calibEnergyErr;
1722 
1723  float finalEnergy = calibEnergy;
1724  zdcSumFinalEnergy(*zdc_sum) = finalEnergy;
1725  zdcSumAverageTime(*zdc_sum) = getAverageTime(iside);
1726  zdcSumStatus(*zdc_sum) = !sideFailed(iside);
1727  zdcSumModuleMask(*zdc_sum) = (getModuleMask() >> (4 * iside)) & 0xF;
1728  if (m_LHCRun==3)
1729  {
1730  zdcSumRPDStatus(*zdc_sum) = m_rpdDataAnalyzer.at(iside)->getSideStatus();
1731  }
1732  }
1733 
1734  return StatusCode::SUCCESS;
1735 }
1736 
1737 void ZdcAnalysisTool::setEnergyCalibrations(unsigned int runNumber)
1738 {
1739 
1740  char name[128];
1741 
1742  std::string filename;
1743  if (m_LHCRun==3)
1744  {
1745  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
1746  }
1747  else if (m_LHCRun==2)
1748  {
1749  filename = PathResolverFindCalibFile( ("ZdcAnalysis/" + m_zdcEnergyCalibFileName).c_str() );
1750  }
1751  else
1752  {
1753  ATH_MSG_WARNING("No LHC Run defined, so no calibration allowed");
1754  return;
1755  }
1756 
1757  ATH_MSG_INFO("Opening energy calibration file " << filename);
1758  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
1759 
1760  if (fCalib == nullptr || fCalib->IsZombie())
1761  {
1762  ATH_MSG_INFO ("failed to open file: " << filename);
1763  throw std::runtime_error ("failed to open file " + filename);
1764  }
1765 
1766  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> splines;
1767 
1768  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
1769  TString calibVersion;
1770  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
1771 
1772  for (int iside = 0; iside < 2; iside++)
1773  {
1774  for (int imod = 0; imod < 4; imod++)
1775  {
1776  sprintf(name, "ZDC_Ecalib_run%u_s%d_m%d", runNumber, iside, imod);
1777  ATH_MSG_DEBUG("Searching for spline " << name);
1778  TSpline3* s = (TSpline3*) fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3");
1779  if (!s && m_doCalib)
1780  {
1781  ATH_MSG_WARNING("No calibrations for run " << runNumber);
1782  m_doCalib = false;
1783  }
1784 
1785  if (s)
1786  {
1787  splines[iside][imod].reset (s);
1788  }
1789  else
1790  {
1791  ATH_MSG_WARNING("No spline " << name);
1792  }
1793  }
1794  }
1795  fCalib->Close();
1796 
1797  if (m_doCalib) m_zdcDataAnalyzer->LoadEnergyCalibrations(splines);
1798 
1799  return;
1800 }
1801 
1802 void ZdcAnalysisTool::setTimeCalibrations(unsigned int runNumber)
1803 {
1804  std::string filename;
1805 
1806  if (m_LHCRun==3)
1807  {
1808  filename = PathResolverFindCalibFile( ("ZdcAnalysis/ZdcCalib_Run"+TString::Itoa(runNumber,10)+".root").Data() );
1809  }
1810  else if (m_LHCRun==2)
1811  {
1812  filename = PathResolverFindCalibFile( "ZdcAnalysis/" + m_zdcTimeCalibFileName );
1813  }
1814  else
1815  {
1816  ATH_MSG_WARNING("No LHC Run defined, so no time calibration allowed");
1817  return;
1818  }
1819 
1820  char name[128] = {0};
1821  ATH_MSG_INFO("Opening time calibration file " << filename);
1822  std::unique_ptr<TFile> fCalib (TFile::Open(filename.c_str(), "READ"));
1823 
1824  // "m_calibVersion", called CalibVersion when settings parameters in python, is a directory within the run-based calibration file
1825  TString calibVersion = "";
1826  if (m_calibVersion != "") calibVersion = m_calibVersion + "/";
1827 
1828  if (fCalib && !fCalib->IsZombie())
1829  {
1830  bool success = true;
1831  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0HGOffsetSplines;
1832  std::array<std::array<std::unique_ptr<TSpline>, 4>, 2> T0LGOffsetSplines;
1833  std::unique_ptr<TSpline3> spline;
1834  for (int iside = 0; iside < 2; iside++)
1835  {
1836  for (int imod = 0; imod < 4; imod++)
1837  {
1838  sprintf(name, "ZDC_T0calib_run%u_HG_s%d_m%d", runNumber, iside, imod);
1839  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
1840  if (spline)
1841  {
1842  T0HGOffsetSplines[iside][imod] = std::move (spline);
1843  }
1844  else
1845  {
1846  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
1847  success = false;
1848  }
1849 
1850  sprintf(name, "ZDC_T0calib_run%u_LG_s%d_m%d", runNumber, iside, imod);
1851  spline.reset (static_cast<TSpline3*>(fCalib->GetObjectChecked(calibVersion+TString(name), "TSpline3")));
1852  if (spline)
1853  {
1854  T0LGOffsetSplines[iside][imod] = std::move (spline);
1855  }
1856  else
1857  {
1858  ATH_MSG_WARNING("No time calib. spline " << calibVersion+name);
1859  success = false;
1860  }
1861  }
1862  }
1863 
1864  if (success)
1865  m_zdcDataAnalyzer->LoadT0Calibrations(T0HGOffsetSplines, T0LGOffsetSplines);
1866  else
1867  ATH_MSG_WARNING("Time calibration failed - no T0 offsets loaded " << calibVersion+name);
1868 
1869  fCalib->Close();
1870  }
1871  else
1872  {
1873  ATH_MSG_WARNING("No time calibration file " << filename);
1874  }
1875 }
1876 
1877 StatusCode ZdcAnalysisTool::reprocessZdc()
1878 {
1879  if (!m_init)
1880  {
1881  ATH_MSG_WARNING("Tool not initialized!");
1882  return StatusCode::FAILURE;
1883  }
1884  m_eventReady = false;
1885  ATH_MSG_DEBUG ("Trying to retrieve " << m_zdcModuleContainerName);
1886 
1887  m_zdcModules = 0;
1888  ATH_CHECK(evtStore()->retrieve(m_zdcModules, m_zdcModuleContainerName));
1889 
1890  m_zdcSums = 0;
1891  ATH_CHECK(evtStore()->retrieve(m_zdcSums, m_zdcSumContainerName));
1892 
1893  m_eventReady = true;
1894 
1895  ATH_CHECK(recoZdcModules(*m_zdcModules, *m_zdcSums));
1896 
1897  return StatusCode::SUCCESS;
1898 }
1899 
1900 bool ZdcAnalysisTool::sigprocMaxFinder(const std::vector<unsigned short>& adc, float deltaT, float& amp, float& time, float& qual)
1901 {
1902  size_t nsamp = adc.size();
1903  float presamp = adc.at(0);
1904  unsigned short max_adc = 0;
1905  int max_index = -1;
1906  for (size_t i = 0; i < nsamp; i++)
1907  {
1908  if (adc[i] > max_adc)
1909  {
1910  max_adc = adc[i];
1911  max_index = i;
1912  }
1913  }
1914  amp = max_adc - presamp;
1915  time = max_index * deltaT;
1916  qual = 1.;
1917 
1918  if (max_index == -1)
1919  {
1920  qual = 0.;
1921  return false;
1922  }
1923 
1924  return true;
1925 }
1926 
1927 bool ZdcAnalysisTool::sigprocSincInterp(const std::vector<unsigned short>& adc, float deltaT, float& amp, float& time, float& qual)
1928 {
1929  size_t nsamp = adc.size();
1930  float presamp = adc.at(0);
1931  m_tf1SincInterp->SetParameter(0, deltaT);
1932  for (size_t i = 0; i < nsamp; i++)
1933  {
1934  m_tf1SincInterp->SetParameter(i + 1, adc.at(i) - presamp);
1935  }
1936  amp = m_tf1SincInterp->GetMaximum();
1937  time = m_tf1SincInterp->GetMaximumX();
1938  qual = 1.;
1939  return true;
1940 }
1941 
1942 float ZdcAnalysisTool::getModuleSum(int side)
1943 {
1944  if (!m_zdcDataAnalyzer) return 0;
1945  return m_zdcDataAnalyzer->GetModuleSum(side);
1946 }
1947 
1948 float ZdcAnalysisTool::getCalibModuleSum(int side)
1949 {
1950  if (!m_zdcDataAnalyzer) return 0;
1951  return m_zdcDataAnalyzer->GetCalibModuleSum(side);
1952 }
1953 
1954 float ZdcAnalysisTool::getCalibModuleSumErr(int side)
1955 {
1956  if (!m_zdcDataAnalyzer) return 0;
1957  return m_zdcDataAnalyzer->GetCalibModuleSumErr(side);
1958 }
1959 
1960 float ZdcAnalysisTool::getUncalibModuleSum(int side)
1961 {
1962  if (!m_zdcDataAnalyzer) return 0;
1963  return m_zdcDataAnalyzer->GetModuleSum(side);
1964 }
1965 
1966 float ZdcAnalysisTool::getUncalibModuleSumErr(int side)
1967 {
1968  if (!m_zdcDataAnalyzer) return 0;
1969  return m_zdcDataAnalyzer->GetModuleSumErr(side);
1970 }
1971 
1972 float ZdcAnalysisTool::getAverageTime(int side)
1973 {
1974  if (!m_zdcDataAnalyzer) return 0;
1975  return m_zdcDataAnalyzer->GetAverageTime(side);
1976 }
1977 
1978 bool ZdcAnalysisTool::sideFailed(int side)
1979 {
1980  if (!m_zdcDataAnalyzer) return 0;
1981  return m_zdcDataAnalyzer->SideFailed(side);
1982 }
1983 
1984 unsigned int ZdcAnalysisTool::getModuleMask()
1985 {
1986  if (!m_zdcDataAnalyzer) return 0;
1987  return m_zdcDataAnalyzer->GetModuleMask();
1988 }
1989 
1990 double ZdcAnalysisTool::getTriggerEfficiency(int side)
1991 {
1992  if (!m_doTrigEff) return -1;
1993 
1994  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
1995  float adcSum = getModuleSum(side);
1996  double eff = m_zdcTriggerEfficiency->GetEfficiency(side, adcSum);
1997  return eff;
1998 }
1999 
2000 double ZdcAnalysisTool::getTriggerEfficiencyUncertainty(int side)
2001 {
2002  if (!m_doCalib) return -1;
2003 
2004  m_zdcTriggerEfficiency->UpdatelumiBlock(m_lumiBlock);
2005  float adcSum = getModuleSum(side);
2006  std::pair<double, double> eff_pair = m_zdcTriggerEfficiency->GetEfficiencyAndError(msg(), side, adcSum);
2007  return eff_pair.second;
2008 }
2009 
2010 
2011 } // namespace ZDC
ZDC::ZdcAnalysisTool::m_zdcTriggerEffParamsFileName
std::string m_zdcTriggerEffParamsFileName
Definition: ZdcAnalysisTool.h:132
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
WriteHandle.h
Handle class for recording to StoreGate.
ZDC::ZdcAnalysisTool::MakeMessageFunction
ZDCMsg::MessageFunctionPtr MakeMessageFunction()
Definition: ZdcAnalysisTool.h:82
ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStop
unsigned int m_rpdGoodPulseSampleStop
Definition: ZdcAnalysisTool.h:182
ZDC::ZdcAnalysisTool::m_zdcModuleContainerName
std::string m_zdcModuleContainerName
Definition: ZdcAnalysisTool.h:148
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinSamples
ZDCDataAnalyzer::ZDCModuleIntArray m_peak2ndDerivMinSamples
Definition: ZdcAnalysisTool.h:201
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
ZDC::ZdcAnalysisTool::m_runNumber
unsigned int m_runNumber
Definition: ZdcAnalysisTool.h:138
ZDC::ZdcAnalysisTool::m_Peak2ndDerivThresh
float m_Peak2ndDerivThresh
Definition: ZdcAnalysisTool.h:167
ZDC::ZdcAnalysisTool::m_rpdPostPulseFracThresh
float m_rpdPostPulseFracThresh
Definition: ZdcAnalysisTool.h:180
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ZDC::ZdcAnalysisTool::m_zdcModuleChisq
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleChisq
Definition: ZdcAnalysisTool.h:217
ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitParams
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParams
Definition: ZdcAnalysisTool.h:228
ZDC::ZdcAnalysisTool::m_zdcModules
const xAOD::ZdcModuleContainer * m_zdcModules
Definition: ZdcAnalysisTool.h:149
ZDC::ZdcAnalysisTool::reprocessZdc
StatusCode reprocessZdc() override
Definition: ZdcAnalysisTool.cxx:1877
ZDC::ZdcAnalysisTool::m_rpdNominalBaseline
unsigned int m_rpdNominalBaseline
Definition: ZdcAnalysisTool.h:183
ZDC::ZdcAnalysisTool::m_zdcModuleCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibEnergy
Definition: ZdcAnalysisTool.h:213
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsLG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsLG
Definition: ZdcAnalysisTool.h:203
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ZDC::ZdcAnalysisTool::m_doTrigEff
bool m_doTrigEff
Definition: ZdcAnalysisTool.h:156
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ZDC::ZdcAnalysisTool::m_ChisqRatioCut
float m_ChisqRatioCut
Definition: ZdcAnalysisTool.h:175
ZDC::ZdcAnalysisTool::m_LHCRun
int m_LHCRun
Definition: ZdcAnalysisTool.h:191
ZDCDataAnalyzer::ZDCModuleFloatArray
std::array< std::array< float, 4 >, 2 > ZDCModuleFloatArray
Definition: ZDCDataAnalyzer.h:22
ZDCPulseAnalyzer::GetAmpError
float GetAmpError() const
Definition: ZDCPulseAnalyzer.h:535
Data
@ Data
Definition: BaseObject.h:11
ZDC::ZdcAnalysisTool::m_rpdAdcOverflow
unsigned int m_rpdAdcOverflow
Definition: ZdcAnalysisTool.h:187
ZDC::ZdcAnalysisTool::m_rpdChannelBaseline
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelBaseline
Definition: ZdcAnalysisTool.h:227
ZDC::ZdcAnalysisTool::m_fixTau1
bool m_fixTau1
Definition: ZdcAnalysisTool.h:172
ZDC::ZdcAnalysisTool::m_rpdEndSignalSample
unsigned int m_rpdEndSignalSample
Definition: ZdcAnalysisTool.h:178
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParams
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParams
Definition: ZdcAnalysisTool.h:229
ALFA_EventTPCnv_Dict::t0
std::vector< ALFA_RawData_p1 > t0
Definition: ALFA_EventTPCnvDict.h:42
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmp
Definition: ZdcAnalysisTool.h:218
ZDC::ZdcAnalysisTool::getUncalibModuleSumErr
float getUncalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:1966
asg
Definition: DataHandleTestTool.h:28
ZDC::ZdcAnalysisTool::m_doTimeCalib
bool m_doTimeCalib
Definition: ZdcAnalysisTool.h:73
ZDCDataAnalyzer::ZDCModuleIntArray
std::array< std::array< int, 4 >, 2 > ZDCModuleIntArray
Definition: ZDCDataAnalyzer.h:24
ZDC::ZdcAnalysisTool::initialize
StatusCode initialize() override
Dummy implementation of the initialisation function.
Definition: ZdcAnalysisTool.cxx:1202
ZDC::ZdcAnalysisTool::m_zdcAnalysisConfigPath
std::string m_zdcAnalysisConfigPath
Definition: ZdcAnalysisTool.h:129
ZDC::SincInterp
double SincInterp(const double *xvec, const double *pvec)
Definition: ZdcSincInterp.cxx:11
ZDC::ZdcAnalysisTool::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: ZdcAnalysisTool.h:144
ZDC::ZdcAnalysisTool::m_rpdChannelMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADC
Definition: ZdcAnalysisTool.h:236
ZDC::ZdcAnalysisTool::m_rpdNbaselineSamples
unsigned int m_rpdNbaselineSamples
Definition: ZdcAnalysisTool.h:177
ZDC::ZdcAnalysisTool::m_presample
unsigned int m_presample
Definition: ZdcAnalysisTool.h:165
ZDC::ZdcAnalysisTool::m_zdcSumModuleMask
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumModuleMask
Definition: ZdcAnalysisTool.h:250
ZDCPulseAnalyzer
Definition: ZDCPulseAnalyzer.h:24
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
ZDCPulseAnalyzer::GetPresample
float GetPresample() const
Definition: ZDCPulseAnalyzer.h:539
ZDC::ZdcAnalysisTool::getTriggerEfficiency
double getTriggerEfficiency(int side)
Definition: ZdcAnalysisTool.cxx:1990
ZDC::ZdcAnalysisTool::m_zdcModuleStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleStatus
Definition: ZdcAnalysisTool.h:215
ZDC::ZdcAnalysisTool::m_zdcSumAverageTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumAverageTime
Definition: ZdcAnalysisTool.h:248
ZDC::ZdcAnalysisTool::m_rpdChannelAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitude
Definition: ZdcAnalysisTool.h:234
ZDC::ZdcAnalysisTool::m_tf1SincInterp
std::unique_ptr< TF1 > m_tf1SincInterp
Definition: ZdcAnalysisTool.h:142
ZDC::ZdcAnalysisTool::m_tau1
float m_tau1
Definition: ZdcAnalysisTool.h:170
ZDC::ZdcAnalysisTool::m_rpdSideCOutputCalibFactors
std::vector< float > m_rpdSideCOutputCalibFactors
Definition: ZdcAnalysisTool.h:188
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
ZDC::ZdcAnalysisTool::~ZdcAnalysisTool
virtual ~ZdcAnalysisTool() override
Definition: ZdcAnalysisTool.cxx:92
ZDCDataAnalyzer::set2ndDerivStep
void set2ndDerivStep(size_t step)
Definition: ZDCDataAnalyzer.cxx:181
ZDCDataAnalyzer::SetCutValues
void SetCutValues(const ZDCModuleFloatArray &chisqDivAmpCutHG, const ZDCModuleFloatArray &chisqDivAmpCutLG, const ZDCModuleFloatArray &deltaT0MinHG, const ZDCModuleFloatArray &deltaT0MaxHG, const ZDCModuleFloatArray &deltaT0MinLG, const ZDCModuleFloatArray &deltaT0MaxLG)
Definition: ZDCDataAnalyzer.cxx:291
ZDC::ZdcAnalysisTool::m_rpdChannelMaxSample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxSample
Definition: ZdcAnalysisTool.h:238
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitParamErrs
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitParamErrs
Definition: ZdcAnalysisTool.h:231
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ZdcAnalysisTool.h
ZdcSincInterp.h
ZDCDataAnalyzer
Definition: ZDCDataAnalyzer.h:20
ZDC::ZdcAnalysisTool::m_zdcSumStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumStatus
Definition: ZdcAnalysisTool.h:249
ZdcModuleAuxContainer.h
ZDC::ZdcAnalysisTool::m_zdcModuleAmplitude
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleAmplitude
Definition: ZdcAnalysisTool.h:212
ZDC::ZdcAnalysisTool::sideFailed
bool sideFailed(int side)
Definition: ZdcAnalysisTool.cxx:1978
ZDC::ZdcAnalysisTool::getModuleSum
float getModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:1942
ZDC::ZdcAnalysisTool::initializepp2023
std::unique_ptr< ZDCDataAnalyzer > initializepp2023()
Definition: ZdcAnalysisTool.cxx:318
ZDC::ZdcAnalysisTool::m_zdcSumFinalEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumFinalEnergy
Definition: ZdcAnalysisTool.h:247
python.PyAthena.module
module
Definition: PyAthena.py:134
ZDC::ZdcAnalysisTool::m_lumiBlock
unsigned int m_lumiBlock
Definition: ZdcAnalysisTool.h:139
ZDCPulseAnalyzer::TimingCorrLog
@ TimingCorrLog
Definition: ZDCPulseAnalyzer.h:51
ZDC::ZdcAnalysisTool::setEnergyCalibrations
void setEnergyCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1737
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ZDC::ZdcAnalysisTool::m_delayDeltaT
float m_delayDeltaT
Definition: ZdcAnalysisTool.h:169
ZDC::ZdcAnalysisTool::m_init
bool m_init
Definition: ZdcAnalysisTool.h:127
ZDC::ZdcAnalysisTool::m_rpdPulse2ndDerivThresh
float m_rpdPulse2ndDerivThresh
Definition: ZdcAnalysisTool.h:179
ZDC::ZdcAnalysisTool::m_rpdPileupBaselineSumThresh
float m_rpdPileupBaselineSumThresh
Definition: ZdcAnalysisTool.h:184
ZDC::ZdcAnalysisTool::getCalibModuleSumErr
float getCalibModuleSumErr(int side)
Definition: ZdcAnalysisTool.cxx:1954
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitParamErrs
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitParamErrs
Definition: ZdcAnalysisTool.h:230
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSum
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSum
Definition: ZdcAnalysisTool.h:243
ZDCDataAnalyzer::SetNoiseSigmas
void SetNoiseSigmas(const ZDCModuleFloatArray &noiseSigmasHG, const ZDCModuleFloatArray &noiseSigmasLG)
Definition: ZDCDataAnalyzer.cxx:243
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:92
ZDC::ZdcAnalysisTool::m_combineDelay
bool m_combineDelay
Definition: ZdcAnalysisTool.h:154
ZDC::ZdcAnalysisTool::m_numSample
unsigned int m_numSample
Definition: ZdcAnalysisTool.h:163
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ZDC::ZdcAnalysisTool::initializepPb2016
std::unique_ptr< ZDCDataAnalyzer > initializepPb2016()
Definition: ZdcAnalysisTool.cxx:724
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ZDC::ZdcAnalysisTool::m_forceCalibLB
int m_forceCalibLB
Definition: ZdcAnalysisTool.h:158
ZDC::ZdcAnalysisTool::initializePbPb2023
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2023()
Definition: ZdcAnalysisTool.cxx:425
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:99
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_80MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_80MHz
Definition: ZdcAnalysisTool.h:197
ZDCDataAnalyzer::SetADCOverUnderflowValues
void SetADCOverUnderflowValues(const ZDCModuleFloatArray &HGOverflowADC, const ZDCModuleFloatArray &HGUnderflowADC, const ZDCModuleFloatArray &LGOverflowADC)
Definition: ZDCDataAnalyzer.cxx:281
file
TFile * file
Definition: tile_monitor.h:29
ZDC::ZdcAnalysisTool::m_zdcModuleMaxADC
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMaxADC
Definition: ZdcAnalysisTool.h:225
ZDC::ZdcAnalysisTool::m_rpdNNegativesAllowed
unsigned int m_rpdNNegativesAllowed
Definition: ZdcAnalysisTool.h:186
ZDC::ZdcAnalysisTool::m_zdcModuleFitT0
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitT0
Definition: ZdcAnalysisTool.h:220
ZDC::ZdcAnalysisTool::recoZdcModules
StatusCode recoZdcModules(const xAOD::ZdcModuleContainer &moduleContainer, const xAOD::ZdcModuleContainer &moduleSumContainer) override
Definition: ZdcAnalysisTool.cxx:1407
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ZDC::ZdcAnalysisTool::getModuleMask
unsigned int getModuleMask()
Definition: ZdcAnalysisTool.cxx:1984
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ZDCPulseAnalyzer::TimingCorrLin
@ TimingCorrLin
Definition: ZDCPulseAnalyzer.h:51
ZDCDataAnalyzer::SetFitMinMaxAmpValues
void SetFitMinMaxAmpValues(const ZDCModuleFloatArray &minAmpHG, const ZDCModuleFloatArray &minAmpLG, const ZDCModuleFloatArray &maxAmpHG, const ZDCModuleFloatArray &maxAmpLG)
Definition: ZDCDataAnalyzer.cxx:260
ZDC::ZdcAnalysisTool::m_zdcModuleMinDeriv2nd
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleMinDeriv2nd
Definition: ZdcAnalysisTool.h:224
ZDCDataAnalyzer::SetTauT0Values
void SetTauT0Values(const ZDCModuleBoolArray &fxiTau1, const ZDCModuleBoolArray &fxiTau2, const ZDCModuleFloatArray &tau1, const ZDCModuleFloatArray &tau2, const ZDCModuleFloatArray &t0HG, const ZDCModuleFloatArray &t0LG)
Definition: ZDCDataAnalyzer.cxx:231
ZDC::ZdcAnalysisTool::m_zdcModuleBkgdMaxFraction
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleBkgdMaxFraction
Definition: ZdcAnalysisTool.h:221
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
WriteDecorHandle.h
Handle class for adding a decoration to an object.
ZDC::ZdcAnalysisTool::m_zdcSumContainerName
std::string m_zdcSumContainerName
Definition: ZdcAnalysisTool.h:150
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer
Definition: ZdcAnalysisTool.h:195
ZDC::ZdcAnalysisTool::setTimeCalibrations
void setTimeCalibrations(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1802
ZDC::ZdcAnalysisTool::m_tau2
float m_tau2
Definition: ZdcAnalysisTool.h:171
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergyErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergyErr
Definition: ZdcAnalysisTool.h:246
ZDCDataAnalyzer::enableDelayed
void enableDelayed(float deltaT, const ZDCModuleFloatArray &undelayedDelayedPedestalDiff)
Definition: ZDCDataAnalyzer.cxx:108
ZDC::ZdcAnalysisTool::m_rpdPileupBaselineStdDevThresh
float m_rpdPileupBaselineStdDevThresh
Definition: ZdcAnalysisTool.h:185
ZDC::ZdcAnalysisTool::m_rpdChannelMaxADCCalib
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelMaxADCCalib
Definition: ZdcAnalysisTool.h:237
ZDC::ZdcAnalysisTool::m_calibVersion
std::string m_calibVersion
Definition: ZdcAnalysisTool.h:159
ZDCDataAnalyzer::enablePostExclusion
void enablePostExclusion(unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
Definition: ZDCDataAnalyzer.cxx:152
ZDC::ZdcAnalysisTool::m_rpdChannelPileupFrac
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupFrac
Definition: ZdcAnalysisTool.h:240
ZDC::ZdcAnalysisTool::m_writeAux
bool m_writeAux
Definition: ZdcAnalysisTool.h:134
ZDC::ZdcAnalysisTool::m_configuration
std::string m_configuration
Definition: ZdcAnalysisTool.h:128
PathResolver.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
ZDC::ZdcAnalysisTool::m_forceCalibRun
int m_forceCalibRun
Definition: ZdcAnalysisTool.h:157
ZDC::ZdcAnalysisTool::m_deltaTCut
float m_deltaTCut
Definition: ZdcAnalysisTool.h:174
ZDCTriggerEfficiency
Definition: ZDCTriggerEfficiency.h:16
ReadHandle.h
Handle class for reading from StoreGate.
ZDC::ZdcAnalysisTool::m_zdcModuleCalibTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleCalibTime
Definition: ZdcAnalysisTool.h:214
ZDC::ZdcAnalysisTool::m_zdcSums
const xAOD::ZdcModuleContainer * m_zdcSums
Definition: ZdcAnalysisTool.h:151
ZDC::ZdcAnalysisTool::getTriggerEfficiencyUncertainty
double getTriggerEfficiencyUncertainty(int side)
Definition: ZdcAnalysisTool.cxx:2000
ZDCDataAnalyzer::enablePreExclusion
void enablePreExclusion(unsigned int maxSamplesExcl, const ZDCModuleIntArray &HGADCThresh, const ZDCModuleIntArray &LGADCThresh)
Definition: ZDCDataAnalyzer.cxx:134
ZDCPulseAnalyzer::GetFitAmplitude
float GetFitAmplitude() const
Definition: ZDCPulseAnalyzer.h:518
ZDC::ZdcAnalysisTool::initializeLHCf2022
std::unique_ptr< ZDCDataAnalyzer > initializeLHCf2022()
Definition: ZdcAnalysisTool.cxx:210
EventInfo.h
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
RPDConfig
Definition: RPDDataAnalyzer.h:18
ZDCPulseAnalyzer::GetMinDeriv2nd
float GetMinDeriv2nd() const
Definition: ZDCPulseAnalyzer.h:555
ZDC::ZdcAnalysisTool::m_rpdSideAOutputCalibFactors
std::vector< float > m_rpdSideAOutputCalibFactors
Definition: ZdcAnalysisTool.h:189
ZDC::ZdcAnalysisTool::m_zdcTriggerEfficiency
std::shared_ptr< ZDCTriggerEfficiency > m_zdcTriggerEfficiency
Definition: ZdcAnalysisTool.h:206
ZDCPulseAnalyzer::GetFitT0
float GetFitT0() const
Definition: ZDCPulseAnalyzer.h:519
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ZDCDataAnalyzer::SetNonlinCorrParams
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)
Definition: ZDCDataAnalyzer.cxx:317
ZDC::ZdcAnalysisTool::m_zdcModuleFitAmpError
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleFitAmpError
Definition: ZdcAnalysisTool.h:219
ZDC::ZdcAnalysisTool::getAverageTime
float getAverageTime(int side)
Definition: ZdcAnalysisTool.cxx:1972
ZDC::ZdcAnalysisTool::m_rpdChannelStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelStatus
Definition: ZdcAnalysisTool.h:239
ZDC::ZdcAnalysisTool::m_rpdChannelPileupExpFitMSE
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupExpFitMSE
Definition: ZdcAnalysisTool.h:232
ZDC::ZdcAnalysisTool::m_zdcModulePresample
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePresample
Definition: ZdcAnalysisTool.h:223
ZDCPulseAnalyzer::GetBkgdMaxFraction
float GetBkgdMaxFraction() const
Definition: ZDCPulseAnalyzer.h:561
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ZDCDataAnalyzer::disableModule
bool disableModule(size_t side, size_t module)
Definition: ZDCDataAnalyzer.cxx:91
ZDC::ZdcAnalysisTool::initializeTriggerEffs
void initializeTriggerEffs(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:97
ZDC::ZdcAnalysisTool::m_zdcModuleTime
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleTime
Definition: ZdcAnalysisTool.h:216
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
ZDC::ZdcAnalysisTool::configureNewRun
StatusCode configureNewRun(unsigned int runNumber)
Definition: ZdcAnalysisTool.cxx:1387
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ZDCDataAnalyzer::ZDCModuleBoolArray
std::array< std::array< bool, 4 >, 2 > ZDCModuleBoolArray
Definition: ZDCDataAnalyzer.h:23
ZDC::ZdcAnalysisTool::sigprocMaxFinder
static bool sigprocMaxFinder(const std::vector< unsigned short > &adc, float deltaT, float &amp, float &time, float &qual)
Definition: ZdcAnalysisTool.cxx:1900
ZDC::ZdcAnalysisTool::m_peak2ndDerivMinThresholdsHG
ZDCDataAnalyzer::ZDCModuleFloatArray m_peak2ndDerivMinThresholdsHG
Definition: ZdcAnalysisTool.h:202
ZDC::ZdcAnalysisTool::initializeDefault
std::unique_ptr< ZDCDataAnalyzer > initializeDefault()
Definition: ZdcAnalysisTool.cxx:598
ZDC
Definition: RpdSubtractCentroidTool.cxx:13
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
ZDC::ZdcAnalysisTool::m_zdcDataAnalyzer_40MHz
std::shared_ptr< ZDCDataAnalyzer > m_zdcDataAnalyzer_40MHz
Definition: ZdcAnalysisTool.h:196
ZDCDataAnalyzer::SetFitTimeMax
void SetFitTimeMax(float tmax)
Definition: ZDCDataAnalyzer.cxx:217
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
ZDC::ZdcAnalysisTool::m_deltaTSample
float m_deltaTSample
Definition: ZdcAnalysisTool.h:164
ZDC::ZdcAnalysisTool::initializeDecorations
void initializeDecorations()
Definition: ZdcAnalysisTool.cxx:1382
ZDCPulseAnalyzer::GetMaxADC
float GetMaxADC() const
Definition: ZDCPulseAnalyzer.h:541
ZDC::ZdcAnalysisTool::m_zdcSumUncalibSumErr
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumUncalibSumErr
Definition: ZdcAnalysisTool.h:244
ZDC::ZdcAnalysisTool::m_zdcTimeCalibFileName
std::string m_zdcTimeCalibFileName
Definition: ZdcAnalysisTool.h:131
ZDC::ZdcAnalysisTool::m_peakSample
unsigned int m_peakSample
Definition: ZdcAnalysisTool.h:166
beamspotman.qual
qual
Definition: beamspotman.py:481
ZDC::ZdcAnalysisTool::getCalibModuleSum
float getCalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:1948
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
ZDC::ZdcAnalysisTool::m_lowGainOnly
bool m_lowGainOnly
Definition: ZdcAnalysisTool.h:153
ZDC::ZdcAnalysisTool::m_zdcSumRPDStatus
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumRPDStatus
Definition: ZdcAnalysisTool.h:251
ZDC::ZdcAnalysisTool::initialize80MHz
void initialize80MHz()
Definition: ZdcAnalysisTool.cxx:1083
ZDCDataAnalyzer::enableRepass
void enableRepass(const ZDCModuleFloatArray &peak2ndDerivMinRepassHG, const ZDCModuleFloatArray &peak2ndDerivMinRepassLG)
Definition: ZDCDataAnalyzer.cxx:171
calibdata.copy
bool copy
Definition: calibdata.py:27
ZDC::ZdcAnalysisTool::initializePbPb2018
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2018()
Definition: ZdcAnalysisTool.cxx:836
ZDC::ZdcAnalysisTool::m_flipEMDelay
bool m_flipEMDelay
Definition: ZdcAnalysisTool.h:152
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
ZDC::ZdcAnalysisTool::m_zdcModulePreSampleAmp
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcModulePreSampleAmp
Definition: ZdcAnalysisTool.h:222
ZDC::ZdcAnalysisTool::m_rpdDataAnalyzer
std::vector< std::unique_ptr< RPDDataAnalyzer > > m_rpdDataAnalyzer
Definition: ZdcAnalysisTool.h:199
ZDCDataAnalyzer::SetPeak2ndDerivMinTolerances
void SetPeak2ndDerivMinTolerances(size_t tolerance)
Definition: ZDCDataAnalyzer.cxx:208
ZDCPulseAnalyzer::GetChisq
float GetChisq() const
Definition: ZDCPulseAnalyzer.h:523
ZDC::ZdcAnalysisTool::initializePbPb2015G4
std::unique_ptr< ZDCDataAnalyzer > initializePbPb2015G4()
Definition: ZdcAnalysisTool.cxx:661
ZDC::ZdcAnalysisTool::m_zdcEnergyCalibFileName
std::string m_zdcEnergyCalibFileName
Definition: ZdcAnalysisTool.h:130
ZDC::ZdcAnalysisTool::m_t0
float m_t0
Definition: ZdcAnalysisTool.h:168
ZDC::ZdcAnalysisTool::sigprocSincInterp
bool sigprocSincInterp(const std::vector< unsigned short > &adc, float deltaT, float &amp, float &time, float &qual)
Definition: ZdcAnalysisTool.cxx:1927
python.DataFormatRates.env
env
Definition: DataFormatRates.py:32
ZDC::ZdcAnalysisTool::ZdcAnalysisTool
ZdcAnalysisTool(const std::string &name)
Definition: ZdcAnalysisTool.cxx:23
ZDCDataAnalyzer::SetSaveFitFunc
void SetSaveFitFunc(bool save)
Definition: ZDCDataAnalyzer.cxx:226
ZDC::ZdcAnalysisTool::m_rpdChannelAmplitudeCalib
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelAmplitudeCalib
Definition: ZdcAnalysisTool.h:235
ZDC::ZdcAnalysisTool::m_doCalib
bool m_doCalib
Definition: ZdcAnalysisTool.h:155
ZDCDataAnalyzer::SetGainFactorsHGLG
void SetGainFactorsHGLG(float gainFactorHG, float gainFactorLG)
Definition: ZDCDataAnalyzer.cxx:190
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ZDCDataAnalyzer::SetTimingCorrParams
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)
Definition: ZDCDataAnalyzer.cxx:304
ZDC::ZdcAnalysisTool::m_auxSuffix
std::string m_auxSuffix
Definition: ZdcAnalysisTool.h:135
ZDC::ZdcAnalysisTool::initialize40MHz
void initialize40MHz()
Definition: ZdcAnalysisTool.cxx:963
ZDC::ZdcAnalysisTool::m_fixTau2
bool m_fixTau2
Definition: ZdcAnalysisTool.h:173
ZDC::ZdcAnalysisTool::m_zdcSumCalibEnergy
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_zdcSumCalibEnergy
Definition: ZdcAnalysisTool.h:245
ZDC::ZdcAnalysisTool::m_rpdChannelPileupStretchedExpFitMSE
SG::WriteDecorHandleKey< xAOD::ZdcModuleContainer > m_rpdChannelPileupStretchedExpFitMSE
Definition: ZdcAnalysisTool.h:233
ZDC::ZdcAnalysisTool::m_name
std::string m_name
Definition: ZdcAnalysisTool.h:126
ZDC::ZdcAnalysisTool::m_rpdGoodPulseSampleStart
unsigned int m_rpdGoodPulseSampleStart
Definition: ZdcAnalysisTool.h:181
ZDC::ZdcAnalysisTool::m_eventReady
bool m_eventReady
Definition: ZdcAnalysisTool.h:137
ZDCPulseAnalyzer::GetPreSampleAmp
float GetPreSampleAmp() const
Definition: ZDCPulseAnalyzer.h:560
ZDCDataAnalyzer::SetModuleAmpFractionLG
void SetModuleAmpFractionLG(const ZDCDataAnalyzer::ZDCModuleFloatArray &moduleAmpFractionLG)
Definition: ZDCDataAnalyzer.cxx:252
ZDC::ZdcAnalysisTool::getUncalibModuleSum
float getUncalibModuleSum(int side)
Definition: ZdcAnalysisTool.cxx:1960
RPDConfig::nRows
unsigned int nRows
Definition: RPDDataAnalyzer.h:19
Generated on Sun Jun 30 2024 21:33:07 for ATLAS Offline Software by   doxygen 1.8.18