ATLAS Offline Software
ZdcNtuple.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include <TSystem.h>
6 #include <TFile.h>
7 #include "xAODRootAccess/tools/Message.h"
8 #include "xAODRootAccess/Init.h"
9 #include "xAODRootAccess/TEvent.h"
10 #include "xAODCore/ShallowCopy.h"
11 #include "AthContainers/ConstAccessor.h"
12 
13 #include <ZdcNtuple/ZdcNtuple.h>
14 #include <ZdcUtils/ZdcEventInfo.h>
15 #include <ZdcConditions/ZdcInjPulserAmpMap.h>
16 
17 // this is needed to distribute the algorithm to the workers
18 //ClassImp(ZdcNtuple)
19 
20 ZdcNtuple :: ZdcNtuple (const std::string& name, ISvcLocator *pSvcLocator)
21  : EL::AnaAlgorithm(name, pSvcLocator),
22  m_grl ("GoodRunsListSelectionTool/grl", this),
23  //m_zdcAnalysisTool("ZDC::ZdcAnalysisTool/ZdcAnalysisTool", this),
24  m_selTool( "InDet::InDetTrackSelectionTool/TrackSelectionTool", this )
25 {
26  // Here you put any code for the base initialization of variables,
27  // e.g. initialize all pointers to 0. Note that you should only put
28  // the most basic initialization here, since this method will be
29  // called on both the submission and the worker node. Most of your
30  // initialization code will go into histInitialize() and
31  // initialize().
32  m_setupTrigHist = false;
33  m_eventCounter = 0;
34 
35  declareProperty("isMC", m_isMC = false, "MC mode");
36  declareProperty("enableOutputTree", enableOutputTree = false, "Enable output tree");
37  declareProperty("enableOutputSamples", enableOutputSamples = false, "Output ZDC and RPD raw data");
38  declareProperty("enableTrigger", enableTrigger = true, "comment");
39  declareProperty("enableTracks", enableTracks = false, "comment");
40  declareProperty("trackLimit", trackLimit = 500, "comment");
41  declareProperty("enableID", enableID = false, "turn on to enable ID tracks & vertices for physics streams");
42  declareProperty("enableCalo", enableCalo = false, "turn on to enable calorimeter energy info for physics streams");
43  declareProperty("enableClusters", enableClusters = false, "turn on to enable calo topo cluster info for physics streams");
44  declareProperty("writeOnlyTriggers", writeOnlyTriggers = false, "comment");
45  declareProperty("useGRL", useGRL = true, "comment");
46  declareProperty("grlFilename", grlFilename = "$ROOTCOREBIN/data/ZdcNtuple/data16_hip8TeV.periodAllYear_DetStatus-v86-pro20-19_DQDefects-00-02-04_PHYS_HeavyIonP_All_Good.xml", "comment");
47  declareProperty("slimmed", slimmed = false, "comment");
48  declareProperty("zdcCalib", zdcCalib = false, "zdc/ZDCCalib file");
49  declareProperty("zdcInj", zdcInj = false, "ZDC injected pulse");
50  declareProperty("zdcLaser", zdcLaser = false, "Run 2 ZDC Laser");
51  declareProperty("zdcOnly", zdcOnly = false, "comment");
52  declareProperty("zdcLowGainMode", zdcLowGainMode = 0, "comment");
53 
54  declareProperty("flipDelay", flipDelay = 0, "comment");
55  declareProperty("reprocZdc", reprocZdc = 0, "comment");
56  declareProperty("auxSuffix", auxSuffix = "", "comment");
57  declareProperty("nsamplesZdc", nsamplesZdc = 24, "number of samples, 7 = most of Run 2, 24 = Run 3");
58  declareProperty("lhcf2022", lhcf2022 = false,"LHCf2022 general config");
59  declareProperty("lhcf2022afp", lhcf2022afp = false,"LHCf2022 AFP-specific config");
60  declareProperty("lhcf2022zdc", lhcf2022zdc = false,"LHCf2022 ZDC-specific config");
61  declareProperty("pbpb2023", pbpb2023 = true, "PbPb2023 config");
62  declareProperty("zdcConfig", zdcConfig = "PbPb2018", "argument to configure ZdcAnalysisTool");
63  declareProperty("doZdcCalib", doZdcCalib = false, "perform ZDC energy calibration");
64  declareProperty("enableZDC", enableZDC = true);
65  declareProperty("enableRPD",enableRPD = false,"enable reading any RPD decorations");
66  declareProperty("enableRPDAmp",enableRPDAmp = false,"enable reading RPD amplitudes (also requires enableRPD)");
67  declareProperty("enableCentroid",enableCentroid = false,"enable reading centroid decorations (also requires enableRPD)");
68 
69  declareProperty( "TrackSelectionTool", m_selTool );
70 
71  m_zdcAnalysisTool.declarePropertyFor (this, "zdcAnalysisTool");
72 
73 }
74 
75 /*
76 StatusCode ZdcNtuple :: setupJob (EL::Job& job)
77 {
78  // Here you put code that sets up the job on the submission object
79  // so that it is ready to work with your algorithm, e.g. you can
80  // request the D3PDReader service or add output files. Any code you
81  // put here could instead also go into the submission script. The
82  // sole advantage of putting it here is that it gets automatically
83  // activated/deactivated when you add/remove the algorithm from your
84  // job, which may or may not be of value to you.
85 
86  job.useXAOD ();
87  ANA_CHECK( "setupJob()", xAOD::Init() ); // call before opening first file
88 
89  return StatusCode::SUCCESS;
90 }
91 */
92 
93 
94 StatusCode ZdcNtuple :: initialize ()
95 {
96  // Here you do everything that needs to be done at the very
97  // beginning on each worker node, e.g. create histograms and output
98  // trees. This method gets called before any input files are
99  // connected.
100 
101  ANA_MSG_DEBUG("Howdy from Initialize!");
102 
103  ANA_CHECK(m_zdcModuleContainerName.initialize());
104  ANA_CHECK(m_zdcSumContainerName.initialize());
105  ATH_CHECK(m_mcEventCollectionName.initialize());
106 
107  if (enableOutputTree)
108  {
109 
110  ANA_CHECK( book(TTree("zdcTree", "ZDC Tree")));
111  m_outputTree = tree( "zdcTree" );
112 
113  m_outputTree->Branch("runNumber", &t_runNumber, "runNumber/i");
114  m_outputTree->Branch("eventNumber", &t_eventNumber, "eventNumber/i");
115  m_outputTree->Branch("lumiBlock", &t_lumiBlock, "lumiBlock/i");
116  m_outputTree->Branch("bunchGroup", &t_bunchGroup, "bunchGroup/b");
117  m_outputTree->Branch("bcid", &t_bcid, "bcid/i");
118  if (zdcInj) m_outputTree->Branch("vInj",&t_vInj,"vInj/F");
119  m_outputTree->Branch("avgIntPerCrossing", &t_avgIntPerCrossing, "avgIntPerCrossing/F");
120  m_outputTree->Branch("actIntPerCrossing", &t_actIntPerCrossing, "actIntPerCrossing/F");
121  m_outputTree->Branch("trigger", &t_trigger, "trigger/l");
122  m_outputTree->Branch("trigger_TBP", &t_trigger_TBP, "trigger_TBP/i");
123  m_outputTree->Branch("tbp", &t_tbp, "tbp[16]/i");
124  m_outputTree->Branch("tav", &t_tav, "tav[16]/i");
125  m_outputTree->Branch("passBits", &t_passBits, "passBits/i");
126  m_outputTree->Branch("extendedLevel1ID",&t_extendedLevel1ID,"extendedLevel1ID/i");
127  m_outputTree->Branch("timeStamp",&t_timeStamp,"timeStamp/i");
128  m_outputTree->Branch("timeStampNSOffset",&t_timeStampNSOffset,"timeStampNSOffset/i");
129  m_outputTree->Branch("zdcEventInfoError",&t_zdcEventInfoError,"zdcEventInfoError/b");
130  m_outputTree->Branch("zdcEventInfoErrorWord",&t_zdcEventInfoErrorWord,"zdcEventInfoErrorWord/i");
131  // ZDC and RPD decoding errors
132  m_outputTree->Branch("zdcDecodingError",&t_zdcDecodingError,"zdcDecodingError/b");
133  m_outputTree->Branch("rpdDecodingError",&t_rpdDecodingError,"rpdDecodingError/b");
134 
135  if (enableZDC)
136  {
137  if (enableOutputSamples)
138  {
139  if (nsamplesZdc == 7)
140  {
141  ANA_MSG_INFO("Setting up for 7 samples");
142  m_outputTree->Branch("zdc_raw", &t_raw7, "zdc_raw[2][4][2][2][7]/s"); // 7 samples
143  }
144 
145  if (nsamplesZdc == 15)
146  {
147  ANA_MSG_INFO("Setting up for 15 samples");
148  m_outputTree->Branch("zdc_raw", &t_raw15, "zdc_raw[2][4][2][2][15]/s"); // 15 samples
149  }
150 
151  if (nsamplesZdc == 24)
152  {
153  ANA_MSG_INFO("Setting up forr 24 samples");
154  m_outputTree->Branch("zdc_raw", &t_raw24, "zdc_raw[2][4][2][2][24]/s"); // 24 samples
155  m_outputTree->Branch("rpd_raw", &t_rpdRaw, "rpd_raw[2][16][24]/s"); // 24 samples
156  }
157  }
158 
159  m_outputTree->Branch("zdc_ZdcAmp", &t_ZdcAmp, "zdc_ZdcAmp[2]/F");
160  m_outputTree->Branch("zdc_ZdcAmpErr", &t_ZdcAmpErr, "zdc_ZdcAmpErr[2]/F");
161  m_outputTree->Branch("zdc_ZdcEnergy", &t_ZdcEnergy, "zdc_ZdcEnergy[2]/F");
162  m_outputTree->Branch("zdc_ZdcEnergyErr", &t_ZdcEnergyErr, "zdc_ZdcEnergyErr[2]/F");
163  m_outputTree->Branch("zdc_ZdcNLEnergy", &t_ZdcNLEnergy, "zdc_ZdcNLEnergy[2]/F");
164  m_outputTree->Branch("zdc_ZdcNLEnergyErr", &t_ZdcNLEnergyErr, "zdc_ZdcNLEnergyErr[2]/F");
165  m_outputTree->Branch("zdc_ZdcTime", &t_ZdcTime, "zdc_ZdcTime[2]/F");
166  m_outputTree->Branch("zdc_ZdcStatus", &t_ZdcStatus, "zdc_ZdcStatus[2]/S");
167  m_outputTree->Branch("zdc_ZdcTrigEff", &t_ZdcTrigEff, "zdc_ZdcTrigEff[2]/F");
168  m_outputTree->Branch("zdc_ZdcModuleMask", &t_ZdcModuleMask, "zdc_ZdcModuleMask/i");
169  m_outputTree->Branch("zdc_ZdcLucrodTriggerSideAmp",&t_ZdcLucrodTriggerSideAmp,"zdc_ZdcLucrodTriggerSideAmp[2]/S");
170  m_outputTree->Branch("zdc_ZdcLucrodTriggerSideAmpLG",&t_ZdcLucrodTriggerSideAmpLG,"zdc_ZdcLucrodTriggerSideAmpLG[2]/S");
171 
172  m_outputTree->Branch("zdc_ZdcModuleAmp", &t_ZdcModuleAmp, "zdc_ZdcModuleAmp[2][4]/F");
173  m_outputTree->Branch("zdc_ZdcModuleTime", &t_ZdcModuleTime, "zdc_ZdcModuleTime[2][4]/F");
174  m_outputTree->Branch("zdc_ZdcModuleFitAmp", &t_ZdcModuleFitAmp, "zdc_ZdcModuleFitAmp[2][4]/F");
175  m_outputTree->Branch("zdc_ZdcModuleFitT0", &t_ZdcModuleFitT0, "zdc_ZdcModuleFitT0[2][4]/F");
176  m_outputTree->Branch("zdc_ZdcModuleStatus", &t_ZdcModuleStatus, "zdc_ZdcModuleStatus[2][4]/i");
177  m_outputTree->Branch("zdc_ZdcModuleChisq", &t_ZdcModuleChisq, "zdc_ZdcModuleChisq[2][4]/F");
178  m_outputTree->Branch("zdc_ZdcModuleCalibAmp", &t_ZdcModuleCalibAmp, "zdc_ZdcModuleCalibAmp[2][4]/F");
179  m_outputTree->Branch("zdc_ZdcModuleCalibTime", &t_ZdcModuleCalibTime, "zdc_ZdcModuleCalibTime[2][4]/F");
180  m_outputTree->Branch("zdc_ZdcModuleBkgdMaxFraction", &t_ZdcModuleBkgdMaxFraction, "zdc_ZdcModuleBkgdMaxFraction[2][4]/F");
181  m_outputTree->Branch("zdc_ZdcModuleAmpError", &t_ZdcModuleAmpError, "zdc_ZdcModuleAmpError[2][4]/F");
182  m_outputTree->Branch("zdc_ZdcModuleMinDeriv2nd", &t_ZdcModuleMinDeriv2nd, "zdc_ZdcModuleMinDeriv2nd[2][4]/F");
183  m_outputTree->Branch("zdc_ZdcModulePresample", &t_ZdcModulePresample, "zdc_ZdcModulePresample[2][4]/F");
184  m_outputTree->Branch("zdc_ZdcModulePreSampleAmp", &t_ZdcModulePreSampleAmp, "zdc_ZdcModulePreSampleAmp[2][4]/F");
185  m_outputTree->Branch("zdc_ZdcLucrodTriggerAmp",&t_ZdcLucrodTriggerAmp,"zdc_ZdcLucrodTriggerAmp[2][4]/S");
186  m_outputTree->Branch("zdc_ZdcLucrodTriggerAmpLG",&t_ZdcLucrodTriggerAmpLG,"zdc_ZdcLucrodTriggerAmpLG[2][4]/S");
187  m_outputTree->Branch("zdc_ZdcModuleMaxADC",&t_ZdcModuleMaxADC,"zdc_ZdcModuleMaxADC[2][4]/F");
188  m_outputTree->Branch("zdc_ZdcModuleMaxADCHG",&t_ZdcModuleMaxADCHG,"zdc_ZdcModuleMaxADCHG[2][4]/F");
189  m_outputTree->Branch("zdc_ZdcModuleMaxADCLG",&t_ZdcModuleMaxADCLG,"zdc_ZdcModuleMaxADCLG[2][4]/F");
190  m_outputTree->Branch("zdc_ZdcModulePeakADCHG",&t_ZdcModulePeakADCHG,"zdc_ZdcModulePeakADCHG[2][4]/F");
191  m_outputTree->Branch("zdc_ZdcModulePeakADCLG",&t_ZdcModulePeakADCLG,"zdc_ZdcModulePeakADCLG[2][4]/F");
192  m_outputTree->Branch("zdc_ZdcModuleAmpLGRefit", &t_ZdcModuleAmpLGRefit, "zdc_ZdcModuleAmpLGRefit[2][4]/F");
193  m_outputTree->Branch("zdc_ZdcModuleAmpCorrLGRefit", &t_ZdcModuleAmpCorrLGRefit, "zdc_ZdcModuleAmpCorrLGRefit[2][4]/F");
194  m_outputTree->Branch("zdc_ZdcModuleT0LGRefit", &t_ZdcModuleT0LGRefit, "zdc_ZdcModuleT0LGRefit[2][4]/F");
195  m_outputTree->Branch("zdc_ZdcModuleT0SubLGRefit", &t_ZdcModuleT0SubLGRefit, "zdc_ZdcModuleT0SubLGRefit[2][4]/F");
196  m_outputTree->Branch("zdc_ZdcModuleChisqLGRefit", &t_ZdcModuleChisqLGRefit, "zdc_ZdcModuleChisqLGRefit[2][4]/F");
197 
198  if(m_isMC){
199  //Modules
200  m_outputTree->Branch("zdc_ZdcModuleTruthTotal",&t_ZdcModuleTruthTotal,"zdc_ZdcModuleTruthTotal[2][7]/F");
201  m_outputTree->Branch("zdc_ZdcModuleTruthInvisible",&t_ZdcModuleTruthInvis,"zdc_ZdcModuleTruthInvisible[2][7]/F");
202  m_outputTree->Branch("zdc_ZdcModuleTruthEM",&t_ZdcModuleTruthEM,"zdc_ZdcModuleTruthEM[2][7]/F");
203  m_outputTree->Branch("zdc_ZdcModuleTruthNonEM",&t_ZdcModuleTruthNonEM,"zdc_ZdcModuleTruthNonEM[2][7]/F");
204  m_outputTree->Branch("zdc_ZdcModuleTruthEscaped",&t_ZdcModuleTruthEscaped,"zdc_ZdcModuleTruthEscaped[2][7]/F");
205  m_outputTree->Branch("zdc_ZdcModuleTruthNphotons",&t_ZdcModuleTruthNphotons,"zdc_ZdcModuleTruthNphotons[2][7]/i");
206  m_outputTree->Branch("zdc_RpdModuleTruthNphotons",&t_RpdModuleTruthNphotons,"zdc_RpdModuleTruthNphotons[2][16]/i");
207 
208  //Sums
209  m_outputTree->Branch("zdc_ZdcTruthTotal",&t_ZdcTruthTotal,"zdc_ZdcTruthTotal[2]/F");
210  m_outputTree->Branch("zdc_ZdcTruthInvisible",&t_ZdcTruthInvis, "zdc_ZdcTruthInvisible[2]/F");
211  m_outputTree->Branch("zdc_ZdcTruthEM",&t_ZdcTruthEM,"zdc_ZdcTruthEM[2]/F");
212  m_outputTree->Branch("zdc_ZdcTruthNonEM",&t_ZdcTruthNonEM,"zdc_ZdcTruthNonEM[2]/F");
213  m_outputTree->Branch("zdc_ZdcTruthEscaped",&t_ZdcTruthEscaped,"zdc_ZdcTruthEscaped[2]/F");
214 
215  //Event gen particles
216  m_outputTree->Branch("zdc_ZdcTruthParticlePosx",&t_ZdcTruthParticlePosx);
217  m_outputTree->Branch("zdc_ZdcTruthParticlePosy",&t_ZdcTruthParticlePosy);
218  m_outputTree->Branch("zdc_ZdcTruthParticlePosz",&t_ZdcTruthParticlePosz);
219  m_outputTree->Branch("zdc_ZdcTruthParticleTime",&t_ZdcTruthParticleTime);
220  m_outputTree->Branch("zdc_ZdcTruthParticlePx",&t_ZdcTruthParticlePx);
221  m_outputTree->Branch("zdc_ZdcTruthParticlePy",&t_ZdcTruthParticlePy);
222  m_outputTree->Branch("zdc_ZdcTruthParticlePz",&t_ZdcTruthParticlePz);
223  m_outputTree->Branch("zdc_ZdcTruthParticleEnergy",&t_ZdcTruthParticleEnergy);
224  m_outputTree->Branch("zdc_ZdcTruthParticlePid",&t_ZdcTruthParticlePid);
225  m_outputTree->Branch("zdc_ZdcTruthParticleStatus",&t_ZdcTruthParticleStatus);
226  }
227  }
228  if (enableRPD)
229  {
230  if (enableRPDAmp) {
231  m_outputTree->Branch("zdc_RpdChannelBaseline",&t_RpdChannelBaseline,"zdc_RpdChannelBaseline[2][16]/F");
232  m_outputTree->Branch("zdc_RpdChannelPileupExpFitParams",&t_RpdChannelPileupExpFitParams,"zdc_RpdChannelPileupExpFitParams[2][16][2]/F");
233  m_outputTree->Branch("zdc_RpdChannelPileupStretchedExpFitParams",&t_RpdChannelPileupStretchedExpFitParams,"zdc_RpdChannelPileupStretchedExpFitParams[2][16][3]/F");
234  m_outputTree->Branch("zdc_RpdChannelPileupExpFitParamErrs",&t_RpdChannelPileupExpFitParamErrs,"zdc_RpdChannelPileupExpFitParamErrs[2][16][2]/F");
235  m_outputTree->Branch("zdc_RpdChannelPileupStretchedExpFitParamErrs",&t_RpdChannelPileupStretchedExpFitParamErrs,"zdc_RpdChannelPileupStretchedExpFitParamErrs[2][16][3]/F");
236  m_outputTree->Branch("zdc_RpdChannelPileupExpFitMSE",&t_RpdChannelPileupExpFitMSE,"zdc_RpdChannelPileupExpFitMSE[2][16]/F");
237  m_outputTree->Branch("zdc_RpdChannelPileupStretchedExpFitMSE",&t_RpdChannelPileupStretchedExpFitMSE,"zdc_RpdChannelPileupStretchedExpFitMSE[2][16]/F");
238  m_outputTree->Branch("zdc_RpdChannelAmplitude",&t_RpdChannelAmplitude,"zdc_RpdChannelAmplitude[2][16]/F");
239  m_outputTree->Branch("zdc_RpdChannelAmplitudeCalib",&t_RpdChannelAmplitudeCalib,"zdc_RpdChannelAmplitudeCalib[2][16]/F");
240  m_outputTree->Branch("zdc_RpdChannelMaxADC",&t_RpdChannelMaxADC,"zdc_RpdChannelMaxADC[2][16]/F");
241  m_outputTree->Branch("zdc_RpdChannelMaxADCCalib",&t_RpdChannelMaxADCCalib,"zdc_RpdChannelMaxADCCalib[2][16]/F");
242  m_outputTree->Branch("zdc_RpdChannelMaxSample",&t_RpdChannelMaxSample,"zdc_RpdChannelMaxSample[2][16]/i");
243  m_outputTree->Branch("zdc_RpdChannelStatus",&t_RpdChannelStatus,"zdc_RpdChannelStatus[2][16]/i");
244  m_outputTree->Branch("zdc_RpdChannelPileupFrac",&t_RpdChannelPileupFrac,"zdc_RpdChannelPileupFrac[2][16]/F");
245  m_outputTree->Branch("zdc_RpdSideStatus",&t_RpdSideStatus,"zdc_RpdSideStatus[2]/i");
246  }
247  if (enableCentroid)
248  {
249  m_outputTree->Branch("zdc_centroidAvailable", &t_centroidDecorationsAvailable);
250  m_outputTree->Branch("zdc_centroidEventValid", &t_centroidEventValid, "zdc_centroidEventValid/B");
251  m_outputTree->Branch("zdc_centroidStatus", &t_centroidStatus, "zdc_centroidStatus[2]/i");
252  m_outputTree->Branch("zdc_RPDChannelSubtrAmp", &t_RPDChannelSubtrAmp, "zdc_RPDChannelSubtrAmp[2][16]/F");
253  m_outputTree->Branch("zdc_RPDSubtrAmpSum", &t_RPDSubtrAmpSum, "zdc_RPDSubtrAmpSum[2]/F");
254  m_outputTree->Branch("zdc_xCentroidPreGeomCorPreAvgSubtr", &t_xCentroidPreGeomCorPreAvgSubtr, "zdc_xCentroidPreGeomCorPreAvgSubtr[2]/F");
255  m_outputTree->Branch("zdc_yCentroidPreGeomCorPreAvgSubtr", &t_yCentroidPreGeomCorPreAvgSubtr, "zdc_yCentroidPreGeomCorPreAvgSubtr[2]/F");
256  m_outputTree->Branch("zdc_xCentroidPreAvgSubtr", &t_xCentroidPreAvgSubtr, "zdc_xCentroidPreAvgSubtr[2]/F");
257  m_outputTree->Branch("zdc_yCentroidPreAvgSubtr", &t_yCentroidPreAvgSubtr, "zdc_yCentroidPreAvgSubtr[2]/F");
258  m_outputTree->Branch("zdc_xCentroid", &t_xCentroid, "zdc_xCentroid[2]/F");
259  m_outputTree->Branch("zdc_yCentroid", &t_yCentroid, "zdc_yCentroid[2]/F");
260  m_outputTree->Branch("zdc_xRowCentroid", &t_xRowCentroid, "zdc_xRowCentroid[2][4]/F");
261  m_outputTree->Branch("zdc_yColCentroid", &t_yColCentroid, "zdc_yColCentroid[2][4]/F");
262  m_outputTree->Branch("zdc_reactionPlaneAngle", &t_reactionPlaneAngle, "zdc_reactionPlaneAngle[2]/F");
263  m_outputTree->Branch("zdc_cosDeltaReactionPlaneAngle", &t_cosDeltaReactionPlaneAngle, "zdc_cosDeltaReactionPlaneAngle/F");
264  }
265  }
266 
267  if (!(zdcCalib || zdcLaser || zdcOnly || zdcInj))
268  {
269  m_outputTree->Branch("mbts_in_e", &t_mbts_in_e, "mbts_in_e[2][8]/F");
270  m_outputTree->Branch("mbts_in_t", &t_mbts_in_t, "mbts_in_t[2][8]/F");
271  m_outputTree->Branch("mbts_out_e", &t_mbts_out_e, "mbts_out_e[2][4]/F");
272  m_outputTree->Branch("mbts_out_t", &t_mbts_out_t, "mbts_out_t[2][4]/F");
273 
274  m_outputTree->Branch("T2mbts_in_e", &t_T2mbts_in_e, "T2mbts_in_e[2][8]/F");
275  m_outputTree->Branch("T2mbts_in_t", &t_T2mbts_in_t, "T2mbts_in_t[2][8]/F");
276  m_outputTree->Branch("T2mbts_out_e", &t_T2mbts_out_e, "T2mbts_out_e[2][4]/F");
277  m_outputTree->Branch("T2mbts_out_t", &t_T2mbts_out_t, "T2mbts_out_t[2][4]/F");
278 
279  m_outputTree->Branch("L1ET", &t_L1ET, "L1ET/F");
280  m_outputTree->Branch("L1ET24", &t_L1ET24, "L1ET24/F");
281 
282  m_outputTree->Branch("totalEt", &t_totalEt, "totalEt/F");
283  m_outputTree->Branch("totalEt_TTsum", &t_totalEt_TTsum, "totalEt_TTsum/F");
284 
285  m_outputTree->Branch("totalEt24", &t_totalEt24, "totalEt24/F");
286  m_outputTree->Branch("totalEt24_TTsum", &t_totalEt24_TTsum, "totalEt24_TTsum/F");
287 
288  m_outputTree->Branch("fcalEt", &t_fcalEt, "fcalEt/F");
289  m_outputTree->Branch("fcalEtA", &t_fcalEtA, "fcalEtA/F");
290  m_outputTree->Branch("fcalEtC", &t_fcalEtC, "fcalEtC/F");
291  m_outputTree->Branch("fcalEtA_TT", &t_fcalEtA_TT, "fcalEtA_TT/F");
292  m_outputTree->Branch("fcalEtC_TT", &t_fcalEtC_TT, "fcalEtC_TT/F");
293 
294  m_outputTree->Branch("nvx", &t_nvx, "nvx/I");
295  m_outputTree->Branch("vx", &t_vx, "vx[3]/F");
296  m_outputTree->Branch("pvindex", &t_pvindex, "pvindex/I");
297  m_outputTree->Branch("vxntrk", &t_vxntrk, "vxntrk/I");
298  m_outputTree->Branch("vx_trk_index", "vector<int>", &t_vx_trk_index);
299  m_outputTree->Branch("vxtype", &t_vxtype, "vxtype/I");
300  m_outputTree->Branch("vxcov", &t_vxcov, "vxcov[6]/F");
301  m_outputTree->Branch("vxsumpt2", &t_vxsumpt2, "vxsumpt2/F");
302  m_outputTree->Branch("nstrong", &t_nstrong, "nstrong/I");
303  m_outputTree->Branch("puvxntrk", &t_puvxntrk, "puvxntrk/I");
304  m_outputTree->Branch("puvxsumpt", &t_puvxsumpt, "puvxsumpt/F");
305  m_outputTree->Branch("puvxz", &t_puvxz, "puvxz/F");
306  m_outputTree->Branch("vxnlooseprimary", &t_vxnlooseprimary, "vxnlooseprimary/I");
307  m_outputTree->Branch("vxnminbias", &t_vxnminbias, "vxnminbias/I");
308  m_outputTree->Branch("vxngoodmuon", &t_vxngoodmuon, "vxngoodmuon/I");
309 
310  m_outputTree->Branch("t_nvtx", &t_nvtx, "nvtx/I");
311  m_outputTree->Branch("vtx_type", "vector<int8_t>", &t_vtx_type);
312  m_outputTree->Branch("vtx_x", "vector<float>", &t_vtx_x);
313  m_outputTree->Branch("vtx_y", "vector<float>", &t_vtx_y);
314  m_outputTree->Branch("vtx_z", "vector<float>", &t_vtx_z);
315  m_outputTree->Branch("vtx_ntrk_all", "vector<int16_t>", &t_vtx_ntrk_all);
316  m_outputTree->Branch("vtx_sumpt2_all", "vector<float>", &t_vtx_sumpt2_all);
317  m_outputTree->Branch("vtx_ntrk", "vector<int16_t>", &t_vtx_ntrk);
318  m_outputTree->Branch("vtx_sumpt2", "vector<float>", &t_vtx_sumpt2);
319  m_outputTree->Branch("vtx_trk_index", "vector< vector<int16_t> >", &t_vtx_trk_index);
320 
321  m_outputTree->Branch("mbts_countA", &t_mbts_countA, "mbts_countA/s");
322  m_outputTree->Branch("mbts_countC", &t_mbts_countC, "mbts_countC/s");
323  m_outputTree->Branch("T2mbts_countAin", &t_T2mbts_countAin, "T2mbts_countAin/s");
324  m_outputTree->Branch("T2mbts_countCin", &t_T2mbts_countCin, "T2mbts_countCin/s");
325  m_outputTree->Branch("mbts_timeA", &t_mbts_timeA, "mbts_timeA/F");
326  m_outputTree->Branch("mbts_timeC", &t_mbts_timeC, "mbts_timeC/F");
327  m_outputTree->Branch("mbts_timeDiff", &t_mbts_timeDiff, "mbts_timeDiff/F");
328 
329  t_nclus = 0;
330  m_outputTree->Branch("nclus", &t_nclus, "nclus/i");
331  m_outputTree->Branch("clusEt", &t_clusEt, "clusEt/F");
332  m_outputTree->Branch("clusEtMax", &t_clusEtMax, "clusEtMax/F");
333  m_outputTree->Branch("clusetaMax", &t_clusetaMax, "clusetaMax/F");
334  m_outputTree->Branch("clusphiMax", &t_clusphiMax, "clusphiMax/F");
335 
336  m_outputTree->Branch("cc_pt", "vector<float>", &t_cc_pt);
337  m_outputTree->Branch("cc_eta", "vector<float>", &t_cc_eta);
338  m_outputTree->Branch("cc_phi", "vector<float>", &t_cc_phi);
339  m_outputTree->Branch("cc_e", "vector<float>", &t_cc_e);
340  m_outputTree->Branch("cc_raw_m", "vector<float>", &t_cc_raw_m);
341  m_outputTree->Branch("cc_raw_eta", "vector<float>", &t_cc_raw_eta);
342  m_outputTree->Branch("cc_raw_phi", "vector<float>", &t_cc_raw_phi);
343  m_outputTree->Branch("cc_raw_e", "vector<float>", &t_cc_raw_e);
344  m_outputTree->Branch("cc_raw_samp", "vector<vector<float>>", &t_cc_raw_samp);
345  m_outputTree->Branch("cc_sig", "vector<float>", &t_cc_sig);
346  m_outputTree->Branch("cc_layer", "vector<int>", &t_cc_layer);
347 
348  m_outputTree->Branch("edgeGapA", &t_edgeGapA, "edgeGapA/F");
349  m_outputTree->Branch("edgeGapC", &t_edgeGapC, "edgeGapC/F");
350 
351  m_outputTree->Branch("ntrk", &t_ntrk, "ntrk/i");
352  if (enableTracks)
353  {
354  m_outputTree->Branch("trk_pt", "vector<float>", &t_trk_pt);
355  m_outputTree->Branch("trk_eta", "vector<float>", &t_trk_eta);
356  m_outputTree->Branch("trk_theta", "vector<float>", &t_trk_theta);
357  m_outputTree->Branch("trk_phi", "vector<float>", &t_trk_phi);
358  m_outputTree->Branch("trk_e", "vector<float>", &t_trk_e);
359  m_outputTree->Branch("trk_index", "vector<int>", &t_trk_index);
360  m_outputTree->Branch("trk_d0", "vector<float>", &t_trk_d0);
361  m_outputTree->Branch("trk_z0", "vector<float>", &t_trk_z0);
362  m_outputTree->Branch("trk_vz", "vector<float>", &t_trk_vz);
363  m_outputTree->Branch("trk_vtxz", "vector<float>", &t_trk_vtxz);
364  m_outputTree->Branch("trk_pixeldEdx", "vector<float>", &t_trk_pixeldEdx);
365  m_outputTree->Branch("trk_charge", "vector<int8_t>", &t_trk_charge);
366  m_outputTree->Branch("trk_quality", "vector<int16_t>", &t_trk_quality);
367  m_outputTree->Branch("trk_nPixHits", "vector<uint8_t>", &t_trk_nPixHits);
368  m_outputTree->Branch("trk_nSctHits", "vector<uint8_t>", &t_trk_nSctHits);
369  m_outputTree->Branch("trk_nPixDead", "vector<uint8_t>", &t_trk_nPixDead);
370  m_outputTree->Branch("trk_nSctDead", "vector<uint8_t>", &t_trk_nSctDead);
371  m_outputTree->Branch("trk_nPixHoles", "vector<uint8_t>", &t_trk_nPixHoles);
372  m_outputTree->Branch("trk_nSctHoles", "vector<uint8_t>", &t_trk_nSctHoles);
373  m_outputTree->Branch("trk_nTrtHits", "vector<uint8_t>", &t_trk_nTrtHits);
374  m_outputTree->Branch("trk_nTrtOutliers", "vector<uint8_t>", &t_trk_nTrtOutliers);
375  m_outputTree->Branch("trk_inPixHits", "vector<uint8_t>", &t_trk_inPixHits);
376  m_outputTree->Branch("trk_exPixHits", "vector<uint8_t>", &t_trk_exPixHits);
377  m_outputTree->Branch("trk_ninPixHits", "vector<uint8_t>", &t_trk_ninPixHits);
378  m_outputTree->Branch("trk_nexPixHits", "vector<uint8_t>", &t_trk_nexPixHits);
379  }
380 
381  if( lhcf2022 || lhcf2022zdc || lhcf2022afp){
382  m_outputTree->Branch("nProtons", &nProtons, "nProtons/i");
383  m_outputTree->Branch("proton_pt", "vector<double>", &proton_pt);
384  m_outputTree->Branch("proton_eta", "vector<double>", &proton_eta);
385  m_outputTree->Branch("proton_phi", "vector<double>", &proton_phi);
386  m_outputTree->Branch("proton_e", "vector<double>", &proton_e);
387  m_outputTree->Branch("proton_side", "vector<int>", &proton_side);
388  m_outputTree->Branch("proton_eLoss", "vector<double>", &proton_eLoss);
389  m_outputTree->Branch("proton_t", "vector<double>", &proton_t);
390  m_outputTree->Branch("proton_track_stationID", "vector<vector<int>>", &proton_track_stationID);
391  m_outputTree->Branch("proton_track_nClusters", "vector<vector<int>>", &proton_track_nClusters);
392  m_outputTree->Branch("proton_track_xLocal", "vector<vector<float>>", &proton_track_xLocal);
393  m_outputTree->Branch("proton_track_yLocal", "vector<vector<float>>", &proton_track_yLocal);
394  m_outputTree->Branch("proton_track_zLocal", "vector<vector<float>>", &proton_track_zLocal);
395  m_outputTree->Branch("proton_track_xSlope", "vector<vector<float>>", &proton_track_xSlope);
396  m_outputTree->Branch("proton_track_ySlope", "vector<vector<float>>", &proton_track_ySlope);
397  }
398 
399  }
400  }
401 
402  ANA_MSG_DEBUG("Anti-howdy from Initialize!");
403 
404 
405  // Here you do everything that you need to do after the first input
406  // file has been connected and before the first event is processed,
407  // e.g. create additional histograms based on which variables are
408  // available in the input files. You can also create all of your
409  // histograms and trees in here, but be aware that this method
410  // doesn't get called if no events are processed. So any objects
411  // you create here won't be available in the output if you have no
412  // input events.
413 
414  ANA_MSG_INFO("enableOutputTree = " << enableOutputTree);
415  ANA_MSG_INFO("writeOnlyTriggers = " << writeOnlyTriggers);
416  ANA_MSG_INFO("enableOutputSamples = " << enableOutputSamples);
417  ANA_MSG_INFO("enableTrigger = " << enableTrigger);
418  ANA_MSG_INFO("enableRPD = " << enableRPD);
419  ANA_MSG_INFO("enableCentroid = " << enableCentroid);
420  ANA_MSG_INFO("zdcCalib = " << zdcCalib);
421  ANA_MSG_INFO("zdcInj = " << zdcInj);
422  ANA_MSG_INFO("zdcLaser = " << zdcLaser);
423  ANA_MSG_INFO("zdcConfig = " << zdcConfig);
424  ANA_MSG_INFO("reprocZdc = " << reprocZdc);
425  ANA_MSG_INFO("auxSuffix = " << auxSuffix );
426  ANA_MSG_INFO("zdcLowGainMode = " << zdcLowGainMode);
427  ANA_MSG_INFO("enableID = " << enableID);
428  ANA_MSG_INFO("enableCalo = " << enableCalo);
429  ANA_MSG_INFO("enableClusters = " << enableClusters);
430  ANA_MSG_INFO("trackLimit = " << trackLimit);
431  ANA_MSG_INFO("trackLimitReject = " << trackLimitReject);
432  ANA_MSG_INFO("isMC = " << m_isMC);
433  ANA_MSG_INFO("useGRL = " << useGRL);
434  ANA_MSG_INFO("grlFilename = " << grlFilename);
435  ANA_MSG_INFO("slimmed = " << slimmed);
436  ANA_MSG_INFO("zdcOnly = " << zdcOnly);
437  ANA_MSG_INFO("flipDelay = " << flipDelay);
438  ANA_MSG_INFO("nsamplesZdc = " << nsamplesZdc);
439  ANA_MSG_INFO("lhcf2022 = " << lhcf2022);
440  ANA_MSG_INFO("lhcf2022afp = " << lhcf2022afp);
441  ANA_MSG_INFO("lhcf2022zdc = " << lhcf2022zdc);
442  ANA_MSG_INFO("doZdcCalib = " << doZdcCalib);
443 
444  ANA_MSG_DEBUG("initialize: Initialize!");
445 
446 
447  // GRL
448 
449  if (useGRL)
450  {
451  const char* fullGRLFilePath = gSystem->ExpandPathName (grlFilename.c_str());
452  ANA_MSG_INFO("GRL: " << fullGRLFilePath);
453  std::vector<std::string> vecStringGRL;
454  vecStringGRL.push_back(fullGRLFilePath);
455  ANA_CHECK(m_grl.setProperty( "GoodRunsListVec", vecStringGRL));
456  ANA_CHECK(m_grl.setProperty("PassThrough", false)); // if true (default) will ignore result of GRL and will just pass all events
457  ANA_CHECK(m_grl.initialize());
458 
459  }
460 
461  if (enableTracks)
462  {
463  ANA_CHECK(m_selTool.retrieve());
464  }
465 
466  if (enableTrigger) // HLT related
467  {
468  ANA_MSG_INFO("Trying to initialize TDT");
469  ANA_CHECK(m_trigDecisionTool.retrieve());
470  }
471 
472  // ZDC re-reco tool
473  if (reprocZdc)
474  {
475  m_zdcAnalysisTool.setTypeAndName("ZDC::ZdcAnalysisTool/ZdcAnalysisTool");
476 
477  ANA_MSG_INFO("Trying to configure ZDC Analysis Tool!");
478 
479  ANA_CHECK(m_zdcAnalysisTool.setProperty("FlipEMDelay", flipDelay));
480  ANA_CHECK(m_zdcAnalysisTool.setProperty("LowGainMode", zdcLowGainMode));
481  ANA_CHECK(m_zdcAnalysisTool.setProperty("DoCalib", doZdcCalib));
482  ANA_CHECK(m_zdcAnalysisTool.setProperty("Configuration", zdcConfig));
483  ANA_CHECK(m_zdcAnalysisTool.setProperty("AuxSuffix", auxSuffix));
484  ANA_CHECK(m_zdcAnalysisTool.setProperty("ForceCalibRun", -1));
485 
486  ANA_MSG_INFO("Setting up zdcConfig=" << zdcConfig);
487  if (zdcConfig=="LHCf2022")
488  {
489  ANA_CHECK(m_zdcAnalysisTool.setProperty("DoTrigEff", false)); // for now
490  ANA_CHECK(m_zdcAnalysisTool.setProperty("DoTimeCalib", false)); // for now
491  ANA_CHECK(m_zdcAnalysisTool.setProperty("Configuration", "LHCf2022"));
492  }
493  else if (zdcConfig == "PbPb2018")
494  {
495  ANA_CHECK(m_zdcAnalysisTool.setProperty("Configuration", "PbPb2018"));
496  }
497  else if (zdcConfig == "pPb2016")
498  {
499  ANA_CHECK(m_zdcAnalysisTool.setProperty("Configuration", "pPb2016"));
500  }
501  else if (zdcConfig == "PbPb2015")
502  {
503  ANA_CHECK(m_zdcAnalysisTool.setProperty("Configuration", "PbPb2015"));
504  }
505 
506  if (flipDelay)
507  ANA_MSG_INFO("FLIP ZDC DELAY IN EM MODULES");
508  else
509  ANA_MSG_INFO("NO FLIP ZDC DELAY IN EM MODULES");
510 
511 
512  ANA_MSG_INFO("Trying to initialize ZDC Analysis Tool!");
513  ANA_CHECK(m_zdcAnalysisTool.initialize());
514  }
515 
516  if (zdcInj)
517  {
518  m_zdcInjPulserAmpMap = std::make_shared<ZdcInjPulserAmpMap>();
519  ATH_MSG_INFO( "Using JSON file for injector-pulse voltage at path " << m_zdcInjPulserAmpMap->getFilePath() );
520  }
521 
522  return StatusCode::SUCCESS;
523 }
524 
525 
526 
527 StatusCode ZdcNtuple :: execute ()
528 {
529  // Here you do everything that needs to be done on every single
530  // events, e.g. read input variables, apply cuts, and fill
531  // histograms and trees. This is where most of your actual analysis
532  // code will go.
533 
534 
535  // prefilter with a track limit
536 
537  if (!evtStore())
538  {
539  ANA_MSG_INFO("*** No event found! ***");
540  return StatusCode::SUCCESS;
541  }
542 
543  ANA_CHECK(evtStore()->retrieve( m_eventInfo, "EventInfo"));
544  processEventInfo();
545  if (zdcInj){
546  processVInjInfo();
547  }
548 
549  //tracks used to go here
550 
551  m_trackParticles = 0;
552 
553  if ((!(zdcCalib || zdcLaser || zdcOnly || zdcInj)) && enableID)
554  {
555  ANA_MSG_DEBUG("Trying to extract InDetTrackParticles from evtStore()=" << evtStore());
556  ANA_CHECK(evtStore()->retrieve( m_trackParticles, "InDetTrackParticles") );
557  size_t n = m_trackParticles->size();
558  ANA_MSG_DEBUG("Done w/ extracting InDetTrackParticles with size = " << n);
559 
560  if (n > trackLimit && trackLimitReject) return StatusCode::SUCCESS;
561  }
562 
563  bool passTrigger = true;
564  m_trigDecision = 0;
565  if (enableTrigger)
566  {
567  ANA_CHECK(evtStore()->retrieve( m_trigDecision, "xTrigDecision"));
568  if (!m_setupTrigHist) setupTriggerHistos();
569  passTrigger = processTriggerDecision();
570  }
571 
572  if (reprocZdc){
573  ANA_MSG_INFO ("Reprocessing ZDC in ZdcNtuple");
574  ANA_CHECK(m_zdcAnalysisTool->reprocessZdc());
575  }else{
576  ANA_MSG_DEBUG ("No ZDC reprocessing");
577  }
578 
579  processZdcNtupleFromModules(); // same model in both cases -- processZdcNtuple() goes straight to the anlaysis tool, which is good for debugging
580 
581  if(m_isMC){
582  processMCEventCollection();
583  }
584 
585  if (!(zdcCalib || zdcLaser || zdcOnly || zdcInj))
586  {
587 
588  // PLEASE NOTE: the commented sections here will be restored once we have a better sense of the Run 3 HI data
589 
590  // Global E_T quantities for centrality
591  if (enableCalo){
592  ANA_CHECK(evtStore()->retrieve( m_caloSums, "CaloSums") );
593  ANA_CHECK(evtStore()->retrieve( m_eventShapes, "HIEventShape") );
594 
595  m_lvl1EnergySumRoI = 0;
596  ANA_CHECK(evtStore()->retrieve( m_lvl1EnergySumRoI, "LVL1EnergySumRoI") );
597 
598  processFCal();
599  }
600 
601  // MBTS quantities, but may require a derivation to be accessible (required STDM6 in pp)
602  //ANA_CHECK(evtStore()->retrieve( m_mbtsInfo, "MBTSForwardEventInfo") );
603  //ANA_CHECK(evtStore()->retrieve( m_mbtsModules, "MBTSModules") );
604  //m_trigT2MbtsBits = 0;
605  //ANA_CHECK(evtStore()->retrieve( m_trigT2MbtsBits, "HLT_xAOD__TrigT2MbtsBitsContainer_T2Mbts") );
606  //processMBTS();
607 
608  if (enableID){
609  ANA_CHECK(evtStore()->retrieve( m_primaryVertices, "PrimaryVertices") );
610  processInDet();
611  }
612 
613 
614  if (enableClusters){
615  ANA_CHECK(evtStore()->retrieve( m_caloClusters, "CaloCalTopoClusters"));
616  processClusters();
617  }
618 
619  // Gaps will require some evaluation of Run 3 performance of the clusters
620  //processGaps();
621 
622  if( lhcf2022||lhcf2022zdc||lhcf2022afp ){
623  ANA_CHECK(evtStore()->retrieve( m_afpProtons, "AFPProtonContainer"));
624  processProtons();
625  }
626  }
627 
628  // if trigger enabled, only write out events which pass one of them, unless using MC
629 
630  if (enableTrigger && !passTrigger && !m_isMC && writeOnlyTriggers) return StatusCode::SUCCESS;
631 
632 
633  if (enableOutputTree)
634  {
635  tree( "zdcTree" )->Fill();
636  }
637 
638  return StatusCode::SUCCESS;
639 }
640 
641 void ZdcNtuple::processZdcNtupleFromModules()
642 {
643 
644  SG::ReadHandle<xAOD::ZdcModuleContainer> zdcModules (m_zdcModuleContainerName);
645  SG::ReadHandle<xAOD::ZdcModuleContainer> zdcSums (m_zdcSumContainerName);
646 
647  ANA_MSG_DEBUG ("copying already processed info!");
648 
649  //Reset the truth separately since it has a different range
650  for(int iside : {0,1}){
651  for(int imod = 0; imod < 7; ++imod){
652  t_ZdcModuleTruthTotal[iside][imod] = 0;
653  t_ZdcModuleTruthInvis[iside][imod] = 0;
654  t_ZdcModuleTruthEM[iside][imod] = 0;
655  t_ZdcModuleTruthNonEM[iside][imod] = 0;
656  t_ZdcModuleTruthEscaped[iside][imod] = 0;
657  t_ZdcModuleTruthNphotons[iside][imod] = 0;
658  }
659  for(int ch = 0; ch < 16; ++ch){
660  t_RpdModuleTruthNphotons[iside][ch] = 0;
661  }
662  }
663 
664  for (size_t iside = 0; iside < 2; iside++)
665  {
666  t_ZdcAmp[iside] = 0; t_ZdcEnergy[iside] = 0; t_ZdcEnergyErr[iside] = 0;t_ZdcTime[iside] = 0; t_ZdcStatus[iside] = 0;
667  t_ZdcNLEnergy[iside] = 0;t_ZdcNLEnergyErr[iside] = 0;
668  t_ZdcTrigEff[iside] = 0;t_ZdcLucrodTriggerSideAmp[iside] = 0; t_ZdcLucrodTriggerSideAmpLG[iside] = 0; t_ZdcTruthTotal[iside] = 0;
669  t_ZdcTruthInvis[iside] = 0; t_ZdcTruthEM[iside] = 0; t_ZdcTruthNonEM[iside] = 0;
670  t_ZdcTruthEscaped[iside] = 0;
671  for (int imod = 0; imod < 4; imod++)
672  {
673  t_ZdcModuleAmp[iside][imod] = 0; t_ZdcModuleTime[iside][imod] = 0; t_ZdcModuleStatus[iside][imod] = 0;
674 
675  t_ZdcModuleCalibAmp[iside][imod] = 0; t_ZdcModuleCalibTime[iside][imod] = 0; t_ZdcModuleChisq[iside][imod] = 0; t_ZdcModuleFitAmp[iside][imod] = 0;
676  t_ZdcModuleFitT0[iside][imod] = 0; t_ZdcModuleBkgdMaxFraction[iside][imod] = 0; t_ZdcModuleAmpError[iside][imod] = 0;
677  t_ZdcModuleMinDeriv2nd[iside][imod] = 0; t_ZdcModulePresample[iside][imod] = 0; t_ZdcModulePreSampleAmp[iside][imod] = 0;
678  t_ZdcLucrodTriggerAmp[iside][imod] = 0;t_ZdcLucrodTriggerAmpLG[iside][imod] = 0;
679  t_ZdcModuleMaxADC[iside][imod] = 0; t_ZdcModuleMaxADCHG[iside][imod] = 0; t_ZdcModuleMaxADCLG[iside][imod] = 0;
680  t_ZdcModulePeakADCHG[iside][imod] = 0; t_ZdcModulePeakADCLG[iside][imod] = 0;
681  t_ZdcModuleAmpLGRefit[iside][imod] = 0; t_ZdcModuleAmpCorrLGRefit[iside][imod] = 0;
682  t_ZdcModuleT0LGRefit[iside][imod] = 0; t_ZdcModuleT0SubLGRefit[iside][imod] = 0; t_ZdcModuleChisqLGRefit[iside][imod] = 0;
683 
684  if (enableOutputSamples)
685  {
686  for (int ig=0;ig<2;ig++)
687  {
688  for (int id=0;id<2;id++)
689  {
690  for (unsigned int isamp=0;isamp<nsamplesZdc;isamp++)
691  {
692  if (nsamplesZdc==7) t_raw7[iside][imod][ig][id][isamp]=0;
693  if (nsamplesZdc==15) t_raw15[iside][imod][ig][id][isamp]=0;
694  if (nsamplesZdc==24) t_raw24[iside][imod][ig][id][isamp]=0;
695  }
696  }
697  }
698  if (nsamplesZdc==24)
699  {
700  for (int ch=0;ch<16;ch++)
701  {
702  for (unsigned int isamp=0;isamp<nsamplesZdc;isamp++)
703  {
704  t_rpdRaw[iside][ch][isamp]=0;
705  }
706  }
707  }
708  }
709  if (enableRPD)
710  {
711  for (int ch = 0; ch < 16; ch++) {
712  t_RpdChannelBaseline[iside][ch] = 0;
713  std::fill(t_RpdChannelPileupExpFitParams[iside][ch], t_RpdChannelPileupExpFitParams[iside][ch] + 2, 0);
714  std::fill(t_RpdChannelPileupStretchedExpFitParams[iside][ch], t_RpdChannelPileupStretchedExpFitParams[iside][ch] + 3, 0);
715  std::fill(t_RpdChannelPileupExpFitParamErrs[iside][ch], t_RpdChannelPileupExpFitParamErrs[iside][ch] + 2, 0);
716  std::fill(t_RpdChannelPileupStretchedExpFitParamErrs[iside][ch], t_RpdChannelPileupStretchedExpFitParamErrs[iside][ch] + 3, 0);
717  t_RpdChannelPileupExpFitMSE[iside][ch] = 0;
718  t_RpdChannelPileupStretchedExpFitMSE[iside][ch] = 0;
719  t_RpdChannelAmplitude[iside][ch] = 0;
720  t_RpdChannelAmplitudeCalib[iside][ch] = 0;
721  t_RpdChannelMaxADC[iside][ch] = 0;
722  t_RpdChannelMaxADCCalib[iside][ch] = 0;
723  t_RpdChannelMaxSample[iside][ch] = 0;
724  t_RpdChannelStatus[iside][ch] = 0;
725  t_RpdChannelPileupFrac[iside][ch] = 0;
726  }
727  t_RpdSideStatus[iside] = 0;
728  }
729  if (enableCentroid)
730  {
731  t_centroidStatus[iside] = 0;
732  std::fill(t_RPDChannelSubtrAmp[iside], t_RPDChannelSubtrAmp[iside] + 16, 0);
733  t_RPDSubtrAmpSum[iside] = 0;
734  t_xCentroidPreGeomCorPreAvgSubtr[iside] = 0;
735  t_yCentroidPreGeomCorPreAvgSubtr[iside] = 0;
736  t_xCentroidPreAvgSubtr[iside] = 0;
737  t_yCentroidPreAvgSubtr[iside] = 0;
738  t_xCentroid[iside] = 0;
739  t_yCentroid[iside] = 0;
740  std::fill(t_xRowCentroid[iside], t_xRowCentroid[iside] + 4, 0);
741  std::fill(t_yColCentroid[iside], t_yColCentroid[iside] + 4, 0);
742  t_reactionPlaneAngle[iside] = 0;
743  }
744  }
745  }
746 
747  t_ZdcModuleMask = 0;
748  if (enableCentroid) {
749  t_centroidDecorationsAvailable = false;
750  t_centroidEventValid = false;
751  t_cosDeltaReactionPlaneAngle = 0;
752  }
753 
754  /*
755  if (t_zdcEventInfoError == xAOD::EventInfo::Error)
756  {
757  ANA_MSG_INFO("ZDC event failed EventInfo error check - aborting!");
758  return;
759  }
760  */
761 
762  static const SG::ConstAccessor<char> centroidEventValidAcc("centroidEventValid" + auxSuffix);
763  static const SG::ConstAccessor<float> cosDeltaReactionPlaneAngleAcc("cosDeltaReactionPlaneAngle" + auxSuffix);
764  static const SG::ConstAccessor<float> CalibEnergyAcc("CalibEnergy"+auxSuffix);
765  static const SG::ConstAccessor<float> CalibEnergyErrAcc("CalibEnergyErr"+auxSuffix);
766  static const SG::ConstAccessor<float> NLCalibEnergyAcc("NLCalibEnergy"+auxSuffix);
767  static const SG::ConstAccessor<float> NLCalibEnergyErrAcc("NLCalibEnergyErr"+auxSuffix);
768  static const SG::ConstAccessor<float> UncalibSumAcc("UncalibSum"+auxSuffix);
769  static const SG::ConstAccessor<float> UncalibSumErrAcc("UncalibSumErr"+auxSuffix);
770  static const SG::ConstAccessor<float> AverageTimeAcc("AverageTime"+auxSuffix);
771  static const SG::ConstAccessor<unsigned int> StatusAcc("Status"+auxSuffix);
772  static const SG::ConstAccessor<unsigned int> ModuleMaskAcc("ModuleMask"+auxSuffix);
773  static const SG::ConstAccessor<float> TruthTotalEnergyAcc("TruthTotalEnergy" + auxSuffix);
774  static const SG::ConstAccessor<float> TruthInvisibleEnergyAcc("TruthInvisibleEnergy" + auxSuffix);
775  static const SG::ConstAccessor<float> TruthEMEnergyAcc("TruthEMEnergy" + auxSuffix);
776  static const SG::ConstAccessor<float> TruthNonEMEnergyAcc("TruthNonEMEnergy" + auxSuffix);
777  static const SG::ConstAccessor<float> TruthEscapedEnergyAcc("TruthEscapedEnergy" + auxSuffix);
778  static const SG::ConstAccessor<unsigned int> centroidStatusAcc("centroidStatus" + auxSuffix);
779  static const SG::ConstAccessor<std::vector<float> > RPDChannelSubtrAmpAcc("RPDChannelSubtrAmp" + auxSuffix);
780  static const SG::ConstAccessor<float> RPDSubtrAmpSumAcc("RPDSubtrAmpSum" + auxSuffix);
781  static const SG::ConstAccessor<float> xCentroidPreGeomCorPreAvgSubtrAcc("xCentroidPreGeomCorPreAvgSubtr" + auxSuffix);
782  static const SG::ConstAccessor<float> yCentroidPreGeomCorPreAvgSubtrAcc("yCentroidPreGeomCorPreAvgSubtr" + auxSuffix);
783  static const SG::ConstAccessor<float> xCentroidPreAvgSubtrAcc("xCentroidPreAvgSubtr" + auxSuffix);
784  static const SG::ConstAccessor<float> yCentroidPreAvgSubtrAcc("yCentroidPreAvgSubtr" + auxSuffix);
785  static const SG::ConstAccessor<float> xCentroidAcc("xCentroid" + auxSuffix);
786  static const SG::ConstAccessor<float> yCentroidAcc("yCentroid" + auxSuffix);
787  static const SG::ConstAccessor<std::vector<float> > xRowCentroidAcc("xRowCentroid" + auxSuffix);
788  static const SG::ConstAccessor<std::vector<float> > yColCentroidAcc("yColCentroid" + auxSuffix);
789  static const SG::ConstAccessor<float> reactionPlaneAngleAcc("reactionPlaneAngle" + auxSuffix);
790  static const SG::ConstAccessor<unsigned int> RPDStatusAcc("RPDStatus" + auxSuffix);
791  static const SG::ConstAccessor<unsigned int> nPhotonsAcc("nPhotons" + auxSuffix);
792  static const SG::ConstAccessor<float> CalibTimeAcc("CalibTime" + auxSuffix);
793  static const SG::ConstAccessor<float> AmplitudeAcc("Amplitude" + auxSuffix);
794  static const SG::ConstAccessor<float> TimeAcc("Time" + auxSuffix);
795  static const SG::ConstAccessor<float> ChisqAcc("Chisq" + auxSuffix);
796  static const SG::ConstAccessor<float> FitAmpAcc("FitAmp" + auxSuffix);
797  static const SG::ConstAccessor<float> FitAmpErrorAcc("FitAmpError" + auxSuffix);
798  static const SG::ConstAccessor<float> FitT0Acc("FitT0" + auxSuffix);
799  static const SG::ConstAccessor<float> BkgdMaxFractionAcc("BkgdMaxFraction" + auxSuffix);
800  static const SG::ConstAccessor<float> MinDeriv2ndAcc("MinDeriv2nd" + auxSuffix);
801  static const SG::ConstAccessor<float> PresampleAcc("Presample" + auxSuffix);
802  static const SG::ConstAccessor<float> PreSampleAmpAcc("PreSampleAmp" + auxSuffix);
803  static const SG::ConstAccessor<float> RPDChannelBaselineAcc("RPDChannelBaseline" + auxSuffix);
804  static const SG::ConstAccessor<std::vector<float> > RPDChannelPileupExpFitParamsAcc("RPDChannelPileupExpFitParams" + auxSuffix);
805  static const SG::ConstAccessor<std::vector<float> > RPDChannelPileupExpFitParamErrsAcc("RPDChannelPileupExpFitParamErrs" + auxSuffix);
806  static const SG::ConstAccessor<std::vector<float> > RPDChannelPileupStretchedExpFitParamsAcc("RPDChannelPileupStretchedExpFitParams" + auxSuffix);
807  static const SG::ConstAccessor<std::vector<float> > RPDChannelPileupStretchedExpFitParamErrsAcc("RPDChannelPileupStretchedExpFitParamErrs" + auxSuffix);
808  static const SG::ConstAccessor<float> RPDChannelPileupExpFitMSEAcc("RPDChannelPileupExpFitMSE" + auxSuffix);
809  static const SG::ConstAccessor<float> RPDChannelPileupStretchedExpFitMSEAcc("RPDChannelPileupStretchedExpFitMSE" + auxSuffix);
810  static const SG::ConstAccessor<float> RPDChannelAmplitudeAcc("RPDChannelAmplitude" + auxSuffix);
811  static const SG::ConstAccessor<float> RPDChannelAmplitudeCalibAcc("RPDChannelAmplitudeCalib" + auxSuffix);
812  static const SG::ConstAccessor<float> RPDChannelMaxADCAcc("RPDChannelMaxADC" + auxSuffix);
813  static const SG::ConstAccessor<float> RPDChannelMaxADCCalibAcc("RPDChannelMaxADCCalib" + auxSuffix);
814  static const SG::ConstAccessor<unsigned int> RPDChannelMaxSampleAcc("RPDChannelMaxSample" + auxSuffix);
815  static const SG::ConstAccessor<unsigned int> RPDChannelStatusAcc("RPDChannelStatus" + auxSuffix);
816  static const SG::ConstAccessor<float> RPDChannelPileupFracAcc("RPDChannelPileupFrac" + auxSuffix);
817  static const SG::ConstAccessor<float> AmpLGRefitAcc("AmpLGRefit" + auxSuffix);
818  static const SG::ConstAccessor<float> T0LGRefitAcc("T0LGRefit" + auxSuffix);
819  static const SG::ConstAccessor<float> T0SubLGRefitAcc("T0SubLGRefit" + auxSuffix);
820  static const SG::ConstAccessor<float> ChisqLGRefitAcc("ChisqLGRefit" + auxSuffix);
821 
822  static const SG::ConstAccessor<uint16_t> LucrodTriggerAmpAcc("LucrodTriggerAmp");
823  static const SG::ConstAccessor<uint16_t> LucrodTriggerAmpLGAcc("LucrodTriggerAmpLG");
824  static const SG::ConstAccessor<uint16_t> LucrodTriggerSideAmpAcc("LucrodTriggerSideAmp");
825  static const SG::ConstAccessor<uint16_t> LucrodTriggerSideAmpLGAcc("LucrodTriggerSideAmpLG");
826  static const SG::ConstAccessor<float> Amplitude0Acc("Amplitude");
827  static const SG::ConstAccessor<float> MaxADCAcc("MaxADC");
828  static const SG::ConstAccessor<float> MaxADCHGAcc("MaxADCHG");
829  static const SG::ConstAccessor<float> MaxADCLGAcc("MaxADCLG");
830  static const SG::ConstAccessor<float> PeakADCHGAcc("PeakADCHG");
831  static const SG::ConstAccessor<float> PeakADCLGAcc("PeakADCLG");
832  static const SG::ConstAccessor<std::vector<uint16_t> > g0d0DataAcc("g0d0Data");
833  static const SG::ConstAccessor<std::vector<uint16_t> > g0d1DataAcc("g0d1Data");
834  static const SG::ConstAccessor<std::vector<uint16_t> > g1d0DataAcc("g1d0Data");
835  static const SG::ConstAccessor<std::vector<uint16_t> > g1d1DataAcc("g1d1Data");
836  static const SG::ConstAccessor<std::vector<uint16_t> > g0dataAcc("g0data");
837  static const SG::ConstAccessor<std::vector<uint16_t> > g1dataAcc("g1data");
838 
839  bool rpdErr = m_eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::RPDDECODINGERROR );
840  bool zdcErr = m_eventInfo->isEventFlagBitSet(xAOD::EventInfo::ForwardDet, ZdcEventInfo::ZDCDECODINGERROR );
841  t_rpdDecodingError = rpdErr;
842  t_zdcDecodingError = zdcErr;
843  if (enableCentroid) {
844  // locate global sum (only if centroid is needed)
845  xAOD::ZdcModule const * globalSum = nullptr;
846  for (auto const * zdcSum : *zdcSums) {
847  if (zdcSum->zdcSide() == 0) {
848  globalSum = zdcSum;
849  break;
850  }
851  }
852  if (!globalSum) {
853  ANA_MSG_ERROR("unable to locate global ZdcSum (side = 0)");
854  t_centroidDecorationsAvailable = false;
855  }
856  else {
857  t_centroidDecorationsAvailable = centroidStatusAcc.isAvailable(*globalSum);
858  }
859  }
860 
861  if (rpdErr||zdcErr) ANA_MSG_WARNING( "Decoding errors ZDC=" << zdcErr << " RPD=" << rpdErr );
862 
863  if (zdcSums.ptr())
864  {
865  ANA_MSG_DEBUG( "accessing ZdcSums" );
866  for (const auto zdcSum : *zdcSums)
867  {
868  if (zdcSum->zdcSide()==0 && enableCentroid && t_centroidDecorationsAvailable)
869  {
870  // new global sum
871  t_centroidEventValid = centroidEventValidAcc(*zdcSum);
872  t_cosDeltaReactionPlaneAngle = cosDeltaReactionPlaneAngleAcc(*zdcSum);
873  continue;
874  }
875  int iside = 0;
876  if (zdcSum->zdcSide() > 0) iside = 1;
877 
878  //static SG::AuxElement::ConstAccessor< float > acc( "CalibEnergy" );
879  //t_ZdcEnergy[iside] = acc(*zdcSum);
880 
881  if (enableZDC && !zdcErr)
882  {
883  t_ZdcEnergy[iside] = CalibEnergyAcc(*zdcSum);
884  t_ZdcEnergyErr[iside] = CalibEnergyErrAcc(*zdcSum);
885  t_ZdcNLEnergy[iside] = NLCalibEnergyAcc(*zdcSum);
886  t_ZdcNLEnergyErr[iside] = NLCalibEnergyErrAcc(*zdcSum);
887 
888  t_ZdcAmp[iside] = UncalibSumAcc(*zdcSum);
889  t_ZdcAmpErr[iside] = UncalibSumErrAcc(*zdcSum);
890  if (LucrodTriggerSideAmpAcc.isAvailable(*zdcSum))
891  t_ZdcLucrodTriggerSideAmp[iside] = LucrodTriggerSideAmpAcc(*zdcSum);
892  if (LucrodTriggerSideAmpLGAcc.isAvailable(*zdcSum))
893  t_ZdcLucrodTriggerSideAmpLG[iside] = LucrodTriggerSideAmpLGAcc(*zdcSum);
894 
895  ANA_MSG_VERBOSE("processZdcNtupleFromModules: ZdcSum energy = " << t_ZdcEnergy[iside]);
896 
897  t_ZdcTime[iside] = AverageTimeAcc(*zdcSum);
898  t_ZdcStatus[iside] = StatusAcc(*zdcSum);
899  t_ZdcModuleMask += ( ModuleMaskAcc(*zdcSum) << 4 * iside);
900 
901  if(m_isMC){
902  ANA_MSG_DEBUG("Filling sum truth");
903  t_ZdcTruthTotal [iside] = TruthTotalEnergyAcc(*zdcSum);
904  t_ZdcTruthInvis [iside] = TruthInvisibleEnergyAcc(*zdcSum);
905  t_ZdcTruthEM [iside] = TruthEMEnergyAcc(*zdcSum);
906  t_ZdcTruthNonEM [iside] = TruthNonEMEnergyAcc(*zdcSum);
907  t_ZdcTruthEscaped[iside] = TruthEscapedEnergyAcc(*zdcSum);
908  }
909 
910  }
911 
912  if (enableRPD)
913  {
914  if (enableRPDAmp && !rpdErr)
915  {
916  t_RpdSideStatus[iside] = RPDStatusAcc(*zdcSum);
917  }
918  if (enableCentroid && t_centroidDecorationsAvailable)
919  {
920  t_centroidStatus[iside] = centroidStatusAcc(*zdcSum);
921  std::vector<float> const& rpdChannelSubtrAmp = RPDChannelSubtrAmpAcc(*zdcSum);
922  std::copy(rpdChannelSubtrAmp.begin(), rpdChannelSubtrAmp.end(), t_RPDChannelSubtrAmp[iside]);
923  t_RPDSubtrAmpSum[iside] = RPDSubtrAmpSumAcc(*zdcSum);
924  t_xCentroidPreGeomCorPreAvgSubtr[iside] = xCentroidPreGeomCorPreAvgSubtrAcc(*zdcSum);
925  t_yCentroidPreGeomCorPreAvgSubtr[iside] = yCentroidPreGeomCorPreAvgSubtrAcc(*zdcSum);
926  t_xCentroidPreAvgSubtr[iside] = xCentroidPreAvgSubtrAcc(*zdcSum);
927  t_yCentroidPreAvgSubtr[iside] = yCentroidPreAvgSubtrAcc(*zdcSum);
928  t_xCentroid[iside] = xCentroidAcc(*zdcSum);
929  t_yCentroid[iside] = yCentroidAcc(*zdcSum);
930  std::vector<float> const& xRowCentroid = xRowCentroidAcc(*zdcSum);
931  std::copy(xRowCentroid.begin(), xRowCentroid.end(), t_xRowCentroid[iside]);
932  std::vector<float> const& yColCentroid = yColCentroidAcc(*zdcSum);
933  std::copy(yColCentroid.begin(), yColCentroid.end(), t_yColCentroid[iside]);
934  t_reactionPlaneAngle[iside] = reactionPlaneAngleAcc(*zdcSum);
935  }
936  }
937  }
938  }
939 
940  ANA_MSG_DEBUG( "accessing ZdcModules" );
941 
942  if (zdcModules.ptr())
943  {
944  for (const auto zdcMod : *zdcModules)
945  {
946  int iside = 0;
947  if (zdcMod->zdcSide() > 0) iside = 1;
948  int imod = zdcMod->zdcModule();
949 
950  if (m_isMC){
951  //Calib hits are only stored in channel 0 of the RPD
952  if(!(imod == 4 && zdcMod->zdcChannel() != 0)){
953  t_ZdcModuleTruthTotal [iside][imod] = TruthTotalEnergyAcc(*zdcMod);
954  t_ZdcModuleTruthInvis [iside][imod] = TruthInvisibleEnergyAcc(*zdcMod);
955  t_ZdcModuleTruthEM [iside][imod] = TruthEMEnergyAcc(*zdcMod);
956  t_ZdcModuleTruthNonEM [iside][imod] = TruthNonEMEnergyAcc(*zdcMod);
957  t_ZdcModuleTruthEscaped[iside][imod] = TruthEscapedEnergyAcc(*zdcMod);
958  t_ZdcModuleTruthNphotons[iside][imod] = nPhotonsAcc(*zdcMod);
959  }
960  //Calib hits are stored for all modules
961  //Other data is only valid for module 1-4
962  if(imod > 4) continue;
963  }
964 
965  ANA_MSG_VERBOSE ("Module " << zdcMod->zdcSide() << " " << zdcMod->zdcModule() << " amp:" << AmplitudeAcc(*zdcMod));
966 
967  if (zdcMod->zdcType() == 0 && !zdcErr)
968  {
969  // ZDC energy type modules
970  t_ZdcModuleCalibAmp[iside][imod] = CalibEnergyAcc(*zdcMod);
971  t_ZdcModuleCalibTime[iside][imod] = CalibTimeAcc(*zdcMod);
972  t_ZdcModuleStatus[iside][imod] = StatusAcc(*zdcMod);
973  if (t_ZdcModuleAmp[iside][imod] != 0.)
974  Warning("processZdcNtupleFromModules", "overwriting side %d module %d!", iside, imod);
975  t_ZdcModuleAmp[iside][imod] = AmplitudeAcc(*zdcMod);
976  t_ZdcModuleTime[iside][imod] = TimeAcc(*zdcMod);
977 
978  t_ZdcModuleChisq[iside][imod] = ChisqAcc(*zdcMod);
979  t_ZdcModuleFitAmp[iside][imod] = FitAmpAcc(*zdcMod);
980  t_ZdcModuleAmpError[iside][imod] = FitAmpErrorAcc(*zdcMod);
981  t_ZdcModuleFitT0[iside][imod] = FitT0Acc(*zdcMod);
982  t_ZdcModuleBkgdMaxFraction[iside][imod] = BkgdMaxFractionAcc(*zdcMod);
983  t_ZdcModuleMinDeriv2nd[iside][imod] = MinDeriv2ndAcc(*zdcMod);
984  t_ZdcModulePresample[iside][imod] = PresampleAcc(*zdcMod);
985  t_ZdcModulePreSampleAmp[iside][imod] = PreSampleAmpAcc(*zdcMod);
986 
987  if (AmpLGRefitAcc.isAvailable(*zdcMod)) {
988  t_ZdcModuleAmpLGRefit[iside][imod] = AmpLGRefitAcc(*zdcMod);
989  t_ZdcModuleT0LGRefit[iside][imod] = T0LGRefitAcc(*zdcMod);
990  t_ZdcModuleT0SubLGRefit[iside][imod] = T0SubLGRefitAcc(*zdcMod);
991  t_ZdcModuleChisqLGRefit[iside][imod] = ChisqLGRefitAcc(*zdcMod);
992  }
993 
994  if (LucrodTriggerAmpAcc.isAvailable(*zdcMod))
995  t_ZdcLucrodTriggerAmp[iside][imod] = LucrodTriggerAmpAcc(*zdcMod);
996  if (LucrodTriggerAmpLGAcc.isAvailable(*zdcMod))
997  t_ZdcLucrodTriggerAmpLG[iside][imod] = LucrodTriggerAmpLGAcc(*zdcMod);
998 
999  if (MaxADCAcc.isAvailable(*zdcMod))
1000  t_ZdcModuleMaxADC[iside][imod] = MaxADCAcc(*zdcMod);
1001  if (MaxADCHGAcc.isAvailable(*zdcMod))
1002  t_ZdcModuleMaxADCHG[iside][imod] = MaxADCHGAcc(*zdcMod);
1003  if (MaxADCLGAcc.isAvailable(*zdcMod))
1004  t_ZdcModuleMaxADCLG[iside][imod] = MaxADCLGAcc(*zdcMod);
1005  if (PeakADCHGAcc.isAvailable(*zdcMod))
1006  t_ZdcModulePeakADCHG[iside][imod] = PeakADCHGAcc(*zdcMod);
1007  if (PeakADCLGAcc.isAvailable(*zdcMod))
1008  t_ZdcModulePeakADCLG[iside][imod] = PeakADCLGAcc(*zdcMod);
1009 
1010  if (enableOutputSamples && !zdcErr)
1011  {
1012  for (unsigned int isamp = 0; isamp < nsamplesZdc; isamp++) // 7 samples
1013  {
1014  if (nsamplesZdc == 7)
1015  {
1016  t_raw7[iside][imod][0][0][isamp] = g0d0DataAcc(*zdcMod).at(isamp);
1017  t_raw7[iside][imod][0][1][isamp] = g0d1DataAcc(*zdcMod).at(isamp);
1018  t_raw7[iside][imod][1][0][isamp] = g1d0DataAcc(*zdcMod).at(isamp);
1019  t_raw7[iside][imod][1][1][isamp] = g1d1DataAcc(*zdcMod).at(isamp);
1020  }
1021 
1022  if (nsamplesZdc == 15)
1023  {
1024  t_raw15[iside][imod][0][0][isamp] = g0d0DataAcc(*zdcMod).at(isamp);
1025  t_raw15[iside][imod][0][1][isamp] = g0d1DataAcc(*zdcMod).at(isamp);
1026  t_raw15[iside][imod][1][0][isamp] = g1d0DataAcc(*zdcMod).at(isamp);
1027  t_raw15[iside][imod][1][1][isamp] = g1d1DataAcc(*zdcMod).at(isamp);
1028  }
1029 
1030  if (nsamplesZdc == 24)
1031  {
1032  t_raw24[iside][imod][0][0][isamp] = g0dataAcc(*zdcMod).at(isamp);
1033  t_raw24[iside][imod][1][0][isamp] = g1dataAcc(*zdcMod).at(isamp);
1034  }
1035  }
1036  }
1037  }
1038  else if (zdcMod->zdcType() == 1 && nsamplesZdc == 24)
1039  {
1040  // this is the RPD
1041  if (enableRPD)
1042  {
1043  if (enableRPDAmp && !rpdErr)
1044  {
1045  t_RpdChannelBaseline[iside][zdcMod->zdcChannel()] = RPDChannelBaselineAcc(*zdcMod);
1046  std::vector<float> const &rpdChannelPileupExpFitParams = RPDChannelPileupExpFitParamsAcc(*zdcMod);
1047  std::copy(rpdChannelPileupExpFitParams.begin(), rpdChannelPileupExpFitParams.end(), t_RpdChannelPileupExpFitParams[iside][zdcMod->zdcChannel()]);
1048  std::vector<float> const &rpdChannelPileupExpFitParamErrs = RPDChannelPileupExpFitParamErrsAcc(*zdcMod);
1049  std::copy(rpdChannelPileupExpFitParamErrs.begin(), rpdChannelPileupExpFitParamErrs.end(), t_RpdChannelPileupExpFitParamErrs[iside][zdcMod->zdcChannel()]);
1050  std::vector<float> const &rpdChannelPileupStretchedExpFitParams = RPDChannelPileupStretchedExpFitParamsAcc(*zdcMod);
1051  std::copy(rpdChannelPileupStretchedExpFitParams.begin(), rpdChannelPileupStretchedExpFitParams.end(), t_RpdChannelPileupStretchedExpFitParams[iside][zdcMod->zdcChannel()]);
1052  std::vector<float> const &rpdChannelPileupStretchedExpFitParamErrs = RPDChannelPileupStretchedExpFitParamErrsAcc(*zdcMod);
1053  std::copy(rpdChannelPileupStretchedExpFitParamErrs.begin(), rpdChannelPileupStretchedExpFitParamErrs.end(), t_RpdChannelPileupStretchedExpFitParamErrs[iside][zdcMod->zdcChannel()]);
1054  t_RpdChannelPileupExpFitMSE[iside][zdcMod->zdcChannel()] = RPDChannelPileupExpFitMSEAcc(*zdcMod);
1055  t_RpdChannelPileupStretchedExpFitMSE[iside][zdcMod->zdcChannel()] = RPDChannelPileupStretchedExpFitMSEAcc(*zdcMod);
1056  t_RpdChannelAmplitude[iside][zdcMod->zdcChannel()] = RPDChannelAmplitudeAcc(*zdcMod);
1057  t_RpdChannelAmplitudeCalib[iside][zdcMod->zdcChannel()] = RPDChannelAmplitudeCalibAcc(*zdcMod);
1058  t_RpdChannelMaxADC[iside][zdcMod->zdcChannel()] = RPDChannelMaxADCAcc(*zdcMod);
1059  t_RpdChannelMaxADCCalib[iside][zdcMod->zdcChannel()] = RPDChannelMaxADCCalibAcc(*zdcMod);
1060  t_RpdChannelMaxSample[iside][zdcMod->zdcChannel()] = RPDChannelMaxSampleAcc(*zdcMod);
1061  t_RpdChannelStatus[iside][zdcMod->zdcChannel()] = RPDChannelStatusAcc(*zdcMod);
1062  t_RpdChannelPileupFrac[iside][zdcMod->zdcChannel()] = RPDChannelPileupFracAcc(*zdcMod);
1063  if(m_isMC){
1064  t_RpdModuleTruthNphotons[iside][zdcMod->zdcChannel()] = nPhotonsAcc(*zdcMod);
1065  }
1066  }
1067  if (enableOutputSamples)
1068  {
1069  std::vector<uint16_t> const &rpdChannelRaw = g0dataAcc(*zdcMod);
1070  std::copy(rpdChannelRaw.begin(), rpdChannelRaw.end(), t_rpdRaw[iside][zdcMod->zdcChannel()]);
1071  }
1072  }
1073  }
1074  }
1075  }
1076  else
1077  {
1078  ANA_MSG_INFO("No ZdcModules" << auxSuffix << " when expected!");
1079  }
1080 
1081  if (msgLvl (MSG::VERBOSE))
1082  {
1083  std::ostringstream message;
1084  message << "Dump zdc_ZdcModuleAmp: ";
1085  for (int iside = 0; iside < 2; iside++)
1086  {
1087  for (int imod = 0; imod < 4; imod++)
1088  {
1089  message << t_ZdcModuleAmp[iside][imod] << " ";
1090  }
1091  }
1092  }
1093 }
1094 
1095 void ZdcNtuple::processMCEventCollection(){
1096  /******************************************
1097  * Get the McEventCollection (input)
1098  ******************************************/
1099  SG::ReadHandle<McEventCollection> mcEventCollection (m_mcEventCollectionName, getContext());
1100  if (!mcEventCollection.isValid()){
1101  ANA_MSG_ERROR("Could not retrieve HepMC with key:" << m_mcEventCollectionName.key());
1102  return;
1103  }else{
1104  ANA_MSG_DEBUG("Retrieved HepMC with key: " << m_mcEventCollectionName.key());
1105  }
1106 
1107  /******************************************
1108  * Clear and resize the output vectors
1109  ******************************************/
1110  t_ZdcTruthParticlePosx.clear();
1111  t_ZdcTruthParticlePosy.clear();
1112  t_ZdcTruthParticlePosz.clear();
1113  t_ZdcTruthParticleTime.clear();
1114  t_ZdcTruthParticlePx.clear();
1115  t_ZdcTruthParticlePy.clear();
1116  t_ZdcTruthParticlePz.clear();
1117  t_ZdcTruthParticleEnergy.clear();
1118  t_ZdcTruthParticlePid.clear();
1119  t_ZdcTruthParticleStatus.clear();
1120 
1121  /******************************************
1122  * Sort the particles into sides and add
1123  * them to the output vectors
1124  ******************************************/
1125  for (unsigned int cntr = 0; cntr < mcEventCollection->size(); ++cntr){
1126  const HepMC::GenEvent *genEvt = (*mcEventCollection)[cntr];
1127 #ifdef HEPMC3
1128  for (const auto &vertex : genEvt->vertices()){
1129  for (const auto &particle : vertex->particles_in()){
1130 #else
1131  for (const auto &vertex : genEvt->vertex_range()){
1132  for (auto ip = vertex->particles_in_const_begin();
1133  ip != vertex->particles_in_const_end();
1134  ++ip) {
1135  auto particle = *ip;
1136 #endif
1137  t_ZdcTruthParticlePosx.push_back(vertex->position().x());
1138  t_ZdcTruthParticlePosy.push_back(vertex->position().y());
1139  t_ZdcTruthParticlePosz.push_back(vertex->position().z());
1140  t_ZdcTruthParticleTime.push_back(vertex->position().t());
1141  t_ZdcTruthParticlePx.push_back(particle->momentum().x());
1142  t_ZdcTruthParticlePy.push_back(particle->momentum().y());
1143  t_ZdcTruthParticlePz.push_back(particle->momentum().z());
1144  t_ZdcTruthParticleEnergy.push_back(particle->momentum().e());
1145  t_ZdcTruthParticlePid.push_back(particle->pdg_id());
1146  t_ZdcTruthParticleStatus.push_back(particle->status());
1147  } // end loop over particles
1148  }// end loop over vertices
1149  }// end loop over HepMC events
1150 }
1151 
1152 bool ZdcNtuple::processTriggerDecision()
1153 {
1154  ANA_MSG_DEBUG ("Processing trigger");
1155 
1156  bool passTrigger = false;
1157 
1158  t_trigger = 0;
1159  t_trigger_TBP = 0;
1160 
1161  for (int i = 0; i < 16; i++)
1162  {
1163  t_tav[i] = 0;
1164  t_tbp[i] = 0;
1165  }
1166 
1167  if (m_trigDecision)
1168  {
1169  for (int i = 0; i < 16; i++)
1170  {
1171  t_tbp[i] = m_trigDecision->tbp().at(i);
1172  t_tav[i] = m_trigDecision->tav().at(i);
1173  ANA_MSG_DEBUG( "TD: " << i << " tbp: " << std::hex << t_tbp[i] << "\t" << t_tav[i] );
1174  }
1175  t_bunchGroup = m_trigDecision->bgCode();
1176  }
1177 
1178  if (enableTrigger)
1179  {
1180 
1181  int ic = 0;
1182  for (auto cg : m_chainGroups)
1183  {
1184 
1185  if (zdcCalib)
1186  {
1187  std::string name = cg->getListOfTriggers().at(0);
1188  const unsigned int triggerbits = m_trigDecisionTool->isPassedBits(name);
1189  // deferred functionality
1190  //bool tbp = triggerbits&TrigDefs::L1_isPassedBeforePrescale;
1191  //bool tap = triggerbits&TrigDefs::L1_isPassedAfterPrescale;
1192  bool tav = triggerbits&TrigDefs::L1_isPassedAfterVeto;
1193  ANA_MSG_DEBUG("TD: checking trigger name=" << name<< " tav=" << tav);
1194  if (tav)
1195  {
1196  t_trigger += (1 << ic);
1197  t_decisions[ic] = true;
1198  t_prescales[ic] = cg->getPrescale();
1199  passTrigger = true;
1200  }
1201  else
1202  {
1203  t_decisions[ic] = 0;
1204  t_prescales[ic] = 0;
1205  }
1206  }
1207  else
1208  {
1209  if (cg->isPassed())
1210  {
1211  t_trigger += (1 << ic);
1212  t_decisions[ic] = true;
1213  t_prescales[ic] = cg->getPrescale();
1214  passTrigger = true;
1215  }
1216  else
1217  {
1218  t_decisions[ic] = 0;
1219  t_prescales[ic] = 0;
1220  }
1221  }
1222 
1223  if (cg->isPassedBits()&TrigDefs::EF_passedRaw)
1224  {
1225  t_trigger_TBP += (1 << ic);
1226  }
1227 
1228 
1229  ic++;
1230  }
1231 
1232  int irc = 0;
1233  for (auto cg : m_rerunChainGroups)
1234  {
1235  t_rerunDecisions[irc] = false;
1236  if (cg->isPassedBits()&TrigDefs::EF_passedRaw)
1237  {
1238  t_rerunDecisions[irc] = true;
1239  }
1240  irc++;
1241  }
1242 
1243  }
1244 
1245  return passTrigger;
1246 }
1247 
1248 void ZdcNtuple::processEventInfo()
1249 {
1250  ANA_MSG_DEBUG( "processing event info");
1251 
1252  t_bcid = m_eventInfo->bcid();
1253  t_runNumber = m_eventInfo->runNumber();
1254  t_eventNumber = m_eventInfo->eventNumber();
1255  t_lumiBlock = m_eventInfo->lumiBlock();
1256  t_bunchGroup = -1;
1257  t_extendedLevel1ID = m_eventInfo->extendedLevel1ID();
1258  t_timeStamp = m_eventInfo->timeStamp();
1259  t_timeStampNSOffset = m_eventInfo->timeStampNSOffset();
1260  t_passBits = acceptEvent();
1261  t_avgIntPerCrossing = m_eventInfo->averageInteractionsPerCrossing();
1262  t_actIntPerCrossing = m_eventInfo->actualInteractionsPerCrossing();
1263  t_zdcEventInfoError = m_eventInfo->errorState(xAOD::EventInfo::ForwardDet);
1264  t_zdcEventInfoErrorWord = m_eventInfo->eventFlags(xAOD::EventInfo::ForwardDet);
1265 
1266  if ( !(m_eventCounter++ % 1000) || msgLvl(MSG::DEBUG))
1267  {
1268  ANA_MSG_INFO("Event# " << m_eventCounter << " Run " << m_eventInfo->runNumber() << " Event " << m_eventInfo->eventNumber() << " LB " << m_eventInfo->lumiBlock() );
1269  }
1270 
1271 }
1272 
1273 void ZdcNtuple::processVInjInfo(){
1274  // Check for new run number
1275  //
1276  if (t_runNumber != m_lastRunNumber) {
1277  //
1278  // Get access to the injector pulse steps for this run
1279  //
1280  m_injMapRunToken = m_zdcInjPulserAmpMap->lookupRun(t_runNumber, true);
1281  if (!m_injMapRunToken.isValid()) {
1282  ANA_MSG_ERROR("Unable to obtain injector pulse steps for run " << t_runNumber);
1283  }
1284  else {
1285  unsigned int startLB = m_zdcInjPulserAmpMap->getFirstLumiBlock(m_injMapRunToken);
1286  unsigned int nsteps = m_zdcInjPulserAmpMap->getNumSteps(m_injMapRunToken);
1287  ANA_MSG_DEBUG("Successfully obtained injector pulse steps for run " << t_runNumber
1288  << ", first LB = " << startLB << ", number of steps = " << nsteps);
1289  }
1290 
1291  // update the last run number to be the current run number
1292  m_lastRunNumber = t_runNumber;
1293  }
1294 
1295  t_vInj = m_zdcInjPulserAmpMap->getPulserAmplitude(m_injMapRunToken, t_lumiBlock);
1296 }
1297 
1298 void ZdcNtuple::processInDet()
1299 {
1300  ANA_MSG_DEBUG("processInDet(): processing tracks & vertices!");
1301  t_ntrk = 0;
1302  t_nvx = 0;
1303  t_vxntrk = 0;
1304  t_vx_trk_index.clear();
1305  t_vxsumpt2 = 0;
1306  t_vxtype = 0;
1307  t_pvindex = -1;
1308  t_puvxntrk = 0;
1309  t_puvxsumpt = 0;
1310  t_vxnlooseprimary = 0;
1311  t_vxnminbias = 0;
1312 
1313  int i;
1314  for (i = 0; i < 3; i++) t_vx[i] = 0;
1315  for (i = 0; i < 6; i++) t_vxcov[i] = 0;
1316 
1317  const xAOD::Vertex* primary_vertex = nullptr;
1318  size_t pv_index = -1;
1319  size_t vx_index = 0;
1320  float max_pileup_sumpT = 0.;
1321  int max_pileup_nTrack = 0;
1322  float max_pileup_z = 0;
1323  int nStrongPileup = 0;
1324 
1325  t_nvtx = 0;
1326  t_vtx_type.clear();
1327  t_vtx_x.clear();
1328  t_vtx_y.clear();
1329  t_vtx_z.clear();
1330  t_vtx_ntrk_all.clear();
1331  t_vtx_sumpt2_all.clear();
1332  t_vtx_ntrk.clear();
1333  t_vtx_sumpt2.clear();
1334  t_vtx_trk_index.clear();
1335 
1336  if (m_primaryVertices)
1337  {
1338  ANA_MSG_DEBUG("processInDet: processing vertices");
1339 
1340  t_nvx = m_primaryVertices->size();
1341 
1342  static const SG::ConstAccessor<float> sumPt2Acc("sumPt2");
1343 
1344  // start of new vertex representation
1345  t_nvtx = m_primaryVertices->size();
1346  for (const auto vertex : *m_primaryVertices)
1347  {
1348  float vtx_sumpt2 = 0;
1349  int vtx_ntrk = 0;
1350 
1351  t_vtx_type.push_back(vertex->vertexType());
1352  t_vtx_x.push_back(0);
1353  t_vtx_y.push_back(0);
1354  t_vtx_z.push_back(vertex->z());
1355 
1356  t_vtx_ntrk.push_back(vtx_ntrk);
1357  t_vtx_sumpt2.push_back(vtx_sumpt2 / 1e6);
1358  t_vtx_ntrk_all.push_back(vertex->nTrackParticles());
1359 
1360  if (sumPt2Acc.isAvailable(*vertex))
1361  t_vtx_sumpt2_all.push_back(sumPt2Acc(*vertex));
1362  else
1363  t_vtx_sumpt2_all.push_back(-1);
1364 
1365  std::vector<int16_t> trk_index;
1366  if ( m_trackParticles && vertex->nTrackParticles() <= trackLimit )
1367  {
1368  const std::vector< ElementLink< xAOD::TrackParticleContainer > >& vxTrackParticles = vertex->trackParticleLinks();
1369  for (size_t itrk = 0; itrk < vxTrackParticles.size(); itrk++)
1370  {
1371  ElementLink< xAOD::TrackParticleContainer > trkLink = vxTrackParticles.at(itrk);
1372  trk_index.push_back(trkLink.index());
1373  }
1374  }
1375  t_vtx_trk_index.push_back(trk_index);
1376 
1377  // end of new vertex representation
1378 
1379  if (vertex->vertexType() == xAOD::VxType::PriVtx)
1380  {
1381  primary_vertex = vertex;
1382  pv_index = vx_index;
1383  }
1384  if (vertex->vertexType() == xAOD::VxType::PileUp)
1385  {
1386  float pileup_sumpT = 0;
1387  int pileup_nTrack = 0;
1388  for (size_t itr = 0; itr < vertex->nTrackParticles(); itr++)
1389  {
1390  int track_quality = trackQuality(vertex->trackParticle(itr), vertex);
1391  if (track_quality != -1 && (track_quality & 128) != 0)
1392  {
1393  pileup_nTrack++;
1394  pileup_sumpT += vertex->trackParticle(itr)->pt();
1395  }
1396  }
1397  if (pileup_sumpT > max_pileup_sumpT)
1398  {
1399  max_pileup_sumpT = pileup_sumpT;
1400  max_pileup_nTrack = pileup_nTrack;
1401  max_pileup_z = vertex->z();
1402  }
1403  if (pileup_sumpT > 5e3 || pileup_nTrack > 5) nStrongPileup++;
1404  }
1405  vx_index++;
1406  }
1407  }
1408 
1409  t_nstrong = nStrongPileup;
1410 
1411  if (primary_vertex != nullptr)
1412  {
1413  t_vx[0] = primary_vertex->x();
1414  t_vx[1] = primary_vertex->y();
1415  t_vx[2] = primary_vertex->z();
1416  /*
1417  const std::vector<float>& cov = primary_vertex->covariance();
1418  */
1419  //for (size_t i=0;i<cov.size();i++)
1420  for (size_t i = 0; i < 6; i++)
1421  {
1422  //t_vxcov[i] = cov.at(i);
1423  t_vxcov[i] = 0;
1424  }
1425  t_vxntrk = primary_vertex->nTrackParticles();
1426  static const SG::ConstAccessor<float> sumPt2Acc("sumPt2");
1427  if (sumPt2Acc.isAvailable(*primary_vertex))
1428  t_vxsumpt2 = sumPt2Acc(*primary_vertex);
1429  else
1430  t_vxsumpt2 = 0;
1431 
1432  t_vxtype = primary_vertex->vertexType();
1433  t_pvindex = pv_index;
1434  t_puvxz = max_pileup_z;
1435  t_puvxsumpt = max_pileup_sumpT;
1436  t_puvxntrk = max_pileup_nTrack;
1437 
1438  const std::vector< ElementLink< xAOD::TrackParticleContainer > >& vxTrackParticles = primary_vertex->trackParticleLinks();
1439 
1440  for (size_t itrk = 0; itrk < vxTrackParticles.size(); itrk++)
1441  {
1442  ElementLink< xAOD::TrackParticleContainer > trkLink = vxTrackParticles.at(itrk);
1443  if (!trkLink.isValid()) continue;
1444  if (m_trackParticles)
1445  {
1446  if (m_trackParticles->size() <= trackLimit)
1447  t_vx_trk_index.push_back(trkLink.index());
1448  }
1449  }
1450 
1451  }
1452 
1453 
1454  if (m_trackParticles)
1455  {
1456  ANA_MSG_DEBUG("processInDet: processing trackss");
1457 
1458  t_trk_pt.clear();
1459  t_trk_eta.clear();
1460  t_trk_phi.clear();
1461  t_trk_e.clear();
1462  t_trk_index.clear();
1463  t_trk_theta.clear();
1464  t_trk_charge.clear();
1465  t_trk_d0.clear();
1466  t_trk_z0.clear();
1467  t_trk_vz.clear();
1468  t_trk_vtxz.clear();
1469  t_trk_quality.clear();
1470  t_trk_nPixHits.clear();
1471  t_trk_nSctHits.clear();
1472  t_trk_nPixDead.clear();
1473  t_trk_nSctDead.clear();
1474  t_trk_nPixHoles.clear();
1475  t_trk_nSctHoles.clear();
1476  t_trk_nTrtHits.clear();
1477  t_trk_nTrtOutliers.clear();
1478  t_trk_inPixHits.clear();
1479  t_trk_exPixHits.clear();
1480  t_trk_ninPixHits.clear();
1481  t_trk_nexPixHits.clear();
1482  t_trk_pixeldEdx.clear();
1483 
1484  t_ntrk = m_trackParticles->size();
1485 
1486  if ( !enableTracks ) return;
1487 
1488  if ( t_ntrk <= trackLimit ) // dump all tracks
1489  {
1490  int trk_index = 0;
1491  for (const auto track : *m_trackParticles)
1492  {
1493  writeTrack(track, primary_vertex, trk_index++);
1494  }
1495  }
1496  else // write small vertices
1497  {
1498  for (const auto vertex : *m_primaryVertices)
1499  {
1500  if (vertex->nTrackParticles() <= trackLimit )
1501  {
1502  const std::vector< ElementLink< xAOD::TrackParticleContainer > >& vxTrackParticles = vertex->trackParticleLinks();
1503  for (size_t itrk = 0; itrk < vxTrackParticles.size(); itrk++)
1504  {
1505  ElementLink< xAOD::TrackParticleContainer > trkLink = vxTrackParticles.at(itrk);
1506  writeTrack(*trkLink, vertex, trkLink.index());
1507  }
1508  }
1509  }
1510  }
1511  }
1512 
1513  return;
1514 }
1515 
1516 
1517 int ZdcNtuple::trackQuality(const xAOD::TrackParticle* track, const xAOD::Vertex* vertex)
1518 {
1519 
1520  if (!track) return -1;
1521 
1522  bool pass_looseprimary = false;
1523  if (m_selTool->accept(*track,vertex))
1524  {
1525  pass_looseprimary = true;
1526  }
1527 
1528  int quality = 0;
1529  if (pass_looseprimary) quality += 1;
1530 
1531  return quality;
1532 
1533 }
1534 
1535 
1536 
1537 void ZdcNtuple::writeTrack(const xAOD::TrackParticle* track, const xAOD::Vertex* vertex, int trk_index)
1538 {
1539  t_trk_pt.push_back(track->pt());
1540  t_trk_eta.push_back(track->eta());
1541  t_trk_phi.push_back(track->phi());
1542  t_trk_e.push_back(track->e());
1543  t_trk_index.push_back(trk_index);
1544  t_trk_theta.push_back(track->theta());
1545  t_trk_charge.push_back(track->charge());
1546  t_trk_d0.push_back(track->d0());
1547  t_trk_z0.push_back(track->z0());
1548  t_trk_vz.push_back(track->vz());
1549 
1550  float vtxz = -999.;
1551  t_trk_vtxz.push_back(vtxz);
1552 
1553  static const SG::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHitsAcc("numberOfInnermostPixelLayerHits");
1554  static const SG::ConstAccessor<uint8_t> expectInnermostPixelLayerHitAcc("expectInnermostPixelLayerHit");
1555  static const SG::ConstAccessor<uint8_t> numberOfNextToInnermostPixelLayerHitsAcc("numberOfNextToInnermostPixelLayerHits");
1556  static const SG::ConstAccessor<uint8_t> expectNextToInnermostPixelLayerHitAcc("expectNextToInnermostPixelLayerHit");
1557  static const SG::ConstAccessor<uint8_t> numberOfSCTHitsAcc("numberOfSCTHits");
1558  static const SG::ConstAccessor<uint8_t> numberOfPixelHitsAcc("numberOfPixelHits");
1559  static const SG::ConstAccessor<uint8_t> numberOfSCTDeadSensorsAcc("numberOfSCTDeadSensors");
1560  static const SG::ConstAccessor<uint8_t> numberOfPixelDeadSensorsAcc("numberOfPixelDeadSensors");
1561  static const SG::ConstAccessor<uint8_t> numberOfSCTHolesAcc("numberOfSCTHoles");
1562  static const SG::ConstAccessor<uint8_t> numberOfPixelHolesAcc("numberOfPixelHoles");
1563  static const SG::ConstAccessor<uint8_t> numberOfTRTHitsAcc("numberOfTRTHits");
1564  static const SG::ConstAccessor<uint8_t> numberOfTRTOutliersAcc("numberOfTRTOutliers");
1565 
1566  t_trk_quality.push_back(trackQuality(track, vertex));
1567  t_trk_inPixHits.push_back(numberOfInnermostPixelLayerHitsAcc(*track));
1568  t_trk_exPixHits.push_back(expectInnermostPixelLayerHitAcc(*track));
1569  t_trk_ninPixHits.push_back(numberOfNextToInnermostPixelLayerHitsAcc(*track));
1570  t_trk_nexPixHits.push_back(expectNextToInnermostPixelLayerHitAcc(*track));
1571  t_trk_nSctHits.push_back(numberOfSCTHitsAcc(*track));
1572  t_trk_nPixHits.push_back(numberOfPixelHitsAcc(*track));
1573  t_trk_nSctDead.push_back(numberOfSCTDeadSensorsAcc(*track));
1574  t_trk_nPixDead.push_back(numberOfPixelDeadSensorsAcc(*track));
1575  t_trk_nSctHoles.push_back(numberOfSCTHolesAcc(*track));
1576  t_trk_nPixHoles.push_back(numberOfPixelHolesAcc(*track));
1577  t_trk_nTrtHits.push_back(numberOfTRTHitsAcc(*track));
1578  t_trk_nTrtOutliers.push_back(numberOfTRTOutliersAcc(*track));
1579 
1580  float pixeldEdx = 0;
1581  track->summaryValue(pixeldEdx, xAOD::SummaryType::pixeldEdx);
1582  t_trk_pixeldEdx.push_back(pixeldEdx);
1583 }
1584 
1585 
1586 void ZdcNtuple::processFCal()
1587 {
1588  ANA_MSG_DEBUG("processFCal: processing FCal");
1589 
1590  t_fcalEt = 0.;
1591  t_fcalEtA = 0.;
1592  t_fcalEtC = 0.;
1593  t_fcalEtA_TT = 0.;
1594  t_fcalEtC_TT = 0.;
1595 
1596  if (m_caloSums)
1597  {
1598  static const SG::ConstAccessor<std::string> SummaryAcc("Summary");
1599  for (const auto calosum : *m_caloSums)
1600  {
1601  const std::string name = SummaryAcc(*calosum);
1602  if (name == "FCal")
1603  {
1604  t_fcalEt = calosum->et();
1605  ANA_MSG_DEBUG("processFCal: fcalEt = " << t_fcalEt);
1606  }
1607 
1608  if (name == "All")
1609  {
1610  t_totalEt = calosum->et();
1611  ANA_MSG_DEBUG("processFCal: totalEt = " << t_totalEt);
1612  }
1613  }
1614  }
1615 
1616  t_fcalEtA = 0;
1617  t_fcalEtC = 0;
1618  t_totalEt24 = 0;
1619 
1620  if (m_eventShapes)
1621  {
1622  for (const auto eventShape : *m_eventShapes)
1623  {
1624  int layer = eventShape->layer();
1625  float eta = eventShape->etaMin();
1626  float et = eventShape->et();
1627  if (layer == 21 || layer == 22 || layer == 23)
1628  {
1629  if (eta > 0) t_fcalEtA += et;
1630  if (eta < 0) t_fcalEtC += et;
1631  }
1632 
1633  if (TMath::Abs(eta) < 2.4)
1634  {
1635  t_totalEt24 += et;
1636  }
1637  }
1638  }
1639 
1640  t_L1ET = 0;
1641  t_L1ET24 = 0;
1642 
1643  if (m_lvl1EnergySumRoI)
1644  {
1645  t_L1ET = m_lvl1EnergySumRoI->energyT();
1646  //t_L1ET24 = m_lvl1EnergySumRoI->energyTRestricted(); // TBD when limited eta ET available
1647  }
1648 
1649  return;
1650 }
1651 
1652 void ZdcNtuple::processGaps()
1653 {
1654 
1655  float eta_min = 5;
1656  float eta_max = -5;
1657 
1658  if (!m_caloClusters) return;
1659  for (const auto cl : *m_caloClusters)
1660  {
1661 
1662  if (cl->pt() < m_gapPtMin) continue;
1663 
1664  int etabin = h_TCSigCut->GetXaxis()->FindBin(cl->eta());
1665  if (etabin < 1 || etabin > h_TCSigCut->GetNbinsX()) continue;
1666  float sig_cut = h_TCSigCut->GetBinContent(etabin);
1667  float sig = cl->getMomentValue(xAOD::CaloCluster::CELL_SIGNIFICANCE);
1668  int cl_cell_sig_samp = static_cast<int>(cl->getMomentValue(xAOD::CaloCluster::CELL_SIG_SAMPLING));
1669 
1670  ANA_MSG_VERBOSE ("gapclus: etabin " << etabin << " sig_cut=" << sig_cut << " sig=" << sig << " samp=" << cl_cell_sig_samp);
1671 
1672  if (sig < sig_cut) continue;
1673 
1674  if (cl_cell_sig_samp >= CaloSampling::TileBar0 && cl_cell_sig_samp <= CaloSampling::TileExt2) continue;
1675 
1676  if (cl->eta() < eta_min) eta_min = cl->eta();
1677  if (cl->eta() > eta_max) eta_max = cl->eta();
1678 
1679  }
1680 
1681  t_edgeGapA = 4.9 - eta_max;
1682  t_edgeGapC = eta_min + 4.9;
1683  ANA_MSG_DEBUG("processGaps(): egA " << t_edgeGapA << " , egC " << t_edgeGapC);
1684 
1685 }
1686 
1687 void ZdcNtuple::processMBTS()
1688 {
1689  ANA_MSG_DEBUG("processMBTS: trying to process!");
1690  t_mbts_countA = 0;
1691  t_mbts_countC = 0;
1692  t_T2mbts_countAin = 0;
1693  t_T2mbts_countCin = 0;
1694  t_mbts_timeA = 0.;
1695  t_mbts_timeC = 0.;
1696  t_mbts_timeDiff = 0.;
1697 
1698  if (m_mbtsInfo->size() > 0)
1699  {
1700  t_mbts_countA = m_mbtsInfo->at(0)->countA();
1701  t_mbts_countC = m_mbtsInfo->at(0)->countC();
1702  t_mbts_timeA = m_mbtsInfo->at(0)->timeA();
1703  t_mbts_timeC = m_mbtsInfo->at(0)->timeC();
1704  t_mbts_timeDiff = m_mbtsInfo->at(0)->timeDiff();
1705  }
1706  else
1707  {
1708  ANA_MSG_INFO("processMBTS: Warning: MBTS info empty!");
1709  }
1710 
1711  for (int iside = 0; iside < 2; iside++)
1712  {
1713  for (int iin = 0; iin < 8; iin++)
1714  {
1715  t_mbts_in_e[iside][iin] = 0.;
1716  t_mbts_in_t[iside][iin] = 0.;
1717  t_T2mbts_in_e[iside][iin] = 0.;
1718  t_T2mbts_in_t[iside][iin] = 0.;
1719  }
1720  for (int iout = 0; iout < 4; iout++)
1721  {
1722  t_mbts_out_e[iside][iout] = 0.;
1723  t_mbts_out_t[iside][iout] = 0.;
1724  t_T2mbts_out_e[iside][iout] = 0.;
1725  t_T2mbts_out_t[iside][iout] = 0.;
1726  }
1727  }
1728 
1729  ANA_MSG_DEBUG ("filling MBTS");
1730 
1731  if (m_mbtsModules == 0)
1732  {
1733  ANA_MSG_INFO("processMBTS: no MBTS container?");
1734  return;
1735  }
1736 
1737  for (const auto mbtsMod : *m_mbtsModules)
1738  {
1739  int iside = 1;
1740  if (mbtsMod->type() < 0) iside = 0.;
1741  float phibin = 0.;
1742  int iphibin = -1;
1743  if (mbtsMod->eta() > 3)
1744  {
1745  phibin = mbtsMod->phi() / (2 * TMath::Pi() / 8.) - 0.4;
1746  iphibin = static_cast<int>(phibin);
1747  if (iphibin < 0 || iphibin > 7)
1748  {
1749  ANA_MSG_INFO("processMBTS: MBTS has bad phi bin");
1750  continue;
1751  }
1752  t_mbts_in_e[iside][iphibin] = mbtsMod->e();
1753  t_mbts_in_t[iside][iphibin] = mbtsMod->time();
1754  }
1755  else
1756  {
1757  phibin = mbtsMod->phi() / (2 * TMath::Pi() / 4.) - 0.24;
1758  iphibin = static_cast<int>(phibin);
1759  if (iphibin < 0 || iphibin > 3)
1760  {
1761  ANA_MSG_INFO("processMBTS: MBTS has bad phi bin");
1762  continue;
1763  }
1764  t_mbts_out_e[iside][iphibin] = mbtsMod->e();
1765  t_mbts_out_t[iside][iphibin] = mbtsMod->time();
1766  }
1767  }
1768 
1769  if (!m_trigT2MbtsBits) return;
1770 
1771  for (const auto mbtsBits : *m_trigT2MbtsBits)
1772  {
1773  const std::vector<float>& energies = mbtsBits->triggerEnergies();
1774  const std::vector<float>& times = mbtsBits->triggerTimes();
1775  for (int imbts = 0; imbts < 32; imbts++)
1776  {
1777  int side = imbts / 16;
1778  int ring = (imbts - 16 * side) / 8;
1779  bool isInner = (ring == 0);
1780  int index = (imbts - 16 * side - ring * 8);
1781  if (!isInner)
1782  {
1783  if ((index % 2) != 0) continue; // skip odd out ring
1784  index /= 2;
1785  }
1786  int iside = (side == 0) ? 1 : 0; // code maps side 1 into first 16 bits and side -1 into second set
1787 
1788  ANA_MSG_VERBOSE ("imbts=" << imbts << " isInner=" << isInner << " iside=" << iside << " index=" << index << " e=" << energies.at(imbts) << " t=" << times.at(imbts));
1789  if (isInner)
1790  {
1791  t_T2mbts_in_e[iside][index] = energies.at(imbts);
1792  t_T2mbts_in_t[iside][index] = times.at(imbts);
1793  if (TMath::Abs(times.at(imbts)) < 12.0 && energies.at(imbts) > 40 / 222.)
1794  {
1795  if (iside == 0) t_T2mbts_countCin++;
1796  if (iside == 1) t_T2mbts_countAin++;
1797  }
1798  }
1799  else
1800  {
1801  t_T2mbts_out_e[iside][index] = energies.at(imbts);
1802  t_T2mbts_out_t[iside][index] = times.at(imbts);
1803  }
1804  }
1805  }
1806 
1807  return;
1808 }
1809 
1810 void ZdcNtuple::processClusters()
1811 {
1812  //t_nclus = 0;
1813 
1814  t_cc_pt.clear();
1815  t_cc_eta.clear();
1816  t_cc_phi.clear();
1817  t_cc_e.clear();
1818  t_cc_raw_m.clear();
1819  t_cc_raw_eta.clear();
1820  t_cc_raw_phi.clear();
1821  t_cc_raw_e.clear();
1822  t_cc_raw_samp.clear();
1823  t_cc_layer.clear();
1824  t_cc_sig.clear();
1825 
1826  t_nclus = m_caloClusters->size();
1827 
1828  t_clusEt = 0;
1829  t_clusEtMax = -999;
1830  t_clusetaMax = 0;
1831  t_clusphiMax = 0;
1832 
1833  for (const auto cluster : *m_caloClusters)
1834  {
1835  t_cc_pt.push_back(cluster->pt());
1836  t_cc_eta.push_back(cluster->eta());
1837  t_cc_phi.push_back(cluster->phi());
1838  t_cc_e.push_back(cluster->e());
1839  t_cc_raw_m.push_back(cluster->rawM());
1840  t_cc_raw_eta.push_back(cluster->rawEta());
1841  t_cc_raw_phi.push_back(cluster->rawPhi());
1842  t_cc_raw_e.push_back(cluster->rawE());
1843 
1844  std::vector<float> energies;
1845 
1846  for (size_t s = CaloSampling::PreSamplerB; s < CaloSampling::Unknown; s++ )
1847  {
1848  bool hasSample = cluster->hasSampling( (xAOD::CaloCluster::CaloSample) s );
1849  float e = 0;
1850  if (hasSample)
1851  {
1852  e = cluster->eSample( (xAOD::CaloCluster::CaloSample) s);
1853  }
1854  energies.push_back(e);
1855  }
1856  t_cc_raw_samp.push_back(energies);
1857 
1858  float et = cluster->e() / TMath::CosH(cluster->eta());
1859  t_clusEt += et;
1860  if (et > t_clusEtMax)
1861  {
1862  t_clusEtMax = et;
1863  t_clusetaMax = cluster->eta();
1864  t_clusphiMax = cluster->phi();
1865  }
1866 
1867  double cell_sig = 0;
1868  if (!cluster->retrieveMoment(xAOD::CaloCluster::CELL_SIGNIFICANCE, cell_sig)) {ANA_MSG_DEBUG("processClusters() : No CELL_SIGNIFICANCE!");}
1869  t_cc_sig.push_back(cell_sig);
1870  double cell_layer = 0;
1871  if (!cluster->retrieveMoment(xAOD::CaloCluster::CELL_SIG_SAMPLING, cell_layer)) {ANA_MSG_DEBUG("processClusters() : No CELL_SIG_SAMPLING!");}
1872  t_cc_layer.push_back(static_cast<int>(cell_layer));
1873  //t_nclus++;
1874  }
1875 
1876  if ( (!enableClusters) || (t_ntrk >= trackLimit) ) // if disabled or if too many tracks
1877  {
1878  t_cc_pt.clear();
1879  t_cc_eta.clear();
1880  t_cc_phi.clear();
1881  t_cc_e.clear();
1882  t_cc_layer.clear();
1883  t_cc_sig.clear();
1884  }
1885  else
1886  {
1887  ANA_MSG_DEBUG("processClusters(): keeping clusters");
1888  }
1889  return;
1890 }
1891 
1892 void ZdcNtuple::processProtons(){
1893 
1894  proton_pt.clear();
1895  proton_eta.clear();
1896  proton_phi.clear();
1897  proton_e.clear();
1898  proton_side.clear();
1899  proton_eLoss.clear();
1900  proton_t.clear();
1901 
1902  proton_track_stationID.clear();
1903  proton_track_nClusters.clear();
1904  proton_track_xLocal.clear();
1905  proton_track_yLocal.clear();
1906  proton_track_zLocal.clear();
1907  proton_track_xSlope.clear();
1908  proton_track_ySlope.clear();
1909 
1910  proton_track_stationID.resize(m_afpProtons->size(), std::vector<int>(2));
1911  proton_track_nClusters.resize(m_afpProtons->size(), std::vector<int>(2));
1912  proton_track_xLocal.resize(m_afpProtons->size(), std::vector<float>(2));
1913  proton_track_yLocal.resize(m_afpProtons->size(), std::vector<float>(2));
1914  proton_track_zLocal.resize(m_afpProtons->size(), std::vector<float>(2));
1915  proton_track_xSlope.resize(m_afpProtons->size(), std::vector<float>(2));
1916  proton_track_ySlope.resize(m_afpProtons->size(), std::vector<float>(2));
1917 
1918  nProtons = 0;
1919 
1920  for(const auto * proton: *m_afpProtons){
1921 
1922  proton_pt.push_back(proton->pt());
1923  proton_eta.push_back(proton->eta());
1924  proton_phi.push_back(proton->phi());
1925  proton_e.push_back(proton->e());
1926  proton_side.push_back(proton->side());
1927 
1928  proton_eLoss.push_back((6800.-proton->e())/6800.);
1929  p_scat.SetPtEtaPhiE(proton->pt(), proton->eta(), proton->phi(), proton->e());
1930  (signbit(proton->eta())) ? p_beam.SetPxPyPzE(0.0, 0.0, -6800.0, 6800.0) : p_beam.SetPxPyPzE(0.0, 0.0, 6800.0,\
1931  6800.0);
1932 
1933  proton_t.push_back( (p_beam - p_scat)*(p_beam - p_scat));
1934 
1935  for(int i=0; i< int(proton->nTracks()); i++){
1936 
1937  proton_track_stationID.at(nProtons).at(i) = proton->track(i)->stationID();
1938  proton_track_nClusters.at(nProtons).at(i) = proton->track(i)->nClusters();
1939  proton_track_xLocal.at(nProtons).at(i) = proton->track(i)->xLocal();
1940  proton_track_yLocal.at(nProtons).at(i) = proton->track(i)->yLocal();
1941  proton_track_zLocal.at(nProtons).at(i) = proton->track(i)->zLocal();
1942  proton_track_xSlope.at(nProtons).at(i) = proton->track(i)->xSlope();
1943  proton_track_ySlope.at(nProtons).at(i) = proton->track(i)->ySlope();
1944 
1945  }
1946 
1947  nProtons++;
1948  }
1949 
1950  return;
1951 }
1952 
1953 uint32_t ZdcNtuple::acceptEvent()
1954 {
1955  uint32_t passbits = 0;
1956 
1957  if (!m_isMC)
1958  {
1959  if (useGRL)
1960  {
1961  if (!m_grl->passRunLB(*m_eventInfo)) {
1962  passbits += 1; // UPC GRL
1963  }
1964  }
1965 
1966  /*
1967  if(!m_grl_mb->passRunLB(*m_eventInfo)){
1968  passbits += 4; // MB GRL
1969  }
1970  */
1971 
1972  if ( (m_eventInfo->errorState(xAOD::EventInfo::LAr) == xAOD::EventInfo::Error )
1973  || (m_eventInfo->errorState(xAOD::EventInfo::Tile) == xAOD::EventInfo::Error )
1974  || (m_eventInfo->errorState(xAOD::EventInfo::SCT) == xAOD::EventInfo::Error )
1975  || (m_eventInfo->isEventFlagBitSet(xAOD::EventInfo::Core, 18) ) )
1976  {
1977  passbits += 2;
1978  } // end if event flags check
1979  } // end if the event is data
1980 
1981  return passbits;
1982 }
1983 
1984 void ZdcNtuple::setupTriggerHistos()
1985 {
1986  if (!enableTrigger) return;
1987 
1988  m_outputTree = tree( "zdcTree" );
1989  ANA_MSG_INFO("setupTriggerHistos(): Setting up trigger histos and ntuple = " << m_outputTree);
1990 
1991  std::vector<std::string> triggers;
1992  std::vector<std::string> rerunTriggers;
1993  bool zdc_triggers = true;
1994 
1995  // ZDC triggers
1996  if (zdc_triggers)
1997  {
1998  if (zdcCalib) // lists for calibration data
1999  {
2000  if (lhcf2022)
2001  {
2002  triggers.push_back("HLT_noalg_ZDCPEB_L1LHCF");
2003  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_OR");
2004  }
2005 
2006  if (pbpb2023)
2007  {
2008  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_OR");
2009  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_OR_EMPTY");
2010  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_OR_UNPAIRED_NONISO");
2011  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A_C");
2012  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A_C_EMPTY");
2013  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A_C_UNPAIRED_NONISO");
2014  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A");
2015  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A_EMPTY");
2016  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_A_UNPAIRED_NONISO");
2017  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_C");
2018  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_C_EMPTY");
2019  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_C_UNPAIRED_NONISO");
2020  }
2021  }
2022  else // lists for physics data
2023  {
2024  if (lhcf2022)
2025  {
2026  triggers.push_back("HLT_noalg_L1LHCF");
2027  }
2028  if (lhcf2022afp)
2029  {
2030  triggers.push_back("HLT_noalg_AFPPEB_L1AFP_A");
2031  triggers.push_back("HLT_noalg_AFPPEB_L1AFP_C");
2032  }
2033  if (lhcf2022zdc)
2034  {
2035  triggers.push_back("HLT_noalg_ZDCPEB_L1ZDC_OR");
2036  triggers.push_back("HLT_noalg_ZDCPEB_L1LHCF");
2037  triggers.push_back("HLT_noalg_L1ZDC_OR");
2038  triggers.push_back("HLT_noalg_L1ZDC_XOR_E2");
2039  triggers.push_back("HLT_noalg_L1ZDC_XOR_E1_E3");
2040  triggers.push_back("HLT_noalg_L1ZDC_A_AND_C");
2041  triggers.push_back("HLT_mb_sptrk_L1ZDC_OR");
2042  triggers.push_back("HLT_mb_sptrk_L1ZDC_XOR_E2");
2043  triggers.push_back("HLT_mb_sptrk_L1ZDC_XOR_E1_E3");
2044  triggers.push_back("HLT_mb_sptrk_L1ZDC_A_AND_C");
2045  triggers.push_back("HLT_mb_sp100_trk30_hmt_L1ZDC_XOR_E2");
2046  triggers.push_back("HLT_mb_sp100_trk30_hmt_L1ZDC_XOR_E1_E3");
2047  triggers.push_back("HLT_mb_sp100_trk30_hmt_L1ZDC_A_AND_C");
2048  }
2049  }
2050  }
2051 
2052  //char name[50];
2053  ANA_MSG_INFO("Adding trigger branches!");
2054 
2055  int ic = 0;
2056  for (auto &trig : triggers)
2057  {
2058  const Trig::ChainGroup* cg = m_trigDecisionTool->getChainGroup(trig);
2059  if (cg->getListOfTriggers().size())
2060  {
2061  ANA_MSG_INFO("setupTriggerHistos(): Trigger found = " << trig.c_str() << " bit " << ic);
2062  }
2063  else
2064  {
2065  ANA_MSG_INFO("setupTriggerHistos(): Trigger NOT found = " << trig.c_str() << " bit " << ic);
2066  }
2067  m_chainGroups.push_back(cg);
2068  // force all triggers to show up in tree
2069  TString bname(trig.c_str());
2070  m_outputTree->Branch(bname, &(t_decisions[ic]), bname + "/O");
2071  m_outputTree->Branch("ps_" + bname, &(t_prescales[ic]), "ps_" + bname + "/F");
2072  ic++;
2073  }
2074 
2075  ANA_MSG_INFO( "triggers = " << triggers.size() << " chains = " << m_chainGroups.size() );
2076 
2077  int irc = 0;
2078  ANA_MSG_INFO("Adding rerun trigger branches!");
2079  for (auto &trig : rerunTriggers)
2080  {
2081  const Trig::ChainGroup* cg = m_trigDecisionTool->getChainGroup(trig);
2082  m_rerunChainGroups.push_back(cg);
2083  if (cg->getListOfTriggers().size())
2084  {
2085  ANA_MSG_INFO("setupTriggerHistos(): Rerun trigger found = " << trig.c_str() << " bit " << irc);
2086  }
2087  else
2088  {
2089  ANA_MSG_INFO("setupTriggerHistos(): Rerun trigger NOT found = " << trig.c_str() << " bit " << irc);
2090  }
2091  // force all rerun triggers to show up in tree
2092  TString bname(trig.c_str());
2093  m_outputTree->Branch(bname, &(t_rerunDecisions[irc]), bname + "/O");
2094  irc++;
2095  }
2096 
2097  // trigger matching flags for electrons and muons
2098 
2099  m_setupTrigHist = true;
2100 
2101  ANA_MSG_INFO("setupTriggerHistos(): Finished setting up trigger");
2102 
2103 }
2104 
2105 // from TrigMuonMatching
2106 double ZdcNtuple::dR(const double eta1, const double phi1, const double eta2, const double phi2)
2107 {
2108  double deta = std::abs(eta1 - eta2);
2109  double dphi = std::abs(phi1 - phi2) < TMath::Pi() ? std::abs(phi1 - phi2) : 2 * TMath::Pi() - std::abs(phi1 - phi2);
2110  return std::sqrt(deta * deta + dphi * dphi);
2111 }
2112 
2113 
2114 StatusCode ZdcNtuple :: finalize ()
2115 {
2116  // This method is the mirror image of initialize(), meaning it gets
2117  // called after the last event has been processed on the worker node
2118  // and allows you to finish up any objects you created in
2119  // initialize() before they are written to disk. This is actually
2120  // fairly rare, since this happens separately for each worker node.
2121  // Most of the time you want to do your post-processing on the
2122  // submission node after all your histogram outputs have been
2123  // merged. This is different from histFinalize() in that it only
2124  // gets called on worker nodes that processed input events.
2125 
2126 
2127  return StatusCode::SUCCESS;
2128 }
ZdcNtuple::t_trk_phi
std::vector< float > t_trk_phi
Definition: ZdcNtuple.h:361
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ZdcNtuple::t_trk_d0
std::vector< float > t_trk_d0
Definition: ZdcNtuple.h:364
ShallowCopy.h
ZdcNtuple::t_RPDSubtrAmpSum
float t_RPDSubtrAmpSum[2]
Definition: ZdcNtuple.h:272
asg::AnaToolHandle::initialize
StatusCode initialize()
initialize the tool
ZdcInjPulserAmpMap.h
ZdcNtuple::processEventInfo
void processEventInfo()
Definition: ZdcNtuple.cxx:1248
ZdcNtuple::proton_track_ySlope
std::vector< std::vector< float > > proton_track_ySlope
Definition: ZdcNtuple.h:419
ZdcNtuple::t_ZdcModuleChisqLGRefit
float t_ZdcModuleChisqLGRefit[2][4]
Definition: ZdcNtuple.h:242
ZdcNtuple::t_ZdcLucrodTriggerAmp
unsigned short t_ZdcLucrodTriggerAmp[2][4]
Definition: ZdcNtuple.h:231
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ZdcNtuple::t_trk_nSctHits
std::vector< uint8_t > t_trk_nSctHits
Definition: ZdcNtuple.h:372
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
xAOD::Vertex_v1::x
float x() const
Returns the x position.
ZdcNtuple::t_ZdcTruthParticlePosx
std::vector< float > t_ZdcTruthParticlePosx
Definition: ZdcNtuple.h:207
ZdcNtuple::t_RpdChannelPileupStretchedExpFitParamErrs
float t_RpdChannelPileupStretchedExpFitParamErrs[2][16][3]
Definition: ZdcNtuple.h:255
ZdcNtuple::t_rpdRaw
uint16_t t_rpdRaw[2][16][24]
Definition: ZdcNtuple.h:355
ZdcNtuple::t_trigger
uint64_t t_trigger
Definition: ZdcNtuple.h:169
ZdcNtuple::m_zdcInjPulserAmpMap
std::shared_ptr< ZdcInjPulserAmpMap > m_zdcInjPulserAmpMap
Definition: ZdcNtuple.h:132
et
Extra patterns decribing particle interation process.
ZdcNtuple::t_trk_ninPixHits
std::vector< uint8_t > t_trk_ninPixHits
Definition: ZdcNtuple.h:381
ZdcNtuple::t_RpdChannelPileupExpFitParamErrs
float t_RpdChannelPileupExpFitParamErrs[2][16][2]
Definition: ZdcNtuple.h:254
ZdcNtuple::t_ZdcModuleT0LGRefit
float t_ZdcModuleT0LGRefit[2][4]
Definition: ZdcNtuple.h:240
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:79
ZdcNtuple::t_T2mbts_countCin
uint16_t t_T2mbts_countCin
Definition: ZdcNtuple.h:349
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
ZdcNtuple::lhcf2022zdc
bool lhcf2022zdc
Definition: ZdcNtuple.h:86
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
ZdcNtuple::reprocZdc
bool reprocZdc
Definition: ZdcNtuple.h:82
ZdcNtuple::proton_eLoss
std::vector< double > proton_eLoss
Definition: ZdcNtuple.h:412
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
ZdcNtuple::grlFilename
std::string grlFilename
Definition: ZdcNtuple.h:58
ZdcNtuple::t_ZdcModuleCalibAmp
float t_ZdcModuleCalibAmp[2][4]
Definition: ZdcNtuple.h:224
ZdcNtuple::t_ZdcTruthParticlePid
std::vector< int > t_ZdcTruthParticlePid
Definition: ZdcNtuple.h:215
ZdcNtuple::t_RpdChannelPileupStretchedExpFitMSE
float t_RpdChannelPileupStretchedExpFitMSE[2][16]
Definition: ZdcNtuple.h:257
ZdcNtuple::enableTracks
bool enableTracks
Definition: ZdcNtuple.h:66
ZdcNtuple::t_ZdcLucrodTriggerSideAmpLG
unsigned short t_ZdcLucrodTriggerSideAmpLG[2]
Definition: ZdcNtuple.h:201
ZdcNtuple::t_mbts_timeDiff
float t_mbts_timeDiff
Definition: ZdcNtuple.h:346
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ZdcNtuple::t_RpdChannelMaxADC
float t_RpdChannelMaxADC[2][16]
Definition: ZdcNtuple.h:260
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
ZdcNtuple::t_cc_raw_eta
std::vector< float > t_cc_raw_eta
Definition: ZdcNtuple.h:394
ZdcNtuple::t_RpdChannelStatus
unsigned int t_RpdChannelStatus[2][16]
Definition: ZdcNtuple.h:263
ZdcNtuple::enableZDC
bool enableZDC
Definition: ZdcNtuple.h:89
ZdcNtuple::t_RpdChannelAmplitudeCalib
float t_RpdChannelAmplitudeCalib[2][16]
Definition: ZdcNtuple.h:259
ZdcNtuple::t_raw24
uint16_t t_raw24[2][4][2][2][24]
Definition: ZdcNtuple.h:353
ZdcNtuple::writeTrack
void writeTrack(const xAOD::TrackParticle *, const xAOD::Vertex *vertex, int)
Definition: ZdcNtuple.cxx:1537
ZdcNtuple::proton_track_xLocal
std::vector< std::vector< float > > proton_track_xLocal
Definition: ZdcNtuple.h:415
ZdcNtuple::t_nvtx
int t_nvtx
Definition: ZdcNtuple.h:300
ZdcNtuple::t_trk_nPixDead
std::vector< uint8_t > t_trk_nPixDead
Definition: ZdcNtuple.h:373
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:303
ZdcNtuple::trackQuality
int trackQuality(const xAOD::TrackParticle *tp, const xAOD::Vertex *vertex)
Definition: ZdcNtuple.cxx:1517
ZdcNtuple::m_selTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_selTool
Definition: ZdcNtuple.h:106
ZdcNtuple::t_vtx_x
std::vector< float > t_vtx_x
Definition: ZdcNtuple.h:302
ZdcNtuple::t_ZdcModuleT0SubLGRefit
float t_ZdcModuleT0SubLGRefit[2][4]
Definition: ZdcNtuple.h:241
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
ZdcNtuple::t_T2mbts_out_e
float t_T2mbts_out_e[2][4]
Definition: ZdcNtuple.h:183
ZdcNtuple::initialize
virtual StatusCode initialize() override
Definition: ZdcNtuple.cxx:94
ZdcNtuple::t_zdcEventInfoError
uint8_t t_zdcEventInfoError
Definition: ZdcNtuple.h:163
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
ZdcNtuple::t_fcalEtC_TT
float t_fcalEtC_TT
Definition: ZdcNtuple.h:316
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
ZdcNtuple::t_raw7
uint16_t t_raw7[2][4][2][2][7]
Definition: ZdcNtuple.h:351
ZdcNtuple::m_lastRunNumber
unsigned int m_lastRunNumber
Definition: ZdcNtuple.h:52
ZdcNtuple::processProtons
void processProtons()
Definition: ZdcNtuple.cxx:1892
ZdcNtuple::t_T2mbts_in_e
float t_T2mbts_in_e[2][8]
Definition: ZdcNtuple.h:182
ZdcNtuple::t_trk_nTrtOutliers
std::vector< uint8_t > t_trk_nTrtOutliers
Definition: ZdcNtuple.h:378
ZdcNtuple::t_vtx_trk_index
std::vector< std::vector< int16_t > > t_vtx_trk_index
Definition: ZdcNtuple.h:309
ZdcNtuple::t_totalEt
float t_totalEt
Definition: ZdcNtuple.h:320
ZdcNtuple::t_ZdcTruthParticlePy
std::vector< float > t_ZdcTruthParticlePy
Definition: ZdcNtuple.h:212
ZdcNtuple::proton_phi
std::vector< double > proton_phi
Definition: ZdcNtuple.h:409
ZdcNtuple::processFCal
void processFCal()
Definition: ZdcNtuple.cxx:1586
ZdcNtuple::m_grl
asg::AnaToolHandle< IGoodRunsListSelectionTool > m_grl
Definition: ZdcNtuple.h:104
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
ZdcNtuple::t_clusEt
float t_clusEt
Definition: ZdcNtuple.h:399
ZdcNtuple::t_clusphiMax
float t_clusphiMax
Definition: ZdcNtuple.h:402
ZdcNtuple::t_ZdcModuleTruthNphotons
unsigned int t_ZdcModuleTruthNphotons[2][7]
Definition: ZdcNtuple.h:249
ZdcNtuple::nsamplesZdc
size_t nsamplesZdc
Definition: ZdcNtuple.h:84
ZdcNtuple::m_setupTrigHist
bool m_setupTrigHist
Definition: ZdcNtuple.h:137
ZdcNtuple::proton_e
std::vector< double > proton_e
Definition: ZdcNtuple.h:410
xAOD::EnergySumRoI_v2::energyT
float energyT() const
The deposited total transverse energy.
ZdcNtuple::t_trk_nTrtHits
std::vector< uint8_t > t_trk_nTrtHits
Definition: ZdcNtuple.h:377
ZdcNtuple::t_trk_theta
std::vector< float > t_trk_theta
Definition: ZdcNtuple.h:363
ZdcNtuple::zdcLaser
bool zdcLaser
Definition: ZdcNtuple.h:75
ZdcNtuple::t_trk_z0
std::vector< float > t_trk_z0
Definition: ZdcNtuple.h:365
ZdcNtuple::t_fcalEtA
float t_fcalEtA
Definition: ZdcNtuple.h:313
ZdcNtuple::t_clusEtMax
float t_clusEtMax
Definition: ZdcNtuple.h:400
ZdcNtuple::t_vtx_z
std::vector< float > t_vtx_z
Definition: ZdcNtuple.h:304
xAOD::ZdcModule_v1
Class containing ZDC Module information.
Definition: ZdcModule_v1.h:25
ZdcNtuple::enableTrigger
bool enableTrigger
Definition: ZdcNtuple.h:61
asg::AnaToolHandle::setTypeAndName
void setTypeAndName(const std::string &val_typeAndName)
set the value of type and name
ZdcNtuple::t_ZdcModuleTruthInvis
float t_ZdcModuleTruthInvis[2][7]
Definition: ZdcNtuple.h:245
ZdcNtuple::t_puvxsumpt
float t_puvxsumpt
Definition: ZdcNtuple.h:294
ZdcNtuple::t_fcalEtA_TT
float t_fcalEtA_TT
Definition: ZdcNtuple.h:315
ZdcNtuple::t_ZdcModuleTruthTotal
float t_ZdcModuleTruthTotal[2][7]
Definition: ZdcNtuple.h:244
ZdcNtuple::t_fcalEt
float t_fcalEt
Definition: ZdcNtuple.h:312
ZdcNtuple::processMBTS
void processMBTS()
Definition: ZdcNtuple.cxx:1687
ZdcNtuple::t_ZdcNLEnergy
float t_ZdcNLEnergy[2]
Definition: ZdcNtuple.h:194
ZdcNtuple::processTriggerDecision
bool processTriggerDecision()
Definition: ZdcNtuple.cxx:1152
ZdcNtuple::t_trk_eta
std::vector< float > t_trk_eta
Definition: ZdcNtuple.h:360
xAOD::TrigDecision_v1::tav
const std::vector< uint32_t > & tav() const
Get the Trigger After Veto bits.
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ZdcNtuple::t_vtx_sumpt2_all
std::vector< float > t_vtx_sumpt2_all
Definition: ZdcNtuple.h:306
ANA_MSG_ERROR
#define ANA_MSG_ERROR(xmsg)
Macro printing error messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:294
ZdcNtuple::t_reactionPlaneAngle
float t_reactionPlaneAngle[2]
Definition: ZdcNtuple.h:281
ZdcNtuple::t_ZdcModulePreSampleAmp
float t_ZdcModulePreSampleAmp[2][4]
Definition: ZdcNtuple.h:230
ZdcNtuple::t_RpdChannelPileupExpFitMSE
float t_RpdChannelPileupExpFitMSE[2][16]
Definition: ZdcNtuple.h:256
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
ZdcNtuple::execute
virtual StatusCode execute() override
Definition: ZdcNtuple.cxx:527
ZdcNtuple::t_RPDChannelSubtrAmp
float t_RPDChannelSubtrAmp[2][16]
Definition: ZdcNtuple.h:271
ANA_CHECK
#define ANA_CHECK(EXP)
check whether the given expression was successful
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:324
ZdcNtuple::t_ZdcModuleMaxADCHG
float t_ZdcModuleMaxADCHG[2][4]
Definition: ZdcNtuple.h:234
ZdcNtuple::t_ZdcModulePeakADCLG
float t_ZdcModulePeakADCLG[2][4]
Definition: ZdcNtuple.h:237
ZdcNtuple::t_vxngoodmuon
int t_vxngoodmuon
Definition: ZdcNtuple.h:298
SG::ConstAccessor< char >
ZdcNtuple::t_ZdcTruthParticlePosz
std::vector< float > t_ZdcTruthParticlePosz
Definition: ZdcNtuple.h:209
ZdcNtuple::t_vtx_y
std::vector< float > t_vtx_y
Definition: ZdcNtuple.h:303
ZdcNtuple::t_raw15
uint16_t t_raw15[2][4][2][2][15]
Definition: ZdcNtuple.h:352
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
ZdcNtuple::processClusters
void processClusters()
Definition: ZdcNtuple.cxx:1810
ZdcNtuple::t_ZdcModulePeakADCHG
float t_ZdcModulePeakADCHG[2][4]
Definition: ZdcNtuple.h:236
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
ZdcNtuple::t_ZdcTruthParticlePosy
std::vector< float > t_ZdcTruthParticlePosy
Definition: ZdcNtuple.h:208
ZdcNtuple::t_decisions
bool t_decisions[200]
Definition: ZdcNtuple.h:174
ZdcNtuple::m_injMapRunToken
ZdcInjPulserAmpMap::Token m_injMapRunToken
Definition: ZdcNtuple.h:53
xAOD::EventInfo_v1::timeStampNSOffset
uint32_t timeStampNSOffset() const
Nanosecond time offset wrt. the time stamp.
ZdcNtuple::t_centroidEventValid
char t_centroidEventValid
Definition: ZdcNtuple.h:269
ZdcNtuple::zdcLowGainMode
unsigned int zdcLowGainMode
Definition: ZdcNtuple.h:78
ZdcNtuple::pbpb2023
bool pbpb2023
Definition: ZdcNtuple.h:88
ZdcNtuple::acceptEvent
uint32_t acceptEvent()
Definition: ZdcNtuple.cxx:1953
ZdcNtuple::proton_track_stationID
std::vector< std::vector< int > > proton_track_stationID
Definition: ZdcNtuple.h:414
asg::AnaToolHandle::setProperty
StatusCode setProperty(const std::string &property, const T2 &value)
set the given property of the tool.
ZdcNtuple::lhcf2022afp
bool lhcf2022afp
Definition: ZdcNtuple.h:87
ZdcNtuple::t_pvindex
int t_pvindex
Definition: ZdcNtuple.h:289
ZdcNtuple::t_timeStampNSOffset
uint32_t t_timeStampNSOffset
Definition: ZdcNtuple.h:160
ZdcNtuple::t_vxnminbias
int t_vxnminbias
Definition: ZdcNtuple.h:297
ZdcNtuple::t_trk_charge
std::vector< int8_t > t_trk_charge
Definition: ZdcNtuple.h:368
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
ZdcNtuple::enableCentroid
bool enableCentroid
Definition: ZdcNtuple.h:92
ReweightUtils.message
message
Definition: ReweightUtils.py:15
ZdcNtuple::t_ZdcModuleMaxADCLG
float t_ZdcModuleMaxADCLG[2][4]
Definition: ZdcNtuple.h:235
ZdcNtuple::t_ZdcTruthInvis
float t_ZdcTruthInvis[2]
Definition: ZdcNtuple.h:203
ZdcNtuple::nProtons
int nProtons
Definition: ZdcNtuple.h:406
xAOD::Vertex_v1::vertexType
VxType::VertexType vertexType() const
The type of the vertex.
ZdcNtuple::t_ZdcModuleAmpError
float t_ZdcModuleAmpError[2][4]
Definition: ZdcNtuple.h:226
ZdcNtuple::t_ZdcStatus
short t_ZdcStatus[2]
Definition: ZdcNtuple.h:197
ZdcNtuple::m_chainGroups
std::vector< const Trig::ChainGroup * > m_chainGroups
Definition: ZdcNtuple.h:139
ZdcNtuple::proton_t
std::vector< double > proton_t
Definition: ZdcNtuple.h:413
ZdcNtuple::t_trk_nSctHoles
std::vector< uint8_t > t_trk_nSctHoles
Definition: ZdcNtuple.h:376
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
ZdcNtuple::useGRL
bool useGRL
Definition: ZdcNtuple.h:57
asg::AnaToolHandle::declarePropertyFor
void declarePropertyFor(T2 *tool, const std::string &name, const std::string &description="")
declare as property on the given tool
ZdcNtuple::proton_side
std::vector< int > proton_side
Definition: ZdcNtuple.h:411
ZdcNtuple::zdcOnly
bool zdcOnly
Definition: ZdcNtuple.h:77
ZdcNtuple::t_ZdcModulePresample
float t_ZdcModulePresample[2][4]
Definition: ZdcNtuple.h:229
ZdcNtuple::t_ZdcTruthParticlePz
std::vector< float > t_ZdcTruthParticlePz
Definition: ZdcNtuple.h:213
ZdcNtuple::t_ZdcEnergyErr
float t_ZdcEnergyErr[2]
Definition: ZdcNtuple.h:193
ZdcNtuple::t_mbts_timeC
float t_mbts_timeC
Definition: ZdcNtuple.h:345
ZdcNtuple::enableID
bool enableID
Definition: ZdcNtuple.h:63
ZdcNtuple::proton_track_zLocal
std::vector< std::vector< float > > proton_track_zLocal
Definition: ZdcNtuple.h:417
ZdcNtuple::t_trk_vz
std::vector< float > t_trk_vz
Definition: ZdcNtuple.h:366
ZdcNtuple::t_totalEt_TTsum
float t_totalEt_TTsum
Definition: ZdcNtuple.h:321
ZdcNtuple::t_cc_raw_e
std::vector< float > t_cc_raw_e
Definition: ZdcNtuple.h:396
ZdcNtuple::t_trk_e
std::vector< float > t_trk_e
Definition: ZdcNtuple.h:362
ZdcNtuple::t_ZdcModuleCalibTime
float t_ZdcModuleCalibTime[2][4]
Definition: ZdcNtuple.h:225
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
ZdcNtuple::t_ZdcModuleBkgdMaxFraction
float t_ZdcModuleBkgdMaxFraction[2][4]
Definition: ZdcNtuple.h:227
ZdcNtuple::t_vInj
float t_vInj
Definition: ZdcNtuple.h:155
ZdcNtuple::proton_track_nClusters
std::vector< std::vector< int > > proton_track_nClusters
Definition: ZdcNtuple.h:420
ZdcNtuple.h
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ZdcNtuple::t_L1ET24
float t_L1ET24
Definition: ZdcNtuple.h:143
ZdcNtuple::t_ZdcLucrodTriggerAmpLG
unsigned short t_ZdcLucrodTriggerAmpLG[2][4]
Definition: ZdcNtuple.h:232
ZdcNtuple::t_tav
uint32_t t_tav[16]
Definition: ZdcNtuple.h:187
ZdcNtuple::t_trk_inPixHits
std::vector< uint8_t > t_trk_inPixHits
Definition: ZdcNtuple.h:379
ZdcNtuple::t_vxtype
int t_vxtype
Definition: ZdcNtuple.h:288
ZdcNtuple::t_mbts_timeA
float t_mbts_timeA
Definition: ZdcNtuple.h:344
ZdcNtuple::t_xCentroidPreAvgSubtr
float t_xCentroidPreAvgSubtr[2]
Definition: ZdcNtuple.h:275
ZdcNtuple::t_xCentroid
float t_xCentroid[2]
Definition: ZdcNtuple.h:277
ZdcNtuple::m_mbtsModules
const xAOD::MBTSModuleContainer * m_mbtsModules
Definition: ZdcNtuple.h:122
ZdcInjPulserAmpMap::Token::isValid
bool isValid() const
Definition: ZdcInjPulserAmpMap.h:48
ZdcNtuple::t_avgIntPerCrossing
float t_avgIntPerCrossing
Definition: ZdcNtuple.h:161
ZdcNtuple::t_T2mbts_in_t
float t_T2mbts_in_t[2][8]
Definition: ZdcNtuple.h:184
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ZdcNtuple::t_clusetaMax
float t_clusetaMax
Definition: ZdcNtuple.h:401
ZdcNtuple::t_yCentroidPreGeomCorPreAvgSubtr
float t_yCentroidPreGeomCorPreAvgSubtr[2]
Definition: ZdcNtuple.h:274
ZdcNtuple::enableOutputTree
bool enableOutputTree
Definition: ZdcNtuple.h:59
ZdcNtuple::t_xCentroidPreGeomCorPreAvgSubtr
float t_xCentroidPreGeomCorPreAvgSubtr[2]
Definition: ZdcNtuple.h:273
ZdcNtuple::t_cc_phi
std::vector< float > t_cc_phi
Definition: ZdcNtuple.h:389
ZdcNtuple::t_ZdcNLEnergyErr
float t_ZdcNLEnergyErr[2]
Definition: ZdcNtuple.h:195
ZdcNtuple::t_zdcDecodingError
uint8_t t_zdcDecodingError
Definition: ZdcNtuple.h:166
ZdcNtuple::t_RpdChannelPileupExpFitParams
float t_RpdChannelPileupExpFitParams[2][16][2]
Definition: ZdcNtuple.h:252
ZdcNtuple::t_rerunDecisions
bool t_rerunDecisions[200]
Definition: ZdcNtuple.h:175
ZdcNtuple::ZdcNtuple
ZdcNtuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition: ZdcNtuple.cxx:20
ZdcNtuple::writeOnlyTriggers
bool writeOnlyTriggers
Definition: ZdcNtuple.h:62
ZdcNtuple::t_trk_nexPixHits
std::vector< uint8_t > t_trk_nexPixHits
Definition: ZdcNtuple.h:382
ZdcNtuple::t_vxcov
float t_vxcov[6]
Definition: ZdcNtuple.h:290
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
ZdcNtuple::t_ZdcModuleTime
float t_ZdcModuleTime[2][4]
Definition: ZdcNtuple.h:219
ZdcNtuple::t_ZdcTime
float t_ZdcTime[2]
Definition: ZdcNtuple.h:196
ZdcEventInfo::ZDCDECODINGERROR
@ ZDCDECODINGERROR
Definition: ZdcEventInfo.h:19
lumiFormat.i
int i
Definition: lumiFormat.py:85
ZdcNtuple::t_ZdcTruthEscaped
float t_ZdcTruthEscaped[2]
Definition: ZdcNtuple.h:206
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
ZdcNtuple::t_eventNumber
uint32_t t_eventNumber
Definition: ZdcNtuple.h:152
ZdcNtuple::t_ZdcTruthTotal
float t_ZdcTruthTotal[2]
Definition: ZdcNtuple.h:202
ZdcNtuple::t_ZdcModuleFitT0
float t_ZdcModuleFitT0[2][4]
Definition: ZdcNtuple.h:221
ZdcNtuple::t_cc_raw_phi
std::vector< float > t_cc_raw_phi
Definition: ZdcNtuple.h:395
ZdcNtuple::t_ZdcLucrodTriggerSideAmp
unsigned short t_ZdcLucrodTriggerSideAmp[2]
Definition: ZdcNtuple.h:200
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
ZdcNtuple::m_eventInfo
const xAOD::EventInfo * m_eventInfo
Definition: ZdcNtuple.h:115
beamspotman.n
n
Definition: beamspotman.py:729
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ZdcNtuple::t_T2mbts_countAin
uint16_t t_T2mbts_countAin
Definition: ZdcNtuple.h:348
ZdcNtuple::t_totalEt24_TTsum
float t_totalEt24_TTsum
Definition: ZdcNtuple.h:323
ZdcNtuple::t_cc_sig
std::vector< float > t_cc_sig
Definition: ZdcNtuple.h:391
Message.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
xAOD::CaloCluster_v1::CELL_SIG_SAMPLING
@ CELL_SIG_SAMPLING
CaloSample of the cell with the largest |E|/sig.
Definition: CaloCluster_v1.h:164
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
ZdcNtuple::trackLimit
size_t trackLimit
Definition: ZdcNtuple.h:79
ZdcNtuple::t_ntrk
uint32_t t_ntrk
Definition: ZdcNtuple.h:358
ZdcNtuple::t_passBits
uint32_t t_passBits
Definition: ZdcNtuple.h:157
ANA_MSG_INFO
#define ANA_MSG_INFO(xmsg)
Macro printing info messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:290
ZdcNtuple::t_vtx_ntrk_all
std::vector< int16_t > t_vtx_ntrk_all
Definition: ZdcNtuple.h:305
ZdcNtuple::t_ZdcModuleChisq
float t_ZdcModuleChisq[2][4]
Definition: ZdcNtuple.h:222
ZdcNtuple::t_totalEt24
float t_totalEt24
Definition: ZdcNtuple.h:322
ZdcNtuple::t_rpdDecodingError
uint8_t t_rpdDecodingError
Definition: ZdcNtuple.h:167
ZdcNtuple::t_mbts_out_t
float t_mbts_out_t[2][4]
Definition: ZdcNtuple.h:180
ANA_MSG_WARNING
#define ANA_MSG_WARNING(xmsg)
Macro printing warning messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:292
ZdcNtuple::t_ZdcAmp
float t_ZdcAmp[2]
Definition: ZdcNtuple.h:190
ZdcNtuple::m_eventCounter
int m_eventCounter
Definition: ZdcNtuple.h:135
TEvent.h
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
ZdcNtuple::dR
double dR(const double eta1, const double phi1, const double eta2, const double phi2)
Definition: ZdcNtuple.cxx:2106
ZdcNtuple::t_mbts_countA
uint16_t t_mbts_countA
Definition: ZdcNtuple.h:342
xAOD::EventInfo_v1::extendedLevel1ID
uint32_t extendedLevel1ID() const
The extended Level-1 identifier.
python.BuildSignatureFlags.sig
sig
Definition: BuildSignatureFlags.py:221
ZdcNtuple::zdcInj
bool zdcInj
Definition: ZdcNtuple.h:76
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
ZdcNtuple::t_puvxz
float t_puvxz
Definition: ZdcNtuple.h:292
ZdcNtuple::t_xRowCentroid
float t_xRowCentroid[2][4]
Definition: ZdcNtuple.h:279
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ZdcNtuple::h_TCSigCut
TH1 * h_TCSigCut
Definition: ZdcNtuple.h:339
EL
This module defines the arguments passed from the BATCH driver to the BATCH worker.
Definition: AsgComponentFactories.h:16
ZdcNtuple::processMCEventCollection
void processMCEventCollection()
Definition: ZdcNtuple.cxx:1095
Init.h
ZdcNtuple::t_zdcEventInfoErrorWord
uint32_t t_zdcEventInfoErrorWord
Definition: ZdcNtuple.h:164
ZdcNtuple::p_scat
TLorentzVector p_scat
Definition: ZdcNtuple.h:423
ZdcNtuple::lhcf2022
bool lhcf2022
Definition: ZdcNtuple.h:85
ZdcNtuple::t_ZdcModuleTruthNonEM
float t_ZdcModuleTruthNonEM[2][7]
Definition: ZdcNtuple.h:247
ZdcNtuple::t_mbts_in_t
float t_mbts_in_t[2][8]
Definition: ZdcNtuple.h:179
ZdcNtuple::m_trigT2MbtsBits
const xAOD::TrigT2MbtsBitsContainer * m_trigT2MbtsBits
Definition: ZdcNtuple.h:123
ZdcNtuple::processZdcNtupleFromModules
void processZdcNtupleFromModules()
Definition: ZdcNtuple.cxx:641
ZdcNtuple::t_cc_e
std::vector< float > t_cc_e
Definition: ZdcNtuple.h:390
xAOD::Vertex_v1::z
float z() const
Returns the z position.
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
ZdcNtuple::m_mcEventCollectionName
SG::ReadHandleKey< McEventCollection > m_mcEventCollectionName
Definition: ZdcNtuple.h:113
ZdcNtuple::t_mbts_in_e
float t_mbts_in_e[2][8]
Definition: ZdcNtuple.h:177
ZdcNtuple::t_vtx_ntrk
std::vector< int16_t > t_vtx_ntrk
Definition: ZdcNtuple.h:307
ZdcNtuple::t_trk_vtxz
std::vector< float > t_trk_vtxz
Definition: ZdcNtuple.h:367
ZdcNtuple::trackLimitReject
bool trackLimitReject
Definition: ZdcNtuple.h:80
ZdcNtuple::enableRPDAmp
bool enableRPDAmp
Definition: ZdcNtuple.h:91
ZdcNtuple::t_ZdcModuleAmpLGRefit
float t_ZdcModuleAmpLGRefit[2][4]
Definition: ZdcNtuple.h:238
ZdcNtuple::t_runNumber
uint32_t t_runNumber
Definition: ZdcNtuple.h:151
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
ZdcNtuple::t_RpdModuleTruthNphotons
unsigned int t_RpdModuleTruthNphotons[2][16]
Definition: ZdcNtuple.h:266
xAOD::EventInfo_v1::ForwardDet
@ ForwardDet
The forward detectors.
Definition: EventInfo_v1.h:338
ZdcNtuple::processGaps
void processGaps()
Definition: ZdcNtuple.cxx:1652
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ZdcNtuple::m_zdcModuleContainerName
SG::ReadHandleKey< xAOD::ZdcModuleContainer > m_zdcModuleContainerName
Definition: ZdcNtuple.h:109
ZdcNtuple::t_trk_pt
std::vector< float > t_trk_pt
Definition: ZdcNtuple.h:359
ZdcNtuple::t_RpdChannelMaxADCCalib
float t_RpdChannelMaxADCCalib[2][16]
Definition: ZdcNtuple.h:261
ZdcNtuple::t_ZdcModuleMask
unsigned int t_ZdcModuleMask
Definition: ZdcNtuple.h:198
ZdcNtuple::m_trackParticles
const xAOD::TrackParticleContainer * m_trackParticles
Definition: ZdcNtuple.h:126
ZdcNtuple::m_primaryVertices
const xAOD::VertexContainer * m_primaryVertices
Definition: ZdcNtuple.h:124
grepfile.ic
int ic
Definition: grepfile.py:33
ZdcNtuple::m_afpProtons
const xAOD::AFPProtonContainer * m_afpProtons
Definition: ZdcNtuple.h:130
ZdcNtuple::t_vxnlooseprimary
int t_vxnlooseprimary
Definition: ZdcNtuple.h:296
ZdcNtuple::t_cc_raw_m
std::vector< float > t_cc_raw_m
Definition: ZdcNtuple.h:393
Trig::ChainGroup
Definition: ChainGroup.h:51
ZdcNtuple::t_ZdcAmpErr
float t_ZdcAmpErr[2]
Definition: ZdcNtuple.h:191
ZdcNtuple::t_bcid
uint32_t t_bcid
Definition: ZdcNtuple.h:154
ZdcNtuple::m_outputTree
TTree * m_outputTree
Definition: ZdcNtuple.h:150
xAOD::EventInfo_v1::averageInteractionsPerCrossing
float averageInteractionsPerCrossing() const
Average interactions per crossing for all BCIDs - for out-of-time pile-up.
Definition: EventInfo_v1.cxx:397
ZdcNtuple::t_cc_layer
std::vector< int > t_cc_layer
Definition: ZdcNtuple.h:392
ZdcNtuple::t_extendedLevel1ID
uint32_t t_extendedLevel1ID
Definition: ZdcNtuple.h:158
ZdcNtuple::t_ZdcTruthNonEM
float t_ZdcTruthNonEM[2]
Definition: ZdcNtuple.h:205
ZdcNtuple::zdcConfig
std::string zdcConfig
Definition: ZdcNtuple.h:95
ZdcNtuple::t_ZdcModuleFitAmp
float t_ZdcModuleFitAmp[2][4]
Definition: ZdcNtuple.h:220
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition: TrackingPrimitives.h:574
ZdcNtuple::t_ZdcModuleStatus
unsigned int t_ZdcModuleStatus[2][4]
Definition: ZdcNtuple.h:223
ZdcNtuple::t_edgeGapA
float t_edgeGapA
Definition: ZdcNtuple.h:326
ZdcNtuple::t_edgeGapC
float t_edgeGapC
Definition: ZdcNtuple.h:327
ZdcNtuple::t_mbts_out_e
float t_mbts_out_e[2][4]
Definition: ZdcNtuple.h:178
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
ANA_MSG_VERBOSE
#define ANA_MSG_VERBOSE(xmsg)
Macro printing verbose messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:286
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ZdcNtuple::t_timeStamp
uint32_t t_timeStamp
Definition: ZdcNtuple.h:159
xAOD::proton
@ proton
Definition: TrackingPrimitives.h:199
ZdcNtuple::t_ZdcModuleTruthEM
float t_ZdcModuleTruthEM[2][7]
Definition: ZdcNtuple.h:246
ZdcNtuple::slimmed
bool slimmed
Definition: ZdcNtuple.h:56
ZdcNtuple::t_trk_exPixHits
std::vector< uint8_t > t_trk_exPixHits
Definition: ZdcNtuple.h:380
ZdcNtuple::zdcCalib
bool zdcCalib
Definition: ZdcNtuple.h:74
ZdcNtuple::t_yCentroid
float t_yCentroid[2]
Definition: ZdcNtuple.h:278
ZdcNtuple::auxSuffix
std::string auxSuffix
Definition: ZdcNtuple.h:83
ZdcNtuple::m_trigDecision
const xAOD::TrigDecision * m_trigDecision
Definition: ZdcNtuple.h:118
ZdcNtuple::t_nvx
int t_nvx
Definition: ZdcNtuple.h:284
ZdcNtuple::t_ZdcTruthParticleStatus
std::vector< int > t_ZdcTruthParticleStatus
Definition: ZdcNtuple.h:216
ZdcNtuple::enableClusters
bool enableClusters
Definition: ZdcNtuple.h:65
ZdcNtuple::t_tbp
uint32_t t_tbp[16]
Definition: ZdcNtuple.h:188
ZdcNtuple::t_vtx_sumpt2
std::vector< float > t_vtx_sumpt2
Definition: ZdcNtuple.h:308
ZdcNtuple::p_beam
TLorentzVector p_beam
Definition: ZdcNtuple.h:422
ZdcNtuple::t_RpdSideStatus
unsigned int t_RpdSideStatus[2]
Definition: ZdcNtuple.h:265
ZdcNtuple::t_vx
float t_vx[3]
Definition: ZdcNtuple.h:285
ZdcNtuple::m_lvl1EnergySumRoI
const xAOD::EnergySumRoI * m_lvl1EnergySumRoI
Definition: ZdcNtuple.h:127
ZdcNtuple::t_bunchGroup
uint8_t t_bunchGroup
Definition: ZdcNtuple.h:156
SG::ReadHandle::ptr
const_pointer_type ptr()
Dereference the pointer.
xAOD::TrigDecision_v1::bgCode
char bgCode() const
Get the bunch group code of the current event.
ZdcNtuple::m_trigDecisionTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecisionTool
Definition: ZdcNtuple.h:103
ZdcNtuple::t_trk_nPixHits
std::vector< uint8_t > t_trk_nPixHits
Definition: ZdcNtuple.h:371
ZdcNtuple::t_ZdcTruthEM
float t_ZdcTruthEM[2]
Definition: ZdcNtuple.h:204
ZdcNtuple::t_centroidDecorationsAvailable
bool t_centroidDecorationsAvailable
Definition: ZdcNtuple.h:268
ZdcNtuple::t_ZdcModuleAmp
float t_ZdcModuleAmp[2][4]
Definition: ZdcNtuple.h:218
ZdcNtuple::t_trk_pixeldEdx
std::vector< float > t_trk_pixeldEdx
Definition: ZdcNtuple.h:383
ZdcNtuple::t_RpdChannelBaseline
float t_RpdChannelBaseline[2][16]
Definition: ZdcNtuple.h:251
xAOD::pixeldEdx
@ pixeldEdx
the dE/dx estimate, calculated using the pixel clusters [?]
Definition: TrackingPrimitives.h:305
xAOD::EventInfo_v1::eventFlags
uint32_t eventFlags(EventFlagSubDet subDet) const
Get the event flags for a particular sub-detector.
Definition: EventInfo_v1.cxx:697
xAOD::EventInfo_v1::Tile
@ Tile
The Tile calorimeter.
Definition: EventInfo_v1.h:336
ZdcNtuple::m_mbtsInfo
const xAOD::ForwardEventInfoContainer * m_mbtsInfo
Definition: ZdcNtuple.h:121
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.index
string index
Definition: DeMoScan.py:362
ZdcNtuple::t_T2mbts_out_t
float t_T2mbts_out_t[2][4]
Definition: ZdcNtuple.h:185
ZdcNtuple::t_RpdChannelAmplitude
float t_RpdChannelAmplitude[2][16]
Definition: ZdcNtuple.h:258
ZdcNtuple::flipDelay
bool flipDelay
Definition: ZdcNtuple.h:81
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ZdcNtuple::t_ZdcModuleTruthEscaped
float t_ZdcModuleTruthEscaped[2][7]
Definition: ZdcNtuple.h:248
ZdcNtuple::t_L1ET
float t_L1ET
Definition: ZdcNtuple.h:142
ZDC::IZdcAnalysisTool::reprocessZdc
virtual StatusCode reprocessZdc()=0
ZdcNtuple::m_isMC
bool m_isMC
Definition: ZdcNtuple.h:136
ZdcNtuple::enableCalo
bool enableCalo
Definition: ZdcNtuple.h:64
lumiFormat.fill
fill
Definition: lumiFormat.py:104
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
ZdcNtuple::t_vxsumpt2
float t_vxsumpt2
Definition: ZdcNtuple.h:291
ZdcNtuple::t_ZdcEnergy
float t_ZdcEnergy[2]
Definition: ZdcNtuple.h:192
ZdcNtuple::t_ZdcModuleMaxADC
float t_ZdcModuleMaxADC[2][4]
Definition: ZdcNtuple.h:233
ZdcNtuple::m_eventShapes
const xAOD::HIEventShapeContainer * m_eventShapes
Definition: ZdcNtuple.h:120
ZdcNtuple::t_yColCentroid
float t_yColCentroid[2][4]
Definition: ZdcNtuple.h:280
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TrackLeptonConfig.quality
quality
Definition: TrackLeptonConfig.py:16
ZdcNtuple::m_caloSums
const xAOD::HIEventShapeContainer * m_caloSums
Definition: ZdcNtuple.h:119
xAOD::Vertex_v1::y
float y() const
Returns the y position.
ZdcNtuple::t_ZdcTrigEff
float t_ZdcTrigEff[2]
Definition: ZdcNtuple.h:199
ZdcNtuple::t_yCentroidPreAvgSubtr
float t_yCentroidPreAvgSubtr[2]
Definition: ZdcNtuple.h:276
ZdcNtuple::t_prescales
float t_prescales[200]
Definition: ZdcNtuple.h:173
ZdcNtuple::t_RpdChannelMaxSample
unsigned int t_RpdChannelMaxSample[2][16]
Definition: ZdcNtuple.h:262
ZdcNtuple::t_cc_pt
std::vector< float > t_cc_pt
Definition: ZdcNtuple.h:387
xAOD::EventInfo_v1::errorState
EventFlagErrorState errorState(EventFlagSubDet subDet) const
Get the error state for a particular sub-detector.
Definition: EventInfo_v1.cxx:817
ZdcNtuple::proton_eta
std::vector< double > proton_eta
Definition: ZdcNtuple.h:408
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
IGoodRunsListSelectionTool::passRunLB
virtual bool passRunLB(const std::vector< std::string > &grlnameVec=std::vector< std::string >(), const std::vector< std::string > &brlnameVec=std::vector< std::string >()) const =0
Check if the current event passes the selection.
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
ZdcNtuple::m_gapPtMin
float m_gapPtMin
Definition: ZdcNtuple.h:328
ZdcNtuple::t_ZdcTruthParticleEnergy
std::vector< float > t_ZdcTruthParticleEnergy
Definition: ZdcNtuple.h:214
xAOD::EventInfo_v1::isEventFlagBitSet
bool isEventFlagBitSet(EventFlagSubDet subDet, size_t bit) const
Check one particular bit of one particular sub-detector.
Definition: EventInfo_v1.cxx:703
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
ZdcNtuple::m_zdcAnalysisTool
asg::AnaToolHandle< ZDC::IZdcAnalysisTool > m_zdcAnalysisTool
Definition: ZdcNtuple.h:105
xAOD::TrigDecision_v1::tbp
const std::vector< uint32_t > & tbp() const
Get the Trigger Before Prescale bits.
ZdcNtuple::proton_pt
std::vector< double > proton_pt
Definition: ZdcNtuple.h:407
ZdcNtuple::t_cosDeltaReactionPlaneAngle
float t_cosDeltaReactionPlaneAngle
Definition: ZdcNtuple.h:282
ZdcNtuple::t_ZdcModuleMinDeriv2nd
float t_ZdcModuleMinDeriv2nd[2][4]
Definition: ZdcNtuple.h:228
ZdcNtuple::proton_track_xSlope
std::vector< std::vector< float > > proton_track_xSlope
Definition: ZdcNtuple.h:418
ZdcNtuple::setupTriggerHistos
void setupTriggerHistos()
Definition: ZdcNtuple.cxx:1984
ZdcNtuple::t_ZdcTruthParticlePx
std::vector< float > t_ZdcTruthParticlePx
Definition: ZdcNtuple.h:211
xAOD::CaloCluster_v1::CELL_SIGNIFICANCE
@ CELL_SIGNIFICANCE
Cell significance = E/sig of the cell with the largest |E|/sig.
Definition: CaloCluster_v1.h:162
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
calibdata.copy
bool copy
Definition: calibdata.py:26
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
ZdcNtuple::t_centroidStatus
unsigned int t_centroidStatus[2]
Definition: ZdcNtuple.h:270
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
ZdcNtuple::finalize
virtual StatusCode finalize() override
Definition: ZdcNtuple.cxx:2114
ZdcNtuple::enableOutputSamples
bool enableOutputSamples
Definition: ZdcNtuple.h:60
Trig::ChainGroup::getListOfTriggers
std::vector< std::string > getListOfTriggers() const
Definition: ChainGroup.cxx:467
ZdcNtuple::m_caloClusters
const xAOD::CaloClusterContainer * m_caloClusters
Definition: ZdcNtuple.h:125
ZdcNtuple::t_vxntrk
int t_vxntrk
Definition: ZdcNtuple.h:286
ZdcNtuple::t_RpdChannelPileupStretchedExpFitParams
float t_RpdChannelPileupStretchedExpFitParams[2][16][3]
Definition: ZdcNtuple.h:253
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
ZdcNtuple::t_trk_nPixHoles
std::vector< uint8_t > t_trk_nPixHoles
Definition: ZdcNtuple.h:375
ZdcNtuple::t_trk_index
std::vector< int > t_trk_index
Definition: ZdcNtuple.h:370
ZdcNtuple::enableRPD
bool enableRPD
Definition: ZdcNtuple.h:90
ZdcNtuple::t_ZdcModuleAmpCorrLGRefit
float t_ZdcModuleAmpCorrLGRefit[2][4]
Definition: ZdcNtuple.h:239
ZdcNtuple::t_cc_raw_samp
std::vector< std::vector< float > > t_cc_raw_samp
Definition: ZdcNtuple.h:397
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
ZdcNtuple::t_fcalEtC
float t_fcalEtC
Definition: ZdcNtuple.h:314
ZdcNtuple::m_rerunChainGroups
std::vector< const Trig::ChainGroup * > m_rerunChainGroups
Definition: ZdcNtuple.h:140
ZdcNtuple::t_lumiBlock
uint32_t t_lumiBlock
Definition: ZdcNtuple.h:153
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ZdcNtuple::m_zdcSumContainerName
SG::ReadHandleKey< xAOD::ZdcModuleContainer > m_zdcSumContainerName
Definition: ZdcNtuple.h:111
ZdcNtuple::t_nstrong
int t_nstrong
Definition: ZdcNtuple.h:295
ZdcEventInfo.h
Define enumerations for event-level ZDC data.
ZdcNtuple::t_nclus
uint32_t t_nclus
Definition: ZdcNtuple.h:386
xAOD::EventInfo_v1::Core
@ Core
Core flags describing the event.
Definition: EventInfo_v1.h:339
ZdcNtuple::t_RpdChannelPileupFrac
float t_RpdChannelPileupFrac[2][16]
Definition: ZdcNtuple.h:264
ZdcNtuple::t_actIntPerCrossing
float t_actIntPerCrossing
Definition: ZdcNtuple.h:162
ZdcNtuple::t_mbts_countC
uint16_t t_mbts_countC
Definition: ZdcNtuple.h:343
ZdcNtuple::t_trigger_TBP
uint32_t t_trigger_TBP
Definition: ZdcNtuple.h:170
plot_times.times
def times(fn)
Definition: plot_times.py:10
ZdcNtuple::t_vx_trk_index
std::vector< int > t_vx_trk_index
Definition: ZdcNtuple.h:287
ZdcNtuple::t_puvxntrk
int t_puvxntrk
Definition: ZdcNtuple.h:293
AthHistogramming::tree
TTree * tree(const std::string &treeName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered TTrees.
Definition: AthHistogramming.cxx:378
ZdcNtuple::t_trk_quality
std::vector< int16_t > t_trk_quality
Definition: ZdcNtuple.h:369
ZdcNtuple::doZdcCalib
bool doZdcCalib
Definition: ZdcNtuple.h:94
xAOD::EventInfo_v1::SCT
@ SCT
The SCT.
Definition: EventInfo_v1.h:333
ZdcNtuple::t_cc_eta
std::vector< float > t_cc_eta
Definition: ZdcNtuple.h:388
ZdcNtuple::t_vtx_type
std::vector< int8_t > t_vtx_type
Definition: ZdcNtuple.h:301
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition: EventInfo_v1.cxx:380
ZdcNtuple::processInDet
void processInDet()
Definition: ZdcNtuple.cxx:1298
ZdcNtuple::t_ZdcTruthParticleTime
std::vector< float > t_ZdcTruthParticleTime
Definition: ZdcNtuple.h:210
ZdcEventInfo::RPDDECODINGERROR
@ RPDDECODINGERROR
Definition: ZdcEventInfo.h:19
ANA_MSG_DEBUG
#define ANA_MSG_DEBUG(xmsg)
Macro printing debug messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:288
ZdcNtuple::processVInjInfo
void processVInjInfo()
Definition: ZdcNtuple.cxx:1273
ZdcNtuple::t_trk_nSctDead
std::vector< uint8_t > t_trk_nSctDead
Definition: ZdcNtuple.h:374
ZdcNtuple::proton_track_yLocal
std::vector< std::vector< float > > proton_track_yLocal
Definition: ZdcNtuple.h:416
Generated on Thu Sep 4 2025 21:24:19 for ATLAS Offline Software by   doxygen 1.8.18