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