ATLAS Offline Software
DumpObjects.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 "DumpObjects.h"
6 #include "AtlasHepMC/GenEvent.h"
7 #include "AtlasHepMC/GenParticle.h"
8 #include "GeneratorObjects/xAODTruthParticleLink.h"
9 #include "InDetPrepRawData/SiCluster.h"
10 #include "InDetReadoutGeometry/SiDetectorElement.h"
11 #include "PixelReadoutGeometry/PixelDetectorManager.h"
12 #include "PixelReadoutGeometry/PixelModuleDesign.h"
13 #include "ReadoutGeometryBase/SiLocalPosition.h"
14 #include "SCT_ReadoutGeometry/SCT_ModuleSideDesign.h"
15 #include "xAODTruth/TruthVertex.h"
16 
17 #include "HepPDT/ParticleDataTable.hh"
18 
19 #include "InDetRIO_OnTrack/PixelClusterOnTrack.h"
20 #include "InDetRIO_OnTrack/SCT_ClusterOnTrack.h"
21 #include "InDetRIO_OnTrack/SiClusterOnTrack.h"
22 #include "TrkEventPrimitives/FitQuality.h"
23 #include "TrkRIO_OnTrack/RIO_OnTrack.h"
24 #include "TrkTrack/TrackInfo.h"
25 
26 #include "EventInfo/EventID.h"
27 #include "EventInfo/EventInfo.h"
28 
29 #include "GaudiKernel/ITHistSvc.h"
30 #include "TTree.h"
31 
32 #include "xAODMeasurementBase/UncalibratedMeasurement.h"
33 #include "xAODMeasurementBase/MeasurementDefs.h"
34 
35 #include <fstream>
36 
37 int InDet::compute_overlap_SP_flag(const int& eta_module_cl1,const int& phi_module_cl1,
38  const int& eta_module_cl2,const int& phi_module_cl2){
39  int flag=-999;
40 
41  if( (eta_module_cl1==eta_module_cl2) && (phi_module_cl1==phi_module_cl2) ){
42  flag=0; // not an overlap Space Point
43  }
44  else if((eta_module_cl1!=eta_module_cl2) && (phi_module_cl1==phi_module_cl2) ){
45  flag=1; // overlap Space Point in eta only
46  }
47  else if((eta_module_cl1==eta_module_cl2) && (phi_module_cl1!=phi_module_cl2) ){
48  flag=2; // overlap Space Point in phi only
49  }
50  else{
51  flag=3; // "overlap" Space Point in eta and phi (not sure we can call it overlap)
52  }
53  return flag;
54 }
55 
56 //-------------------------------------------------------------------------
57 InDet::DumpObjects::DumpObjects(const std::string &name, ISvcLocator *pSvcLocator)
58  //-------------------------------------------------------------------------
59  : AthAlgorithm(name, pSvcLocator), m_pixelID(nullptr), m_SCT_ID(nullptr), m_pixelManager(nullptr),
60  m_SCT_Manager(nullptr), m_event(0), m_selected(0), m_particlePropSvc("PartPropSvc", name),
61  m_particleDataTable(0), m_offset(0) {
62  declareProperty("Offset", m_offset);
63  declareProperty("FileName", m_name = "");
64  //
65  declareProperty("NtupleFileName", m_ntupleFileName);
66  declareProperty("NtupleDirectoryName", m_ntupleDirName);
67  declareProperty("NtupleTreeName", m_ntupleTreeName);
68  declareProperty("maxCL", m_maxCL = 1500000);
69  declareProperty("maxPart", m_maxPart = 1500000);
70  declareProperty("maxSP", m_maxSP = 1500000);
71  declareProperty("maxTRK", m_maxTRK = 1500000);
72  declareProperty("maxDTT", m_maxDTT = 1500000);
73 
74  declareProperty("rootFile", m_rootFile);
75 }
76 
77 //-------------------------------------------
78 StatusCode InDet::DumpObjects::initialize() {
79 //-------------------------------------------
80  m_event = m_offset;
81 
82  // ReadHandle keys
83  ATH_CHECK(m_eventInfoKey.initialize());
84  ATH_CHECK(m_mcEventCollectionKey.initialize());
85  ATH_CHECK(m_stripClusterKey.initialize());
86  ATH_CHECK(m_pixelClusterKey.initialize());
87  ATH_CHECK(m_pixelSDOKey.initialize());
88  ATH_CHECK(m_stripSDOKey.initialize());
89  ATH_CHECK(m_xaodPixelSpacePointContainerKey.initialize());
90  ATH_CHECK(m_xaodStripSpacePointContainerKey.initialize());
91  ATH_CHECK(m_xaodStripSpacePointOverlapContainerKey.initialize());
92 
93  ATH_CHECK(m_tracksKey.initialize());
94  ATH_CHECK(m_tracksTruthKey.initialize());
95  ATH_CHECK(m_detailedTracksTruthKey.initialize());
96 
97 
98 
99 
100  // Grab PixelID helper
101  ATH_CHECK (detStore()->retrieve(m_pixelID, "PixelID") );
102 
103  if (!detStore()->contains<InDetDD::PixelDetectorManager>("Pixel") ||
104  detStore()->retrieve(m_pixelManager, "Pixel").isFailure()) {
105  // if Pixel retrieval fails, try ITkPixel
106  if (!detStore()->contains<InDetDD::PixelDetectorManager>("ITkPixel") ||
107  detStore()->retrieve(m_pixelManager, "ITkPixel").isFailure()) {
108  return StatusCode::FAILURE;
109  }
110  }
111 
112  // Grab SCT_ID helper
113  ATH_CHECK (detStore()->retrieve(m_SCT_ID,"SCT_ID") );
114 
115  if (!detStore()->contains<InDetDD::SCT_DetectorManager>("SCT") ||
116  detStore()->retrieve(m_SCT_Manager, "SCT").isFailure()) {
117  // if SCT retrieval fails, try ITkStrip
118  if (!detStore()->contains<InDetDD::SCT_DetectorManager>("ITkStrip") ||
119  detStore()->retrieve(m_SCT_Manager, "ITkStrip").isFailure()) {
120  return StatusCode::FAILURE;
121  }
122  }
123 
124  // particle property service
125  ATH_CHECK (m_particlePropSvc.retrieve());
126 
127  // and the particle data table
128  m_particleDataTable = m_particlePropSvc->PDT();
129  if (m_particleDataTable == 0) {
130  ATH_MSG_ERROR("Could not get ParticleDataTable! Cannot associate pdg code with charge. Aborting. ");
131  return StatusCode::FAILURE;
132  }
133 
134  // Define the TTree
135  //
136  SmartIF<ITHistSvc> tHistSvc{Gaudi::svcLocator()->service("THistSvc")};
137  ATH_CHECK(tHistSvc.isValid());
138  m_nt = new TTree(TString(m_ntupleTreeName), "Athena Dump for GNN4ITk");
139  // NB: we must not delete the tree, this is done by THistSvc
140  std::string fullNtupleName = m_ntupleFileName + m_ntupleDirName + m_ntupleTreeName;
141  StatusCode sc = tHistSvc->regTree(fullNtupleName, m_nt);
142  if (sc.isFailure()) {
143  ATH_MSG_ERROR("Unable to register TTree: " << fullNtupleName);
144  return sc;
145  }
146 
147  if (m_rootFile) {
148  m_SEID = new int[m_maxCL];
149 
150  m_CLindex = new int[m_maxCL];
151  m_CLhardware = new std::vector<std::string>;
152  m_CLx = new double[m_maxCL];
153  m_CLy = new double[m_maxCL];
154  m_CLz = new double[m_maxCL];
155  m_CLbarrel_endcap = new int[m_maxCL];
156  m_CLlayer_disk = new int[m_maxCL];
157  m_CLeta_module = new int[m_maxCL];
158  m_CLphi_module = new int[m_maxCL];
159  m_CLside = new int[m_maxCL];
160  m_CLmoduleID = new uint64_t[m_maxCL];
161  m_CLparticleLink_eventIndex = new std::vector<std::vector<int>>;
162  m_CLparticleLink_barcode = new std::vector<std::vector<int>>;
163  m_CLbarcodesLinked = new std::vector<std::vector<bool>>;
164  m_CLparticle_charge = new std::vector<std::vector<float>>;
165  m_CLphis = new std::vector<std::vector<int>>;
166  m_CLetas = new std::vector<std::vector<int>>;
167  m_CLtots = new std::vector<std::vector<int>>;
168  m_CLloc_direction1 = new double[m_maxCL];
169  m_CLloc_direction2 = new double[m_maxCL];
170  m_CLloc_direction3 = new double[m_maxCL];
171  m_CLJan_loc_direction1 = new double[m_maxCL];
172  m_CLJan_loc_direction2 = new double[m_maxCL];
173  m_CLJan_loc_direction3 = new double[m_maxCL];
174  m_CLpixel_count = new int[m_maxCL];
175  m_CLcharge_count = new float[m_maxCL];
176  m_CLloc_eta = new float[m_maxCL];
177  m_CLloc_phi = new float[m_maxCL];
178  m_CLglob_eta = new float[m_maxCL];
179  m_CLglob_phi = new float[m_maxCL];
180  m_CLeta_angle = new double[m_maxCL];
181  m_CLphi_angle = new double[m_maxCL];
182  m_CLnorm_x = new float[m_maxCL];
183  m_CLnorm_y = new float[m_maxCL];
184  m_CLnorm_z = new float[m_maxCL];
185  m_CLlocal_cov = new std::vector<std::vector<double>>;
186 
187  m_Part_event_number = new int[m_maxPart];
188  m_Part_barcode = new int[m_maxPart];
189  m_Part_px = new float[m_maxPart];
190  m_Part_py = new float[m_maxPart];
191  m_Part_pz = new float[m_maxPart];
192  m_Part_pt = new float[m_maxPart];
193  m_Part_eta = new float[m_maxPart];
194  m_Part_vx = new float[m_maxPart];
195  m_Part_vy = new float[m_maxPart];
196  m_Part_vz = new float[m_maxPart];
197  m_Part_radius = new float[m_maxPart];
198  m_Part_status = new float[m_maxPart];
199  m_Part_charge = new float[m_maxPart];
200  m_Part_pdg_id = new int[m_maxPart];
201  m_Part_passed = new int[m_maxPart];
202  m_Part_vProdNin = new int[m_maxPart];
203  m_Part_vProdNout = new int[m_maxPart];
204  m_Part_vProdStatus = new int[m_maxPart];
205  m_Part_vProdBarcode = new int[m_maxPart];
206  m_Part_vParentID = new std::vector<std::vector<int>>;
207  m_Part_vParentBarcode = new std::vector<std::vector<int>>;
208 
209  m_SPindex = new int[m_maxSP];
210  m_SPx = new double[m_maxSP];
211  m_SPy = new double[m_maxSP];
212  m_SPz = new double[m_maxSP];
213  m_SPCL1_index = new int[m_maxSP];
214  m_SPCL2_index = new int[m_maxSP];
215  m_SPisOverlap = new int[m_maxSP];
216 
217  m_SPradius = new double[m_maxSP];
218  m_SPcovr = new double[m_maxSP];
219  m_SPcovz = new double[m_maxSP];
220  m_SPhl_topstrip = new float[m_maxSP];
221  m_SPhl_botstrip = new float[m_maxSP];
222  m_SPtopStripDirection = new std::vector<std::vector<float>>;
223  m_SPbottomStripDirection = new std::vector<std::vector<float>>;
224  m_SPstripCenterDistance = new std::vector<std::vector<float>>;
225  m_SPtopStripCenterPosition = new std::vector<std::vector<float>>;
226 
227  m_TRKindex = new int[m_maxTRK];
228  m_TRKtrack_fitter = new int[m_maxTRK];
229  m_TRKparticle_hypothesis = new int[m_maxTRK];
230  m_TRKproperties = new std::vector<std::vector<int>>;
231  m_TRKpattern = new std::vector<std::vector<int>>;
232  m_TRKndof = new int[m_maxTRK];
233  m_TRKmot = new int[m_maxTRK];
234  m_TRKoot = new int[m_maxTRK];
235  m_TRKchiSq = new float[m_maxTRK];
236  m_TRKmeasurementsOnTrack_pixcl_sctcl_index = new std::vector<std::vector<int>>;
237  m_TRKoutliersOnTrack_pixcl_sctcl_index = new std::vector<std::vector<int>>;
238  m_TRKcharge = new int[m_maxTRK];
239  m_TRKperigee_position = new std::vector<std::vector<double>>;
240  m_TRKperigee_momentum = new std::vector<std::vector<double>>;
241  m_TTCindex = new int[m_maxTRK];
242  m_TTCevent_index = new int[m_maxTRK];
243  m_TTCparticle_link = new int[m_maxTRK];
244  m_TTCprobability = new float[m_maxTRK];
245 
246  m_DTTindex = new int[m_maxDTT];
247  m_DTTsize = new int[m_maxDTT];
248  m_DTTtrajectory_eventindex = new std::vector<std::vector<int>>;
249  m_DTTtrajectory_barcode = new std::vector<std::vector<int>>;
250  m_DTTstTruth_subDetType = new std::vector<std::vector<int>>;
251  m_DTTstTrack_subDetType = new std::vector<std::vector<int>>;
252  m_DTTstCommon_subDetType = new std::vector<std::vector<int>>;
253 
254  m_nt->Branch("run_number", &m_run_number, "run_number/i");
255  m_nt->Branch("event_number", &m_event_number, "event_number/l");
256 
257  m_nt->Branch("nSE", &m_nSE, "nSE/I");
258  m_nt->Branch("SEID", m_SEID, "SEID[nSE]/I");
259 
260  m_nt->Branch("nCL", &m_nCL, "nCL/I");
261  m_nt->Branch("CLindex", m_CLindex, "CLindex[nCL]/I");
262  m_nt->Branch("CLhardware", &m_CLhardware);
263  m_nt->Branch("CLx", m_CLx, "CLx[nCL]/D");
264  m_nt->Branch("CLy", m_CLy, "CLy[nCL]/D");
265  m_nt->Branch("CLz", m_CLz, "CLz[nCL]/D");
266  m_nt->Branch("CLbarrel_endcap", m_CLbarrel_endcap, "CLbarrel_endcap[nCL]/I");
267  m_nt->Branch("CLlayer_disk", m_CLlayer_disk, "CLlayer_disk[nCL]/I");
268  m_nt->Branch("CLeta_module", m_CLeta_module, "CLeta_module[nCL]/I");
269  m_nt->Branch("CLphi_module", m_CLphi_module, "CLphi_module[nCL]/I");
270  m_nt->Branch("CLside", m_CLside, "CLside[nCL]/I");
271  m_nt->Branch("CLmoduleID", m_CLmoduleID, "CLmoduleID[nCL]/l");
272  m_nt->Branch("CLparticleLink_eventIndex", &m_CLparticleLink_eventIndex);
273  m_nt->Branch("CLparticleLink_barcode", &m_CLparticleLink_barcode);
274  m_nt->Branch("CLbarcodesLinked", &m_CLbarcodesLinked);
275  m_nt->Branch("CLparticle_charge", &m_CLparticle_charge);
276  m_nt->Branch("CLphis", &m_CLphis);
277  m_nt->Branch("CLetas", &m_CLetas);
278  m_nt->Branch("CLtots", &m_CLtots);
279  m_nt->Branch("CLloc_direction1", m_CLloc_direction1, "CLloc_direction1[nCL]/D");
280  m_nt->Branch("CLloc_direction2", m_CLloc_direction2, "CLloc_direction2[nCL]/D");
281  m_nt->Branch("CLloc_direction3", m_CLloc_direction3, "CLloc_direction3[nCL]/D");
282  m_nt->Branch("CLJan_loc_direction1", m_CLJan_loc_direction1, "CLJan_loc_direction1[nCL]/D");
283  m_nt->Branch("CLJan_loc_direction2", m_CLJan_loc_direction2, "CLJan_loc_direction2[nCL]/D");
284  m_nt->Branch("CLJan_loc_direction3", m_CLJan_loc_direction3, "CLJan_loc_direction3[nCL]/D");
285  m_nt->Branch("CLpixel_count", m_CLpixel_count, "CLpixel_count[nCL]/I");
286  m_nt->Branch("CLcharge_count", m_CLcharge_count, "CLcharge_count[nCL]/F");
287  m_nt->Branch("CLloc_eta", m_CLloc_eta, "CLloc_eta[nCL]/F");
288  m_nt->Branch("CLloc_phi", m_CLloc_phi, "CLloc_phi[nCL]/F");
289  m_nt->Branch("CLglob_eta", m_CLglob_eta, "CLglob_eta[nCL]/F");
290  m_nt->Branch("CLglob_phi", m_CLglob_phi, "CLglob_phi[nCL]/F");
291  m_nt->Branch("CLeta_angle", m_CLeta_angle, "CLeta_angle[nCL]/D");
292  m_nt->Branch("CLphi_angle", m_CLphi_angle, "CLphi_angle[nCL]/D");
293  m_nt->Branch("CLnorm_x", m_CLnorm_x, "CLnorm_x[nCL]/F");
294  m_nt->Branch("CLnorm_y", m_CLnorm_y, "CLnorm_y[nCL]/F");
295  m_nt->Branch("CLnorm_z", m_CLnorm_z, "CLnorm_z[nCL]/F");
296  m_nt->Branch("CLlocal_cov", &m_CLlocal_cov);
297 
298  m_nt->Branch("nPartEVT", &m_nPartEVT, "nPartEVT/I");
299  m_nt->Branch("Part_event_number", m_Part_event_number, "Part_event_number[nPartEVT]/I");
300  m_nt->Branch("Part_barcode", m_Part_barcode, "Part_barcode[nPartEVT]/I");
301  m_nt->Branch("Part_px", m_Part_px, "Part_px[nPartEVT]/F");
302  m_nt->Branch("Part_py", m_Part_py, "Part_py[nPartEVT]/F");
303  m_nt->Branch("Part_pz", m_Part_pz, "Part_pz[nPartEVT]/F");
304  m_nt->Branch("Part_pt", m_Part_pt, "Part_pt[nPartEVT]/F");
305  m_nt->Branch("Part_eta", m_Part_eta, "Part_eta[nPartEVT]/F");
306  m_nt->Branch("Part_vx", m_Part_vx, "Part_vx[nPartEVT]/F");
307  m_nt->Branch("Part_vy", m_Part_vy, "Part_vy[nPartEVT]/F");
308  m_nt->Branch("Part_vz", m_Part_vz, "Part_vz[nPartEVT]/F");
309  m_nt->Branch("Part_radius", m_Part_radius, "Part_radius[nPartEVT]/F");
310  m_nt->Branch("Part_status", m_Part_status, "Part_status[nPartEVT]/F");
311  m_nt->Branch("Part_charge", m_Part_charge, "Part_charge[nPartEVT]/F");
312  m_nt->Branch("Part_pdg_id", m_Part_pdg_id, "Part_pdg_id[nPartEVT]/I");
313  m_nt->Branch("Part_passed", m_Part_passed, "Part_passed[nPartEVT]/I");
314  m_nt->Branch("Part_vProdNin", m_Part_vProdNin, "Part_vProdNin[nPartEVT]/I");
315  m_nt->Branch("Part_vProdNout", m_Part_vProdNout, "Part_vProdNout[nPartEVT]/I");
316  m_nt->Branch("Part_vProdStatus", m_Part_vProdStatus, "Part_vProdStatus[nPartEVT]/I");
317  m_nt->Branch("Part_vProdBarcode", m_Part_vProdBarcode, "Part_vProdBarcode[nPartEVT]/I");
318  m_nt->Branch("Part_vParentID", &m_Part_vParentID);
319  m_nt->Branch("Part_vParentBarcode", &m_Part_vParentBarcode);
320 
321  m_nt->Branch("nSP", &m_nSP, "nSP/I");
322  m_nt->Branch("SPindex", m_SPindex, "SPindex[nSP]/I");
323  m_nt->Branch("SPx", m_SPx, "SPx[nSP]/D");
324  m_nt->Branch("SPy", m_SPy, "SPy[nSP]/D");
325  m_nt->Branch("SPz", m_SPz, "SPz[nSP]/D");
326  m_nt->Branch("SPCL1_index", m_SPCL1_index, "SPCL1_index[nSP]/I");
327  m_nt->Branch("SPCL2_index", m_SPCL2_index, "SPCL2_index[nSP]/I");
328  m_nt->Branch("SPisOverlap", m_SPisOverlap, "SPisOverlap[nSP]/I");
329  m_nt->Branch("SPradius",m_SPradius, "SPradius[nSP]/D");
330  m_nt->Branch("SPcovr",m_SPcovr, "SPradius[nSP]/D");
331  m_nt->Branch("SPcovz",m_SPcovz, "SPradius[nSP]/D");
332  m_nt->Branch("SPhl_topstrip",m_SPhl_topstrip, "SPhl_topstrip[nSP]/F");
333  m_nt->Branch("SPhl_botstrip",m_SPhl_botstrip, "SPhl_botstrip[nSP]/F");
334  m_nt->Branch("SPtopStripDirection",&m_SPtopStripDirection);
335  m_nt->Branch("SPbottomStripDirection",&m_SPbottomStripDirection);
336  m_nt->Branch("SPstripCenterDistance",&m_SPstripCenterDistance);
337  m_nt->Branch("SPtopStripCenterPosition",m_SPtopStripCenterPosition);
338 
339  m_nt->Branch("nTRK", &m_nTRK, "nTRK/I");
340  m_nt->Branch("TRKindex", m_TRKindex, "TRKindex[nTRK]/I");
341  m_nt->Branch("TRKtrack_fitter", m_TRKtrack_fitter, "TRKtrack_fitter[nTRK]/I");
342  m_nt->Branch("TRKparticle_hypothesis", m_TRKparticle_hypothesis, "TRKparticle_hypothesis[nTRK]/I");
343  m_nt->Branch("TRKproperties", &m_TRKproperties);
344  m_nt->Branch("TRKpattern", &m_TRKpattern);
345  m_nt->Branch("TRKndof", m_TRKndof, "TRKndof[nTRK]/I");
346  m_nt->Branch("TRKmot", m_TRKmot, "TRKmot[nTRK]/I");
347  m_nt->Branch("TRKoot", m_TRKoot, "TRKoot[nTRK]/I");
348  m_nt->Branch("TRKchiSq", m_TRKchiSq, "TRKchiSq[nTRK]/F");
349  m_nt->Branch("TRKmeasurementsOnTrack_pixcl_sctcl_index", &m_TRKmeasurementsOnTrack_pixcl_sctcl_index);
350  m_nt->Branch("TRKoutliersOnTrack_pixcl_sctcl_index", &m_TRKoutliersOnTrack_pixcl_sctcl_index);
351  m_nt->Branch("TRKcharge", m_TRKcharge, "TRKcharge[nTRK]/I");
352  m_nt->Branch("TRKperigee_position", &m_TRKperigee_position);
353  m_nt->Branch("TRKperigee_momentum", &m_TRKperigee_momentum);
354  m_nt->Branch("TTCindex", m_TTCindex, "TTCindex[nTRK]/I");
355  m_nt->Branch("TTCevent_index", m_TTCevent_index, "TTCevent_index[nTRK]/I");
356  m_nt->Branch("TTCparticle_link", m_TTCparticle_link, "TTCparticle_link[nTRK]/I");
357  m_nt->Branch("TTCprobability", m_TTCprobability, "TTCprobability[nTRK]/F");
358 
359  m_nt->Branch("nDTT", &m_nDTT, "nDTT/I");
360  m_nt->Branch("DTTindex", m_DTTindex, "DTTindex[nDTT]/I");
361  m_nt->Branch("DTTsize", m_DTTsize, "DTTsize[nDTT]/I");
362  m_nt->Branch("DTTtrajectory_eventindex", &m_DTTtrajectory_eventindex);
363  m_nt->Branch("DTTtrajectory_barcode", &m_DTTtrajectory_barcode);
364  m_nt->Branch("DTTstTruth_subDetType", &m_DTTstTruth_subDetType);
365  m_nt->Branch("DTTstTrack_subDetType", &m_DTTstTrack_subDetType);
366  m_nt->Branch("DTTstCommon_subDetType", &m_DTTstCommon_subDetType);
367  }
368 
369  return StatusCode::SUCCESS;
370 }
371 
372 //-------------------------------
373 StatusCode InDet::DumpObjects::execute() {
374  //-------------------------------
375  //
376  const EventContext &ctx = Gaudi::Hive::currentContext();
377 
378  m_event++;
379 
380  // map cluster ID to an index
381  // in order to connect the cluster to spacepoints
382  std::map<Identifier, long int> clusterIDMapIdx;
383  m_selected = 0; // global indices for clusters
384 
385  std::map<Identifier, long int> clusterIDMapSpacePointIdx; // key: cluster indentifier, value: spacepoint index
386 
387  // create a container with HepMcParticleLink and list of clusters
388  // particle barcode --> is accepted and number of clusters
389  std::map<std::pair<int, int>, std::pair<bool, int>> allTruthParticles;
390 
391  const McEventCollection *mcCollptr = nullptr;
392  SG::ReadHandle<McEventCollection> mcEventCollectionHandle{m_mcEventCollectionKey, ctx};
393  if (not mcEventCollectionHandle.isValid()) {
394  ATH_MSG_WARNING(" McEventCollection not found: " << m_mcEventCollectionKey.key());
395  return StatusCode::FAILURE;
396  }
397  mcCollptr = mcEventCollectionHandle.cptr();
398 
399  // dump out event ID
400  const xAOD::EventInfo *eventInfo = nullptr;
401  SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(m_eventInfoKey, ctx);
402  if (not eventInfoHandle.isValid()) {
403  ATH_MSG_WARNING(" EventInfo not found: " << m_eventInfoKey.key());
404  return StatusCode::FAILURE;
405  }
406  eventInfo = eventInfoHandle.cptr();
407 
408  m_run_number = eventInfo->runNumber();
409  m_event_number = eventInfo->eventNumber();
410 
411  std::map<int, int> allSubEvents;
412 
413  m_nSE = 0;
414 
415  bool duplicateSubeventID = false;
416  for (unsigned int cntr = 0; cntr < mcCollptr->size(); ++cntr) {
417  int ID = mcCollptr->at(cntr)->event_number();
418  if (m_rootFile)
419  m_SEID[m_nSE++] = ID;
420 
421  if (m_nSE == m_maxCL) {
422  ATH_MSG_WARNING("DUMP : hit max number of subevent ID");
423  break;
424  }
425  std::map<int, int>::iterator it = allSubEvents.find(ID);
426  if (it == allSubEvents.end())
427  allSubEvents.insert(std::make_pair(ID, 1));
428  else {
429  it->second++;
430  duplicateSubeventID = true;
431  }
432  }
433 
434  if (duplicateSubeventID) {
435  ATH_MSG_WARNING("Duplicate subevent ID in event " << m_event);
436  }
437 
438  m_nPartEVT = 0;
439 
440  if (m_rootFile) {
441  (*m_Part_vParentID).clear();
442  (*m_Part_vParentBarcode).clear();
443  }
444 
445  for (unsigned int cntr = 0; cntr < mcCollptr->size(); ++cntr) {
446  const HepMC::GenEvent *genEvt = (mcCollptr->at(cntr));
447 
448  // for ( HepMC::GenEvent::particle_const_iterator p = genEvt->particles_begin(); p != genEvt->particles_end(); ++p )
449  // {
450 
454 
455  for (auto p : *genEvt) {
456  //*p is a GenParticle
457  float px, py, pz, pt, eta, vx, vy, vz, radius, status, charge = 0.;
458  std::vector<int> vParentID;
459  std::vector<int> vParentBarcode;
460 
461  int vProdNin, vProdNout, vProdStatus, vProdBarcode;
462  bool passed = isPassed(p, px, py, pz, pt, eta, vx, vy, vz, radius, status, charge, vParentID, vParentBarcode,
463  vProdNin, vProdNout, vProdStatus, vProdBarcode);
464  allTruthParticles.insert(std::make_pair(std::make_pair(genEvt->event_number(), HepMC::barcode(p)),
465  std::make_pair(passed, 0))); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
466  // subevent, barcode, px, py, pz, pt, eta, vx, vy, vz, radius, status, charge
467  if (m_rootFile) {
468  m_Part_event_number[m_nPartEVT] = genEvt->event_number();
469  m_Part_barcode[m_nPartEVT] = HepMC::barcode(p); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
470  m_Part_px[m_nPartEVT] = px;
471  m_Part_py[m_nPartEVT] = py;
472  m_Part_pz[m_nPartEVT] = pz;
473  m_Part_pt[m_nPartEVT] = pt;
474  m_Part_eta[m_nPartEVT] = eta;
475  m_Part_vx[m_nPartEVT] = vx;
476  m_Part_vy[m_nPartEVT] = vy;
477  m_Part_vz[m_nPartEVT] = vz;
478  m_Part_radius[m_nPartEVT] = radius;
479  m_Part_status[m_nPartEVT] = status;
480  m_Part_charge[m_nPartEVT] = charge;
481  m_Part_pdg_id[m_nPartEVT] = p->pdg_id();
482  m_Part_passed[m_nPartEVT] = (passed ? true : false);
483  m_Part_vProdNin[m_nPartEVT] = vProdNin;
484  m_Part_vProdNout[m_nPartEVT] = vProdNout;
485  m_Part_vProdStatus[m_nPartEVT] = vProdStatus;
486  m_Part_vProdBarcode[m_nPartEVT] = vProdBarcode;
487  (*m_Part_vParentID).push_back(vParentID);
488  (*m_Part_vParentBarcode).push_back(vParentBarcode);
489  }
490 
491  m_nPartEVT++;
492  if (m_nPartEVT == m_maxPart) {
493  ATH_MSG_WARNING("DUMP : hit max number of particle events");
494  break;
495  }
496  }
497  }
498 
499  const InDet::PixelClusterContainer *PixelClusterContainer = 0;
500  SG::ReadHandle<InDet::PixelClusterContainer> pixelClusterContainerHandle{m_pixelClusterKey, ctx};
501  if (not pixelClusterContainerHandle.isValid()) {
502  ATH_MSG_WARNING(" PixelClusterContainer not found: " << m_pixelClusterKey.key());
503  return StatusCode::FAILURE;
504  }
505  PixelClusterContainer = pixelClusterContainerHandle.cptr();
506 
507  const InDet::SCT_ClusterContainer *SCT_ClusterContainer = 0;
508  SG::ReadHandle<InDet::SCT_ClusterContainer> stripClusterContainerHandle{m_stripClusterKey, ctx};
509  if (not stripClusterContainerHandle.isValid()) {
510  ATH_MSG_WARNING(" SCT_ClusterContainer not found: " << m_stripClusterKey.key());
511  return StatusCode::FAILURE;
512  }
513  SCT_ClusterContainer = stripClusterContainerHandle.cptr();
514 
515  auto cartesion_to_spherical = [](const Amg::Vector3D &xyzVec, float &eta_, float &phi_) {
516  float r3 = 0;
517  for (int idx = 0; idx < 3; ++idx) {
518  r3 += xyzVec[idx] * xyzVec[idx];
519  }
520  r3 = sqrt(r3);
521  phi_ = atan2(xyzVec[1], xyzVec[0]);
522  float theta_ = acos(xyzVec[2] / r3);
523  eta_ = log(tan(0.5 * theta_));
524  };
525 
529 
530  m_nCL = 0;
531  if (m_rootFile) {
532  (*m_CLhardware).clear();
533  (*m_CLparticleLink_eventIndex).clear();
534  (*m_CLparticleLink_barcode).clear();
535  (*m_CLbarcodesLinked).clear();
536  (*m_CLparticle_charge).clear();
537  (*m_CLphis).clear();
538  (*m_CLetas).clear();
539  (*m_CLtots).clear();
540  (*m_CLlocal_cov).clear();
541  }
542 
543  if (PixelClusterContainer->size() > 0) {
544 
545  const InDetSimDataCollection *sdoCollection = 0;
546  SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{m_pixelSDOKey, ctx};
547  if (not sdoCollectionHandle.isValid()) {
548  ATH_MSG_WARNING(" InDetSimDataCollection not found: " << m_pixelSDOKey.key());
549  return StatusCode::FAILURE;
550  }
551  sdoCollection = sdoCollectionHandle.cptr();
552 
553  for (const auto clusterCollection : *PixelClusterContainer) {
554  // skip empty collections
555  if (clusterCollection->empty())
556  continue;
557 
558  int barrel_endcap = m_pixelID->barrel_ec(clusterCollection->identify());
559  int layer_disk = m_pixelID->layer_disk(clusterCollection->identify());
560  int eta_module = m_pixelID->eta_module(clusterCollection->identify());
561  int phi_module = m_pixelID->phi_module(clusterCollection->identify());
562 
563  InDetDD::SiDetectorElement *element = m_pixelManager->getDetectorElement(clusterCollection->identify());
564 
565  Amg::Vector3D my_normal = element->normal();
566  float norm_x = fabs(my_normal.x()) > 1e-5 ? my_normal.x() : 0.;
567  float norm_y = fabs(my_normal.y()) > 1e-5 ? my_normal.y() : 0.;
568  float norm_z = fabs(my_normal.z()) > 1e-5 ? my_normal.z() : 0.;
569 
570  const InDetDD::PixelModuleDesign *design(dynamic_cast<const InDetDD::PixelModuleDesign *>(&element->design()));
571 
572  if (not design) {
573  ATH_MSG_ERROR("Dynamic cast failed at " << __LINE__ << " of MergedPixelsTool.cxx.");
574  return StatusCode::FAILURE;
575  }
576 
577  // loop over collection
578  for (const auto cluster : *clusterCollection) {
579  Identifier clusterId = cluster->identify();
580  if (!clusterId.is_valid()) {
581  ATH_MSG_WARNING("Pixel cluster identifier is not valid");
582  }
583 
584  const Amg::MatrixX &local_cov = cluster->localCovariance();
585 
586  std::vector<std::pair<int, int>> barcodes = {};
587  std::vector<int> particleLink_eventIndex = {};
588  std::vector<int> particleLink_barcode = {};
589  std::vector<bool> barcodesLinked = {};
590  std::vector<float> charge = {};
591  std::vector<int> phis = {};
592  std::vector<int> etas = {};
593  std::vector<int> tots = {};
594  int min_eta = 999;
595  int min_phi = 999;
596  int max_eta = -999;
597  int max_phi = -999;
598 
599  float charge_count = 0;
600  int pixel_count = 0;
601 
602  for (unsigned int rdo = 0; rdo < cluster->rdoList().size(); rdo++) {
603  const auto &rdoID = cluster->rdoList().at(rdo);
604  int phi = m_pixelID->phi_index(rdoID);
605  int eta = m_pixelID->eta_index(rdoID);
606  if (min_eta > eta)
607  min_eta = eta;
608  if (min_phi > phi)
609  min_phi = phi;
610  if (max_eta < eta)
611  max_eta = eta;
612  if (max_phi < phi)
613  max_phi = phi;
614 
615  ++pixel_count;
616  charge_count += cluster->totList().at(rdo);
617 
618  phis.push_back(phi);
619  etas.push_back(eta);
620  tots.push_back(cluster->totList().at(rdo));
621 
622  auto pos = sdoCollection->find(rdoID);
623  if (pos != sdoCollection->end()) {
624  for (auto deposit : pos->second.getdeposits()) {
625  const HepMcParticleLink &particleLink = deposit.first;
626  std::pair<int, int> barcode(particleLink.eventIndex(), particleLink.barcode());
627  // if (particleLink.isValid()) allTruthParticles.at(barcode).second++; // JB comment this out
628  if (std::find(barcodes.begin(), barcodes.end(), barcode) == barcodes.end()) {
629  barcodes.push_back(barcode);
630  particleLink_eventIndex.push_back(particleLink.eventIndex());
631  particleLink_barcode.push_back(particleLink.barcode());
632  charge.push_back(deposit.second);
633  barcodesLinked.push_back(particleLink.isValid());
634  }
635  }
636  }
637  }
638 
639  InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_phi, min_eta));
640  InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_phi, max_eta));
641 
642  Amg::Vector3D localStartPosition(localPos_entry.xEta() - 0.5 * element->etaPitch(),
643  localPos_entry.xPhi() - 0.5 * element->phiPitch(),
644  -0.5 * element->thickness());
645  Amg::Vector3D localEndPosition(localPos_exit.xEta() + 0.5 * element->etaPitch(),
646  localPos_exit.xPhi() + 0.5 * element->phiPitch(), 0.5 * element->thickness());
647 
648  // local direction in local coordinates
649  // clusterShape: [lx, ly, lz]
650  Amg::Vector3D localDirection = localEndPosition - localStartPosition;
651 
652  float loc_eta = 0, loc_phi = 0; // clusterShape: [leta, lphi]
653  cartesion_to_spherical(localDirection, loc_eta, loc_phi);
654 
655  Amg::Vector3D globalStartPosition = element->globalPosition(localStartPosition);
656  Amg::Vector3D globalEndPosition = element->globalPosition(localEndPosition);
657 
658  Amg::Vector3D direction = globalEndPosition - globalStartPosition;
659  float glob_eta = 0, glob_phi = 0; // clusterShape: [geta, gphi]
660  cartesion_to_spherical(direction, glob_eta, glob_phi);
661 
662  Amg::Vector3D my_phiax = element->phiAxis();
663  Amg::Vector3D my_etaax = element->etaAxis();
664 
665  float trkphicomp = direction.dot(my_phiax);
666  float trketacomp = direction.dot(my_etaax);
667  float trknormcomp = direction.dot(my_normal);
668  double phi_angle = atan2(trknormcomp, trkphicomp);
669  double eta_angle = atan2(trknormcomp, trketacomp);
670  // now dumping all the values now
671  clusterIDMapIdx[cluster->identify()] = m_selected;
672  std::vector<double> v_local_cov;
673  if (local_cov.size() > 0) {
674  for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
675  for (size_t j = 0; j < nCols; ++j) {
676  v_local_cov.push_back(local_cov(i, j));
677  }
678  }
679  }
680  if (m_rootFile) {
681  // fill TTree
682  m_CLindex[m_nCL] = m_selected;
683  (*m_CLhardware).push_back("PIXEL");
684  m_CLx[m_nCL] = cluster->globalPosition().x();
685  m_CLy[m_nCL] = cluster->globalPosition().y();
686  m_CLz[m_nCL] = cluster->globalPosition().z();
687  m_CLbarrel_endcap[m_nCL] = barrel_endcap;
688  m_CLlayer_disk[m_nCL] = layer_disk;
689  m_CLeta_module[m_nCL] = eta_module;
690  m_CLphi_module[m_nCL] = phi_module;
691  m_CLside[m_nCL] = 0;
692  m_CLmoduleID[m_nCL] = clusterCollection->identify().get_compact();
693  (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
694  (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
695  (*m_CLbarcodesLinked).push_back(barcodesLinked);
696  (*m_CLparticle_charge).push_back(charge);
697  (*m_CLetas).push_back(etas);
698  (*m_CLphis).push_back(phis);
699  (*m_CLtots).push_back(tots);
700  m_CLloc_direction1[m_nCL] = localDirection[0];
701  m_CLloc_direction2[m_nCL] = localDirection[1];
702  m_CLloc_direction3[m_nCL] = localDirection[2];
703  m_CLJan_loc_direction1[m_nCL] = 0;
704  m_CLJan_loc_direction2[m_nCL] = 0;
705  m_CLJan_loc_direction3[m_nCL] = 0;
706  m_CLpixel_count[m_nCL] = pixel_count;
707  m_CLcharge_count[m_nCL] = charge_count;
708  m_CLloc_eta[m_nCL] = loc_eta;
709  m_CLloc_phi[m_nCL] = loc_phi;
710  m_CLglob_eta[m_nCL] = glob_eta;
711  m_CLglob_phi[m_nCL] = glob_phi;
712  m_CLeta_angle[m_nCL] = eta_angle;
713  m_CLphi_angle[m_nCL] = phi_angle;
714  m_CLnorm_x[m_nCL] = norm_x;
715  m_CLnorm_y[m_nCL] = norm_y;
716  m_CLnorm_z[m_nCL] = norm_z;
717  (*m_CLlocal_cov).push_back(v_local_cov);
718  }
719  m_nCL++;
720  m_selected++;
721  if (m_nCL == m_maxCL) {
722  ATH_MSG_WARNING("DUMP : hit max number of clusters");
723  break;
724  }
725  }
726  }
727  }
728 
732 
733  if (SCT_ClusterContainer->size() > 0) {
734  const InDetSimDataCollection *sdoCollection = 0;
735  SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{m_stripSDOKey, ctx};
736  if (not sdoCollectionHandle.isValid()) {
737  ATH_MSG_WARNING(" InDetSimDataCollection not found: " << m_stripSDOKey.key());
738  return StatusCode::FAILURE;
739  }
740  sdoCollection = sdoCollectionHandle.cptr();
741 
742  for (const auto clusterCollection : *SCT_ClusterContainer) {
743  // skip empty collections
744  if (clusterCollection->empty())
745  continue;
746 
747  int barrel_endcap = m_SCT_ID->barrel_ec(clusterCollection->identify());
748  int layer_disk = m_SCT_ID->layer_disk(clusterCollection->identify());
749  int eta_module = m_SCT_ID->eta_module(clusterCollection->identify());
750  int phi_module = m_SCT_ID->phi_module(clusterCollection->identify());
751  int side = m_SCT_ID->side(clusterCollection->identify());
752 
753  InDetDD::SiDetectorElement *element = m_SCT_Manager->getDetectorElement(clusterCollection->identify());
754 
755  Amg::Vector3D my_normal = element->normal();
756  float norm_x = fabs(my_normal.x()) > 1e-5 ? my_normal.x() : 0.;
757  float norm_y = fabs(my_normal.y()) > 1e-5 ? my_normal.y() : 0.;
758  float norm_z = fabs(my_normal.z()) > 1e-5 ? my_normal.z() : 0.;
759 
760  // loop over collection
761  for (const auto cluster : *clusterCollection) {
762  Identifier clusterId = cluster->identify();
763  if (!clusterId.is_valid()) {
764  ATH_MSG_WARNING("SCT cluster identifier is not valid");
765  }
766 
767  const Amg::MatrixX &local_cov = cluster->localCovariance();
768 
769  std::vector<std::pair<int, int>> barcodes = {};
770  std::vector<int> particleLink_eventIndex = {};
771  std::vector<int> particleLink_barcode = {};
772  std::vector<bool> barcodesLinked = {};
773  std::vector<float> charge = {};
774 
775  std::vector<int> tots = {};
776  std::vector<int> strip_ids = {};
777  int min_strip = 999;
778  int max_strip = -999;
779 
780  float charge_count = 0;
781  int pixel_count = 0;
782 
783  for (unsigned int rdo = 0; rdo < cluster->rdoList().size(); rdo++) {
784  const auto &rdoID = cluster->rdoList().at(rdo);
785 
786  int strip = m_SCT_ID->strip(rdoID);
787 
788  if (min_strip > strip)
789  min_strip = strip;
790  if (max_strip < strip)
791  max_strip = strip;
792  strip_ids.push_back(strip);
793  // tots.push_back(cluster->totList().at(rdo));
794  tots.push_back(0); // FIXME
795  ++pixel_count;
796  // find barcodes of the truth particles
797  auto pos = sdoCollection->find(rdoID);
798  if (pos != sdoCollection->end()) {
799  for (auto deposit : pos->second.getdeposits()) {
800  const HepMcParticleLink &particleLink = deposit.first;
801  std::pair<int, int> barcode(particleLink.eventIndex(), particleLink.barcode());
802  // note that we are not filling the map allTruthParticles here - OK, we are not using this map for
803  // anything
804  if (std::find(barcodes.begin(), barcodes.end(), barcode) == barcodes.end()) {
805  barcodes.push_back(barcode);
806  particleLink_eventIndex.push_back(particleLink.eventIndex());
807  particleLink_barcode.push_back(particleLink.barcode());
808  charge.push_back(deposit.second);
809  barcodesLinked.push_back(particleLink.isValid());
810  }
811  }
812  }
813  }
814 
815  // retrieve cluster shape
816  const InDetDD::SCT_ModuleSideDesign *design(
817  dynamic_cast<const InDetDD::SCT_ModuleSideDesign *>(&element->design()));
818  if (not design) {
819  ATH_MSG_ERROR("Failed at " << __LINE__ << " of accessing SCT ModuleSide Design");
820  return StatusCode::FAILURE;
821  }
822 
823  Amg::Vector2D locpos = cluster->localPosition();
824  std::pair<Amg::Vector3D, Amg::Vector3D> ends(
825  element->endsOfStrip(InDetDD::SiLocalPosition(locpos.y(), locpos.x(), 0)));
826 
827  Amg::Vector3D JanDirection = ends.second - ends.first;
828 
829  InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_strip));
830  InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_strip));
831 
832  Amg::Vector3D localStartPosition(localPos_entry.xEta() - 0.5 * element->etaPitch(),
833  localPos_entry.xPhi() - 0.5 * element->phiPitch(),
834  -0.5 * element->thickness());
835  Amg::Vector3D localEndPosition(localPos_exit.xEta() + 0.5 * element->etaPitch(),
836  localPos_exit.xPhi() + 0.5 * element->phiPitch(), 0.5 * element->thickness());
837 
838  Amg::Vector3D localDirection = localEndPosition - localStartPosition;
839  float loc_eta = 0, loc_phi = 0; // clusterShape: [leta, lphi]
840  cartesion_to_spherical(localDirection, loc_eta, loc_phi);
841 
842  Amg::Vector3D globalStartPosition = element->globalPosition(localStartPosition);
843  Amg::Vector3D globalEndPosition = element->globalPosition(localEndPosition);
844 
845  Amg::Vector3D direction = globalEndPosition - globalStartPosition;
846  float glob_eta = 0, glob_phi = 0; // clusterShape: [geta, gphi]
847  cartesion_to_spherical(direction, glob_eta, glob_phi);
848 
849  Amg::Vector3D my_phiax = element->phiAxis();
850  Amg::Vector3D my_etaax = element->etaAxis();
851 
852  float trkphicomp = direction.dot(my_phiax);
853  float trketacomp = direction.dot(my_etaax);
854  float trknormcomp = direction.dot(my_normal);
855  double phi_angle = atan2(trknormcomp, trkphicomp);
856  double eta_angle = atan2(trknormcomp, trketacomp);
857 
858  // now dumping all the values now
859  clusterIDMapIdx[cluster->identify()] = m_selected;
860  // cluster shape
861  std::vector<int> cst;
862  for (unsigned strip = 0; strip < strip_ids.size(); strip++) {
863  cst.push_back(-1);
864  }
865  std::vector<double> v_local_cov;
866  if (local_cov.size() > 0) {
867  for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
868  for (size_t j = 0; j < nCols; ++j) {
869  v_local_cov.push_back(local_cov(i, j));
870  }
871  }
872  }
873  if (m_rootFile) {
874  m_CLindex[m_nCL] = m_selected;
875  (*m_CLhardware).push_back("STRIP");
876  m_CLx[m_nCL] = cluster->globalPosition().x();
877  m_CLy[m_nCL] = cluster->globalPosition().y();
878  m_CLz[m_nCL] = cluster->globalPosition().z();
879  m_CLbarrel_endcap[m_nCL] = barrel_endcap;
880  m_CLlayer_disk[m_nCL] = layer_disk;
881  m_CLeta_module[m_nCL] = eta_module;
882  m_CLphi_module[m_nCL] = phi_module;
883  m_CLside[m_nCL] = side;
884  m_CLmoduleID[m_nCL] = clusterCollection->identify().get_compact();
885  (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
886  (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
887  (*m_CLbarcodesLinked).push_back(barcodesLinked);
888  (*m_CLparticle_charge).push_back(charge);
889  (*m_CLetas).push_back(strip_ids);
890  (*m_CLphis).push_back(cst);
891  (*m_CLtots).push_back(tots);
892  m_CLloc_direction1[m_nCL] = localDirection[0];
893  m_CLloc_direction2[m_nCL] = localDirection[1];
894  m_CLloc_direction3[m_nCL] = localDirection[2];
895  m_CLJan_loc_direction1[m_nCL] = JanDirection[0];
896  m_CLJan_loc_direction2[m_nCL] = JanDirection[1];
897  m_CLJan_loc_direction3[m_nCL] = JanDirection[2];
898  m_CLpixel_count[m_nCL] = pixel_count;
899  m_CLcharge_count[m_nCL] = charge_count;
900  m_CLloc_eta[m_nCL] = loc_eta;
901  m_CLloc_phi[m_nCL] = loc_phi;
902  m_CLglob_eta[m_nCL] = glob_eta;
903  m_CLglob_phi[m_nCL] = glob_phi;
904  m_CLeta_angle[m_nCL] = eta_angle;
905  m_CLphi_angle[m_nCL] = phi_angle;
906  m_CLnorm_x[m_nCL] = norm_x;
907  m_CLnorm_y[m_nCL] = norm_y;
908  m_CLnorm_z[m_nCL] = norm_z;
909  (*m_CLlocal_cov).push_back(v_local_cov);
910  }
911 
912  m_nCL++;
913  m_selected++;
914  if (m_nCL == m_maxCL) {
915  ATH_MSG_WARNING("DUMP : hit max number of clusters");
916  break;
917  }
918  }
919  }
920  }
921 
922 
926 
927  static const SG::Accessor< ElementLink<SpacePointCollection> > linkAcc("pixelSpacePointLink");
928  static const SG::Accessor< ElementLink< ::SpacePointCollection > > striplinkAcc("sctSpacePointLink");
929  static const SG::Accessor< ElementLink< ::SpacePointOverlapCollection > > stripOverlaplinkAcc("stripOverlapSpacePointLink");
930 
931  // xAOD Containers
932  const xAOD::SpacePointContainer *xAODPixelSPContainer = nullptr;
933 
934  SG::ReadHandle<xAOD::SpacePointContainer> xAODPixelSpacePointContainerHandle{m_xaodPixelSpacePointContainerKey,ctx};
935 
936  if (not xAODPixelSpacePointContainerHandle.isValid()) {
937  ATH_MSG_ERROR(" SpacePointContainer not found: " << m_xaodPixelSpacePointContainerKey.key());
938  return StatusCode::FAILURE;
939  }
940 
941  xAODPixelSPContainer = xAODPixelSpacePointContainerHandle.cptr();
942 
943 
944  const xAOD::SpacePointContainer *xAODStripSPContainer = 0;
945  SG::ReadHandle<xAOD::SpacePointContainer> xAODStripSpacePointContainerHandle{m_xaodStripSpacePointContainerKey, ctx};
946  if (not xAODStripSpacePointContainerHandle.isValid()) {
947  ATH_MSG_ERROR(" SpacePointContainer not found: " << m_xaodStripSpacePointContainerKey.key());
948  return StatusCode::FAILURE;
949  }
950  xAODStripSPContainer = xAODStripSpacePointContainerHandle.cptr();
951 
952 
953  const xAOD::SpacePointContainer *xAODStripSPOverlapContainer = 0;
954  SG::ReadHandle<xAOD::SpacePointContainer> xAODStripSpacePointOverlapContainerHandle{m_xaodStripSpacePointOverlapContainerKey, ctx};
955  if (not xAODStripSpacePointOverlapContainerHandle.isValid()) {
956  ATH_MSG_ERROR(" SpacePointContainer not found: " << m_xaodStripSpacePointOverlapContainerKey.key());
957  return StatusCode::FAILURE;
958  }
959  xAODStripSPOverlapContainer = xAODStripSpacePointOverlapContainerHandle.cptr();
960 
961  int sp_index = 0;
962  m_nSP = 0;
963 
964  if (xAODPixelSPContainer && xAODPixelSPContainer->size() > 0) {
965  for (const auto sp : *xAODPixelSPContainer) {
966 
967  if (not linkAcc.isAvailable(*sp))
968  ATH_MSG_FATAL("no pixel SpacePoint link for xAOD::SpacePoint");
969 
970 
971  auto trk_sp = *linkAcc(*sp);
972  const InDet::SiCluster *cl = static_cast<const InDet::SiCluster*>(trk_sp->clusterList().first);
973 
974  if (m_rootFile) {
975  m_SPindex[m_nSP] = sp_index;
976  m_SPx[m_nSP] = sp->globalPosition().x();
977  m_SPy[m_nSP] = sp->globalPosition().y();
978  m_SPz[m_nSP] = sp->globalPosition().z();
979  m_SPradius[m_nSP] = sp->radius();
980  m_SPcovr[m_nSP] = sp->varianceR();
981  m_SPcovz[m_nSP] = sp->varianceZ();
982  m_SPCL1_index[m_nSP] = clusterIDMapIdx[cl->identify()];
983  m_SPCL2_index[m_nSP] = -1;
984  m_SPisOverlap[m_nSP] = -1;
985  }
986 
987  sp_index++;
988  m_nSP++;
989  if (m_nSP == m_maxSP) {
990  ATH_MSG_WARNING("DUMP : hit max number of space points");
991  break;
992  }
993  } // loop on container
994  } // container not empty
995 
996  if (xAODStripSPContainer && xAODStripSPContainer->size() > 0) {
997 
998  //loop over collection
999  for (const auto sp : *xAODStripSPContainer) {
1000 
1001  ATH_CHECK(striplinkAcc.isAvailable(*sp));
1002 
1003  auto trk_sp = *striplinkAcc(*sp);
1004  const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1005  const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1006 
1007  if (m_rootFile) {
1008 
1009  m_SPindex[m_nSP] = sp_index;
1010  m_SPx[m_nSP] = sp->globalPosition().x();
1011  m_SPy[m_nSP] = sp->globalPosition().y();
1012  m_SPz[m_nSP] = sp->globalPosition().z();
1013  m_SPradius[m_nSP] = sp->radius();
1014  m_SPcovr[m_nSP] = sp->varianceR();
1015  m_SPcovz[m_nSP] = sp->varianceZ();
1016  m_SPCL1_index[m_nSP] = clusterIDMapIdx[cl_1->identify()];
1017  m_SPCL2_index[m_nSP] = clusterIDMapIdx[cl_2->identify()];
1018  m_SPisOverlap[m_nSP] = 0;
1019  m_SPhl_topstrip[m_nSP] = sp->topHalfStripLength();
1020  m_SPhl_botstrip[m_nSP] = sp->bottomHalfStripLength();
1021 
1022 
1023  std::vector<float> topstripDir(sp->topStripDirection().data(),
1024  sp->topStripDirection().data() +
1025  sp->topStripDirection().size());
1026 
1027  std::vector<float> botstripDir(sp->bottomStripDirection().data(),
1028  sp->bottomStripDirection().data() +
1029  sp->bottomStripDirection().size());
1030 
1031  std::vector<float> DstripCnt(sp->stripCenterDistance().data(),
1032  sp->stripCenterDistance().data() +
1033  sp->stripCenterDistance().size());
1034 
1035  std::vector<float> topstripCnt(sp->topStripCenter().data(),
1036  sp->topStripCenter().data() +
1037  sp->topStripCenter().size());
1038 
1039  (*m_SPtopStripDirection).push_back(topstripDir);
1040  (*m_SPbottomStripDirection).push_back(botstripDir);
1041  (*m_SPstripCenterDistance).push_back(DstripCnt);
1042  (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1043 
1044  }
1045 
1046  sp_index++;
1047  m_nSP++;
1048 
1049  if (m_nSP == m_maxSP) {
1050  ATH_MSG_WARNING("DUMP : hit max number of space points");
1051  break;
1052  }
1053  }
1054  }
1055 
1056 
1057  if (xAODStripSPOverlapContainer && xAODStripSPOverlapContainer->size() > 0) {
1058 
1059  //loop over collection
1060  for (const auto sp : *xAODStripSPOverlapContainer) {
1061 
1062  ATH_CHECK(stripOverlaplinkAcc.isAvailable(*sp));
1063 
1064  auto trk_sp = *stripOverlaplinkAcc(*sp);
1065  const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1066  const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1067 
1068  if (m_rootFile) {
1069 
1070  m_SPindex[m_nSP] = sp_index;
1071  m_SPx[m_nSP] = sp->globalPosition().x();
1072  m_SPy[m_nSP] = sp->globalPosition().y();
1073  m_SPz[m_nSP] = sp->globalPosition().z();
1074  m_SPradius[m_nSP] = sp->radius();
1075  m_SPcovr[m_nSP] = sp->varianceR();
1076  m_SPcovz[m_nSP] = sp->varianceZ();
1077  m_SPCL1_index[m_nSP] = clusterIDMapIdx[cl_1->identify()];
1078  m_SPCL2_index[m_nSP] = clusterIDMapIdx[cl_2->identify()];
1079 
1080  int flag = compute_overlap_SP_flag(m_CLeta_module[clusterIDMapIdx[cl_1->identify()]],
1081  m_CLphi_module[clusterIDMapIdx[cl_1->identify()]],
1082  m_CLeta_module[clusterIDMapIdx[cl_2->identify()]],
1083  m_CLphi_module[clusterIDMapIdx[cl_2->identify()]]);
1084 
1085  if ( flag<1 || flag > 2 )
1086  ATH_MSG_WARNING("Unexpected overlap SP flag: "<<flag);
1087 
1088 
1089  m_SPisOverlap[m_nSP] = flag;
1090  m_SPhl_topstrip[m_nSP] = sp->topHalfStripLength();
1091  m_SPhl_botstrip[m_nSP] = sp->bottomHalfStripLength();
1092 
1093 
1094  std::vector<float> topstripDir(sp->topStripDirection().data(),
1095  sp->topStripDirection().data() +
1096  sp->topStripDirection().size());
1097 
1098  std::vector<float> botstripDir(sp->bottomStripDirection().data(),
1099  sp->bottomStripDirection().data() +
1100  sp->bottomStripDirection().size());
1101 
1102  std::vector<float> DstripCnt(sp->stripCenterDistance().data(),
1103  sp->stripCenterDistance().data() +
1104  sp->stripCenterDistance().size());
1105 
1106  std::vector<float> topstripCnt(sp->topStripCenter().data(),
1107  sp->topStripCenter().data() +
1108  sp->topStripCenter().size());
1109 
1110  (*m_SPtopStripDirection).push_back(topstripDir);
1111  (*m_SPbottomStripDirection).push_back(botstripDir);
1112  (*m_SPstripCenterDistance).push_back(DstripCnt);
1113  (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1114 
1115  }
1116 
1117  sp_index++;
1118  m_nSP++;
1119  if (m_nSP == m_maxSP) {
1120  ATH_MSG_WARNING("DUMP : hit max number of space points");
1121  break;
1122  }
1123  } // loop on container
1124  } // container not empty
1125 
1126 
1130 
1131  const TrackCollection *trackCollection = 0;
1132  SG::ReadHandle<TrackCollection> trackCollectionHandle{m_tracksKey, ctx};
1133  if (not trackCollectionHandle.isValid()) {
1134  ATH_MSG_WARNING(" TrackCollection not found: " << m_tracksKey.key());
1135  return StatusCode::FAILURE;
1136  }
1137  trackCollection = trackCollectionHandle.cptr();
1138 
1139  const TrackTruthCollection *trackTruthCollection = 0;
1140  SG::ReadHandle<TrackTruthCollection> trackTruthCollectionHandle{m_tracksTruthKey, ctx};
1141  if (not trackTruthCollectionHandle.isValid()) {
1142  ATH_MSG_WARNING(" TrackTruthCollection not found: " << m_tracksTruthKey.key());
1143  return StatusCode::FAILURE;
1144  }
1145  trackTruthCollection = trackTruthCollectionHandle.cptr();
1146 
1147  int trk_index = 0;
1148 
1149  // loop over tracks (and track truth) objects
1150  TrackCollection::const_iterator trackIterator = (*trackCollection).begin();
1151  m_nTRK = 0;
1152  if (m_rootFile) {
1153  (*m_TRKproperties).clear();
1154  (*m_TRKpattern).clear();
1155  (*m_TRKperigee_position).clear();
1156  (*m_TRKperigee_momentum).clear();
1157  (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).clear();
1158  (*m_TRKoutliersOnTrack_pixcl_sctcl_index).clear();
1159  }
1160 
1161  for (; trackIterator < (*trackCollection).end(); ++trackIterator) {
1162  if (!((*trackIterator))) {
1163  ATH_MSG_WARNING("TrackCollection contains empty entries");
1164  continue;
1165  }
1166  const Trk::TrackInfo &info = (*trackIterator)->info();
1167  const Trk::FitQuality *fitQuality = (*trackIterator)->fitQuality();
1168  const Trk::Perigee *perigeeParameters = (*trackIterator)->perigeeParameters();
1169  const DataVector<const Trk::MeasurementBase> *measurementsOnTrack = (*trackIterator)->measurementsOnTrack();
1170  const DataVector<const Trk::MeasurementBase> *outliersOnTrack = (*trackIterator)->outliersOnTrack();
1171 
1172  ElementLink<TrackCollection> tracklink;
1173  tracklink.setElement(const_cast<Trk::Track *>(*trackIterator));
1174  tracklink.setStorableObject(*trackCollection);
1175  const ElementLink<TrackCollection> tracklink2 = tracklink;
1176  TrackTruthCollection::const_iterator found = trackTruthCollection->find(tracklink2);
1177 
1178  const std::bitset<Trk::TrackInfo::NumberOfTrackProperties> &properties = info.properties();
1179  std::vector<int> v_properties;
1180  for (std::size_t i = 0; i < properties.size(); i++) {
1181  if (properties[i]) {
1182  v_properties.push_back(i);
1183  }
1184  }
1185 
1186  const std::bitset<Trk::TrackInfo::NumberOfTrackRecoInfo> &pattern = info.patternRecognition();
1187  std::vector<int> v_pattern;
1188  for (std::size_t i = 0; i < pattern.size(); i++) {
1189  if (pattern[i]) {
1190  v_pattern.push_back(i);
1191  }
1192  }
1193 
1194  int ndof = -1;
1195  float chiSq = 0;
1196  if (fitQuality) {
1197  ndof = fitQuality->numberDoF();
1198  chiSq = fitQuality->chiSquared();
1199  }
1200  std::vector<double> position, momentum;
1201  int charge = 0;
1202  if (perigeeParameters) {
1203  position.push_back(perigeeParameters->position()[0]);
1204  position.push_back(perigeeParameters->position()[1]);
1205  position.push_back(perigeeParameters->position()[2]);
1206  momentum.push_back(perigeeParameters->momentum()[0]);
1207  momentum.push_back(perigeeParameters->momentum()[1]);
1208  momentum.push_back(perigeeParameters->momentum()[2]);
1209  charge = perigeeParameters->charge();
1210  } else {
1211  position.push_back(0);
1212  position.push_back(0);
1213  position.push_back(0);
1214  momentum.push_back(0);
1215  momentum.push_back(0);
1216  momentum.push_back(0);
1217  }
1218  int mot = 0;
1219  int oot = 0;
1220  if (measurementsOnTrack)
1221  mot = measurementsOnTrack->size();
1222  if (outliersOnTrack)
1223  oot = outliersOnTrack->size();
1224  std::vector<int> measurementsOnTrack_pixcl_sctcl_index, outliersOnTrack_pixcl_sctcl_index;
1225  int TTCindex, TTCevent_index, TTCparticle_link;
1226  float TTCprobability;
1227  if (measurementsOnTrack) {
1228  for (size_t i = 0; i < measurementsOnTrack->size(); i++) {
1229  const Trk::MeasurementBase *mb = (*measurementsOnTrack)[i];
1230  const InDet::PixelClusterOnTrack *pixcl = dynamic_cast<const InDet::PixelClusterOnTrack *>(mb);
1231  const InDet::SCT_ClusterOnTrack *sctcl = dynamic_cast<const InDet::SCT_ClusterOnTrack *>(mb);
1232  if (pixcl) {
1233  measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->prepRawData()->identify()]);
1234  }
1235  else if (sctcl) {
1236  measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->prepRawData()->identify()]);
1237  } else {
1238  measurementsOnTrack_pixcl_sctcl_index.push_back(-1);
1239  }
1240  }
1241  }
1242  if (outliersOnTrack) {
1243  for (size_t i = 0; i < outliersOnTrack->size(); i++) {
1244  const Trk::MeasurementBase *mb = (*outliersOnTrack)[i];
1245  const InDet::PixelClusterOnTrack *pixcl = dynamic_cast<const InDet::PixelClusterOnTrack *>(mb);
1246  const InDet::SCT_ClusterOnTrack *sctcl = dynamic_cast<const InDet::SCT_ClusterOnTrack *>(mb);
1247  if (pixcl) {
1248  outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->prepRawData()->identify()]);
1249  } else if (sctcl) {
1250  outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->prepRawData()->identify()]);
1251  } else {
1252  outliersOnTrack_pixcl_sctcl_index.push_back(-1);
1253  }
1254  }
1255  }
1256  if (found != trackTruthCollection->end()) {
1257  TTCindex = found->first.index();
1258  TTCevent_index = found->second.particleLink().eventIndex();
1259  TTCparticle_link = found->second.particleLink().barcode();
1260  TTCprobability = found->second.probability();
1261  } else {
1262  TTCindex = TTCevent_index = TTCparticle_link = -999;
1263  TTCprobability = -1;
1264  }
1265 
1266  if (m_rootFile) {
1267  m_TRKindex[m_nTRK] = trk_index;
1268  m_TRKtrack_fitter[m_nTRK] = info.trackFitter();
1269  m_TRKndof[m_nTRK] = info.trackFitter();
1270  m_TRKparticle_hypothesis[m_nTRK] = info.particleHypothesis();
1271  (*m_TRKproperties).push_back(v_properties);
1272  (*m_TRKpattern).push_back(v_pattern);
1273  m_TRKndof[m_nTRK] = ndof;
1274  m_TRKchiSq[m_nTRK] = chiSq;
1275  (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).push_back(measurementsOnTrack_pixcl_sctcl_index);
1276  (*m_TRKoutliersOnTrack_pixcl_sctcl_index).push_back(outliersOnTrack_pixcl_sctcl_index);
1277  m_TRKcharge[m_nTRK] = charge;
1278  (*m_TRKperigee_position).push_back(position);
1279  (*m_TRKperigee_momentum).push_back(momentum);
1280  m_TRKmot[m_nTRK] = mot;
1281  m_TRKoot[m_nTRK] = oot;
1282  m_TTCindex[m_nTRK] = TTCindex;
1283  m_TTCevent_index[m_nTRK] = TTCevent_index;
1284  m_TTCparticle_link[m_nTRK] = TTCparticle_link;
1285  m_TTCprobability[m_nTRK] = TTCprobability;
1286  }
1287 
1288  trk_index++;
1289  // index
1290  m_nTRK++;
1291  if (m_nTRK == m_maxTRK) {
1292  ATH_MSG_WARNING("DUMP : hit max number of track events");
1293  break;
1294  }
1295  }
1296 
1297  const DetailedTrackTruthCollection *detailedTrackTruthCollection = 0;
1298  SG::ReadHandle<DetailedTrackTruthCollection> detailedTrackTruthCollectionHandle{m_detailedTracksTruthKey, ctx};
1299  if (not detailedTrackTruthCollectionHandle.isValid()) {
1300  ATH_MSG_WARNING(" DetailedTrackTruthCollection not found: " << m_detailedTracksTruthKey.key());
1301  return StatusCode::FAILURE;
1302  }
1303  detailedTrackTruthCollection = detailedTrackTruthCollectionHandle.cptr();
1304 
1305  m_nDTT = 0;
1306  if (m_rootFile) {
1307  (*m_DTTtrajectory_eventindex).clear();
1308  (*m_DTTtrajectory_barcode).clear();
1309  (*m_DTTstTruth_subDetType).clear();
1310  (*m_DTTstTrack_subDetType).clear();
1311  (*m_DTTstCommon_subDetType).clear();
1312  }
1313 
1314  // loop over DetailedTrackTruth objects
1315  DetailedTrackTruthCollection::const_iterator detailedTrackTruthIterator = (*detailedTrackTruthCollection).begin();
1316  for (; detailedTrackTruthIterator != (*detailedTrackTruthCollection).end(); ++detailedTrackTruthIterator) {
1317  std::vector<int> DTTtrajectory_eventindex, DTTtrajectory_barcode, DTTstTruth_subDetType, DTTstTrack_subDetType,
1318  DTTstCommon_subDetType;
1319  const TruthTrajectory &traj = detailedTrackTruthIterator->second.trajectory();
1320  for (size_t j = 0; j < traj.size(); j++) {
1321  DTTtrajectory_eventindex.push_back(traj[j].eventIndex());
1322  DTTtrajectory_barcode.push_back(traj[j].barcode());
1323  }
1324  const SubDetHitStatistics &stTruth = detailedTrackTruthIterator->second.statsTruth();
1325  const SubDetHitStatistics &stTrack = detailedTrackTruthIterator->second.statsTrack();
1326  const SubDetHitStatistics &stCommon = detailedTrackTruthIterator->second.statsCommon();
1327  for (unsigned j = 0; j < SubDetHitStatistics::NUM_SUBDETECTORS; j++) {
1328  DTTstTruth_subDetType.push_back(stTruth[SubDetHitStatistics::SubDetType(j)]);
1329  }
1330  for (unsigned j = 0; j < SubDetHitStatistics::NUM_SUBDETECTORS; j++) {
1331  DTTstTrack_subDetType.push_back(stTrack[SubDetHitStatistics::SubDetType(j)]);
1332  }
1333  for (unsigned j = 0; j < SubDetHitStatistics::NUM_SUBDETECTORS; j++) {
1334  DTTstCommon_subDetType.push_back(stCommon[SubDetHitStatistics::SubDetType(j)]);
1335  }
1336 
1337  if (m_rootFile) {
1338  m_DTTindex[m_nDTT] = detailedTrackTruthIterator->first.index();
1339  m_DTTsize[m_nDTT] = traj.size();
1340  (*m_DTTtrajectory_eventindex).push_back(DTTtrajectory_eventindex);
1341  (*m_DTTtrajectory_barcode).push_back(DTTtrajectory_barcode);
1342  (*m_DTTstTruth_subDetType).push_back(DTTstTruth_subDetType);
1343  (*m_DTTstTrack_subDetType).push_back(DTTstTrack_subDetType);
1344  (*m_DTTstCommon_subDetType).push_back(DTTstCommon_subDetType);
1345  }
1346 
1347  m_nDTT++;
1348  }
1349 
1350  // Once all the information for this event has been filled in the arrays,
1351  // copy content of the arrays to the TTree
1352  if (m_rootFile)
1353  m_nt->Fill();
1354 
1355  return StatusCode::SUCCESS;
1356 }
1357 
1358 //--------------------------------
1359 StatusCode InDet::DumpObjects::finalize() {
1360  //--------------------------------
1361  if (m_rootFile) {
1362  delete[] m_SEID;
1363 
1364  delete[] m_CLindex;
1365  delete m_CLhardware;
1366  delete[] m_CLx;
1367  delete[] m_CLy;
1368  delete[] m_CLz;
1369  delete[] m_CLbarrel_endcap;
1370  delete[] m_CLlayer_disk;
1371  delete[] m_CLeta_module;
1372  delete[] m_CLphi_module;
1373  delete[] m_CLside;
1374  delete[] m_CLmoduleID;
1375  delete m_CLparticleLink_eventIndex;
1376  delete m_CLparticleLink_barcode;
1377  delete m_CLbarcodesLinked;
1378  delete m_CLparticle_charge;
1379  delete m_CLphis;
1380  delete m_CLetas;
1381  delete m_CLtots;
1382  delete[] m_CLloc_direction1;
1383  delete[] m_CLloc_direction2;
1384  delete[] m_CLloc_direction3;
1385  delete[] m_CLJan_loc_direction1;
1386  delete[] m_CLJan_loc_direction2;
1387  delete[] m_CLJan_loc_direction3;
1388  delete[] m_CLpixel_count;
1389  delete[] m_CLcharge_count;
1390  delete[] m_CLloc_eta;
1391  delete[] m_CLloc_phi;
1392  delete[] m_CLglob_eta;
1393  delete[] m_CLglob_phi;
1394  delete[] m_CLeta_angle;
1395  delete[] m_CLphi_angle;
1396  delete[] m_CLnorm_x;
1397  delete[] m_CLnorm_y;
1398  delete[] m_CLnorm_z;
1399  delete m_CLlocal_cov;
1400 
1401  delete[] m_Part_event_number;
1402  delete[] m_Part_barcode;
1403  delete[] m_Part_px;
1404  delete[] m_Part_py;
1405  delete[] m_Part_pz;
1406  delete[] m_Part_pt;
1407  delete[] m_Part_eta;
1408  delete[] m_Part_vx;
1409  delete[] m_Part_vy;
1410  delete[] m_Part_vz;
1411  delete[] m_Part_radius;
1412  delete[] m_Part_status;
1413  delete[] m_Part_charge;
1414  delete[] m_Part_pdg_id;
1415  delete[] m_Part_passed;
1416 
1417  delete[] m_Part_vProdNin;
1418  delete[] m_Part_vProdNout;
1419  delete[] m_Part_vProdStatus;
1420  delete[] m_Part_vProdBarcode;
1421  delete m_Part_vParentID;
1422  delete m_Part_vParentBarcode;
1423 
1424  delete[] m_SPindex;
1425  delete[] m_SPx;
1426  delete[] m_SPy;
1427  delete[] m_SPz;
1428  delete[] m_SPCL1_index;
1429  delete[] m_SPCL2_index;
1430  delete[] m_SPisOverlap;
1431  delete[] m_SPradius;
1432  delete[] m_SPcovr;
1433  delete[] m_SPcovz;
1434  delete[] m_SPhl_topstrip;
1435  delete[] m_SPhl_botstrip;
1436  delete m_SPtopStripDirection;
1437  delete m_SPbottomStripDirection;
1438  delete m_SPstripCenterDistance;
1439  delete m_SPtopStripCenterPosition;
1440 
1441  delete[] m_TRKindex;
1442  delete[] m_TRKtrack_fitter;
1443  delete[] m_TRKparticle_hypothesis;
1444  delete m_TRKproperties;
1445  delete m_TRKpattern;
1446  delete[] m_TRKndof;
1447  delete[] m_TRKmot;
1448  delete[] m_TRKoot;
1449  delete[] m_TRKchiSq;
1450  delete m_TRKmeasurementsOnTrack_pixcl_sctcl_index;
1451  delete m_TRKoutliersOnTrack_pixcl_sctcl_index;
1452  delete[] m_TRKcharge;
1453  delete m_TRKperigee_position;
1454  delete m_TRKperigee_momentum;
1455  delete[] m_TTCindex;
1456  delete[] m_TTCevent_index;
1457  delete[] m_TTCparticle_link;
1458  delete[] m_TTCprobability;
1459 
1460  delete[] m_DTTindex;
1461  delete[] m_DTTsize;
1462  delete m_DTTtrajectory_eventindex;
1463  delete m_DTTtrajectory_barcode;
1464  delete m_DTTstTruth_subDetType;
1465  delete m_DTTstTrack_subDetType;
1466  delete m_DTTstCommon_subDetType;
1467  }
1468 
1469  return StatusCode::SUCCESS;
1470 }
1471 
1472 //--------------------------------------------------------------------------------------------
1473 bool InDet::DumpObjects::isPassed(HepMC::ConstGenParticlePtr particle, float &px, float &py, float &pz,
1474  float &pt, float &eta, float &vx, float &vy, float &vz, float &radius, float &status,
1475  float &charge, std::vector<int> &vParentID, std::vector<int> &vParentBarcode,
1476  int &vProdNin, int &vProdNout, int &vProdStatus, int &vProdBarcode) {
1477  //--------------------------------------------------------------------------------------------
1478 
1479  px = particle->momentum().px();
1480  py = particle->momentum().py();
1481  pz = particle->momentum().pz();
1482 
1483  pt = std::sqrt(px * px + py * py);
1484  eta = particle->momentum().eta();
1485 
1486  int pdgCode = particle->pdg_id();
1487 
1488  int absPdgCode = std::abs(pdgCode);
1489  // get the charge: ap->charge() is used later, DOES NOT WORK RIGHT NOW
1490  const HepPDT::ParticleData *ap = m_particleDataTable->particle(absPdgCode);
1491  charge = 1.;
1492  if (ap)
1493  charge = ap->charge();
1494  // since the PDT table only has abs(PID) values for the charge
1495  charge *= (pdgCode > 0.) ? 1. : -1.;
1496 
1497  status = particle->status();
1498 
1499  if (particle->production_vertex()) {
1500  vx = particle->production_vertex()->position().x();
1501  vy = particle->production_vertex()->position().y();
1502  vz = particle->production_vertex()->position().z();
1503  radius = particle->production_vertex()->position().perp();
1504  } else {
1505  vx = vy = vz = -1;
1506  radius = 999;
1507  if (status == 1)
1508  ATH_MSG_WARNING("no vertex for particle with status 1");
1509  }
1510 
1511  if (particle->production_vertex()) {
1512  vProdNin = particle->production_vertex()->particles_in_size();
1513  vProdNout = particle->production_vertex()->particles_out_size();
1514  vProdStatus = particle->production_vertex()->id();
1515  vProdBarcode = HepMC::barcode(particle->production_vertex()); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
1516 #ifdef HEPMC3
1517  for (const auto &p : particle->production_vertex()->particles_in()) {
1518  vParentID.push_back(p->pdg_id());
1519  vParentBarcode.push_back(HepMC::barcode(p)); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
1520  }
1521 #else
1522  for (auto ip = particle->production_vertex()->particles_in_const_begin();
1523  ip != particle->production_vertex()->particles_in_const_end();
1524  ++ip)
1525  {
1526  vParentID.push_back((*ip)->pdg_id());
1527  vParentBarcode.push_back(HepMC::barcode(*ip)); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
1528  }
1529 #endif
1530  } else {
1531  vProdNin = 0;
1532  vProdNout = 0;
1533  vProdStatus = -999;
1534  vProdBarcode = 999;
1535  }
1536 
1537  bool passEta = (pt > 0.1) ? (std::abs(eta) < m_max_eta) : false;
1538  if (not passEta)
1539  return false;
1540 
1541  bool passPt = (pt > m_min_pt);
1542  if (not passPt)
1543  return false;
1544 
1545  bool passBarcode = (HepMC::barcode(particle) < m_max_barcode); // JB: HEPMC3 barcode() -> HepMC::barcode(p)
1546  if (not passBarcode)
1547  return false;
1548 
1549  bool passCharge = not(charge == 0.);
1550  if (not passCharge)
1551  return false;
1552 
1553  bool passStatus = (status == 1);
1554  if (not passStatus)
1555  return false;
1556 
1557  bool passProdRadius = (radius < m_maxProdVertex);
1558  if (not passProdRadius)
1559  return false;
1560 
1561  return true;
1562 }
grepfile.info
info
Definition: grepfile.py:38
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
InDet::DumpObjects::m_nPartEVT
int m_nPartEVT
Definition: DumpObjects.h:153
InDet::DumpObjects::m_TRKperigee_momentum
std::vector< std::vector< double > > * m_TRKperigee_momentum
Definition: DumpObjects.h:195
InDet::DumpObjects::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition: DumpObjects.h:70
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
InDet::DumpObjects::m_CLnorm_z
float * m_CLnorm_z
Definition: DumpObjects.h:150
DumpObjects.h
InDet::DumpObjects::m_CLeta_angle
double * m_CLeta_angle
Definition: DumpObjects.h:149
IDTPM::ndof
float ndof(const U &p)
Definition: TrackParametersHelper.h:134
UncalibratedMeasurement.h
SCT_ClusterOnTrack.h
InDet::DumpObjects::m_SPtopStripCenterPosition
std::vector< std::vector< float > > * m_SPtopStripCenterPosition
Definition: DumpObjects.h:185
InDet::DumpObjects::execute
virtual StatusCode execute() override final
Definition: DumpObjects.cxx:373
SubDetHitStatistics::SubDetType
SubDetType
Definition: SubDetHitStatistics.h:74
Trk::TrackInfo
Contains information about the 'fitter' of this track.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/TrackInfo.h:32
InDet::DumpObjects::m_CLtots
std::vector< std::vector< int > > * m_CLtots
Definition: DumpObjects.h:142
InDet::DumpObjects::m_TRKchiSq
float * m_TRKchiSq
Definition: DumpObjects.h:192
InDet::DumpObjects::m_TRKoot
int * m_TRKoot
Definition: DumpObjects.h:191
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
PixelID::phi_index
int phi_index(const Identifier &id) const
Definition: PixelID.h:658
GenEvent.h
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
InDet::DumpObjects::m_Part_vProdNin
int * m_Part_vProdNin
Definition: DumpObjects.h:165
test_pyathena.px
px
Definition: test_pyathena.py:18
InDet::DumpObjects::m_maxDTT
int m_maxDTT
Definition: DumpObjects.h:116
perigeeParameters
Definition: ExtrapolatorComparisonTest.h:42
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
python.TestDriveDummies.properties
dictionary properties
Definition: TestDriveDummies.py:14
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
InDetDD::PixelModuleDesign
Definition: PixelModuleDesign.h:48
InDet::DumpObjects::m_CLside
int * m_CLside
Definition: DumpObjects.h:136
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
InDet::DumpObjects::m_TRKproperties
std::vector< std::vector< int > > * m_TRKproperties
Definition: DumpObjects.h:190
InDet::DumpObjects::m_CLloc_direction2
double * m_CLloc_direction2
Definition: DumpObjects.h:143
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
InDet::DumpObjects::m_nt
TTree * m_nt
Definition: DumpObjects.h:118
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
SCT_ModuleSideDesign.h
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle< McEventCollection >
InDet::DumpObjects::m_pixelSDOKey
SG::ReadHandleKey< InDetSimDataCollection > m_pixelSDOKey
Definition: DumpObjects.h:85
InDetDD::SCT_ModuleSideDesign
Definition: SCT_ModuleSideDesign.h:40
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
InDet::DumpObjects::m_CLnorm_x
float * m_CLnorm_x
Definition: DumpObjects.h:150
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
SubDetHitStatistics::NUM_SUBDETECTORS
@ NUM_SUBDETECTORS
Definition: SubDetHitStatistics.h:74
InDet::DumpObjects::m_SPradius
double * m_SPradius
Definition: DumpObjects.h:174
SubDetHitStatistics
Definition: SubDetHitStatistics.h:34
InDet::DumpObjects::m_nCL
int m_nCL
Definition: DumpObjects.h:126
InDet::DumpObjects::m_Part_eta
float * m_Part_eta
Definition: DumpObjects.h:158
InDet::DumpObjects::m_CLloc_direction1
double * m_CLloc_direction1
Definition: DumpObjects.h:143
InDetDD::SolidStateDetectorElementBase::etaAxis
const Amg::Vector3D & etaAxis() const
Definition: SolidStateDetectorElementBase.cxx:88
InDet::DumpObjects::m_Part_vz
float * m_Part_vz
Definition: DumpObjects.h:159
skel.it
it
Definition: skel.GENtoEVGEN.py:396
InDet::DumpObjects::m_Part_pt
float * m_Part_pt
Definition: DumpObjects.h:157
test_pyathena.pt
pt
Definition: test_pyathena.py:11
InDet::DumpObjects::m_DTTindex
int * m_DTTindex
Definition: DumpObjects.h:200
InDet::DumpObjects::m_xaodStripSpacePointOverlapContainerKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodStripSpacePointOverlapContainerKey
Definition: DumpObjects.h:92
InDet::SCT_ClusterContainer
Trk::PrepRawDataContainer< SCT_ClusterCollection > SCT_ClusterContainer
Definition: SCT_ClusterContainer.h:27
InDet::DumpObjects::m_CLbarrel_endcap
int * m_CLbarrel_endcap
Definition: DumpObjects.h:132
InDetSimDataCollection
Definition: InDetSimDataCollection.h:25
InDet::DumpObjects::m_CLparticleLink_eventIndex
std::vector< std::vector< int > > * m_CLparticleLink_eventIndex
Definition: DumpObjects.h:138
InDet::DumpObjects::m_CLy
double * m_CLy
Definition: DumpObjects.h:130
InDet::DumpObjects::m_DTTtrajectory_eventindex
std::vector< std::vector< int > > * m_DTTtrajectory_eventindex
Definition: DumpObjects.h:201
InDet::DumpObjects::m_SCT_ID
const SCT_ID * m_SCT_ID
Definition: DumpObjects.h:69
InDet::DumpObjects::m_CLlocal_cov
std::vector< std::vector< double > > * m_CLlocal_cov
Definition: DumpObjects.h:151
SiClusterOnTrack.h
InDet::SCT_ClusterOnTrack::prepRawData
virtual const InDet::SCT_Cluster * prepRawData() const override final
returns the PrepRawData - is a SCT_Cluster in this scope
Definition: SCT_ClusterOnTrack.h:145
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
InDet::DumpObjects::m_SPindex
int * m_SPindex
Definition: DumpObjects.h:169
InDet::DumpObjects::m_min_pt
float m_min_pt
Definition: DumpObjects.h:103
InDet::PixelClusterContainer
Trk::PrepRawDataContainer< PixelClusterCollection > PixelClusterContainer
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelClusterContainer.h:28
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
InDet::DumpObjects::m_offset
int m_offset
Definition: DumpObjects.h:99
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
InDet::DumpObjects::m_SCT_Manager
const InDetDD::SCT_DetectorManager * m_SCT_Manager
Definition: DumpObjects.h:71
InDet::DumpObjects::m_CLcharge_count
float * m_CLcharge_count
Definition: DumpObjects.h:146
InDet::DumpObjects::m_SPCL1_index
int * m_SPCL1_index
Definition: DumpObjects.h:171
InDet::DumpObjects::m_Part_passed
int * m_Part_passed
Definition: DumpObjects.h:164
InDet::DumpObjects::m_CLetas
std::vector< std::vector< int > > * m_CLetas
Definition: DumpObjects.h:142
InDetDD::SCT_DetectorManager::getDetectorElement
virtual SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements via Identifier
Definition: SCT_DetectorManager.cxx:64
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
InDet::DumpObjects::m_Part_vProdNout
int * m_Part_vProdNout
Definition: DumpObjects.h:165
InDetDD::SolidStateDetectorElementBase::etaPitch
double etaPitch() const
Pitch (inline methods)
python.AtlRunQueryParser.ap
ap
Definition: AtlRunQueryParser.py:826
InDet::DumpObjects::m_Part_status
float * m_Part_status
Definition: DumpObjects.h:161
GenParticle.h
InDet::DumpObjects::m_Part_event_number
int * m_Part_event_number
Definition: DumpObjects.h:154
InDet::DumpObjects::m_CLJan_loc_direction3
double * m_CLJan_loc_direction3
Definition: DumpObjects.h:144
InDet::DumpObjects::m_TTCparticle_link
int * m_TTCparticle_link
Definition: DumpObjects.h:196
InDet::DumpObjects::m_TTCprobability
float * m_TTCprobability
Definition: DumpObjects.h:197
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
InDet::DumpObjects::isPassed
bool isPassed(HepMC::ConstGenParticlePtr particle, float &px, float &py, float &pz, float &pt, float &eta, float &vx, float &vy, float &vz, float &radius, float &status, float &charge, std::vector< int > &vParentID, std::vector< int > &vParentBarcode, int &vProdNin, int &vProdNout, int &vProdStatus, int &vProdBarcode)
Definition: DumpObjects.cxx:1473
InDet::DumpObjects::m_SPcovz
double * m_SPcovz
Definition: DumpObjects.h:176
InDet::DumpObjects::m_maxProdVertex
float m_maxProdVertex
Definition: DumpObjects.h:105
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
InDet::DumpObjects::m_xaodStripSpacePointContainerKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodStripSpacePointContainerKey
Definition: DumpObjects.h:90
InDet::DumpObjects::m_TRKperigee_position
std::vector< std::vector< double > > * m_TRKperigee_position
Definition: DumpObjects.h:195
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
InDet::DumpObjects::m_run_number
unsigned int m_run_number
Definition: DumpObjects.h:120
InDet::DumpObjects::m_rootFile
bool m_rootFile
jobOption: save data in root format
Definition: DumpObjects.h:117
TRT::Hit::side
@ side
Definition: HitInfo.h:83
InDet::DumpObjects::m_CLbarcodesLinked
std::vector< std::vector< bool > > * m_CLbarcodesLinked
Definition: DumpObjects.h:140
InDet::DumpObjects::m_SPbottomStripDirection
std::vector< std::vector< float > > * m_SPbottomStripDirection
Definition: DumpObjects.h:183
InDetDD::SiLocalPosition
Definition: SiLocalPosition.h:31
InDet::DumpObjects::m_CLparticle_charge
std::vector< std::vector< float > > * m_CLparticle_charge
Definition: DumpObjects.h:141
InDet::DumpObjects::m_selected
int m_selected
Definition: DumpObjects.h:73
InDetDD::SiLocalPosition::xPhi
double xPhi() const
position along phi direction:
Definition: SiLocalPosition.h:123
InDet::DumpObjects::m_DTTstTrack_subDetType
std::vector< std::vector< int > > * m_DTTstTrack_subDetType
Definition: DumpObjects.h:202
InDet::DumpObjects::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: DumpObjects.h:79
InDet::DumpObjects::m_name
std::string m_name
Definition: DumpObjects.h:76
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
InDet::DumpObjects::m_CLhardware
std::vector< std::string > * m_CLhardware
Definition: DumpObjects.h:128
InDetDD::SiDetectorElement::phiPitch
double phiPitch() const
Pitch (inline methods)
EventID.h
This class provides a unique identification for each event, in terms of run/event number and/or a tim...
InDet::DumpObjects::m_DTTtrajectory_barcode
std::vector< std::vector< int > > * m_DTTtrajectory_barcode
Definition: DumpObjects.h:201
TrackTruthCollection
Definition: TrackTruthCollection.h:21
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
InDet::DumpObjects::m_tracksKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
Definition: DumpObjects.h:94
PixelDetectorManager.h
InDet::DumpObjects::m_SPtopStripDirection
std::vector< std::vector< float > > * m_SPtopStripDirection
Definition: DumpObjects.h:182
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
InDet::DumpObjects::m_CLloc_eta
float * m_CLloc_eta
Definition: DumpObjects.h:147
InDet::DumpObjects::m_CLphis
std::vector< std::vector< int > > * m_CLphis
Definition: DumpObjects.h:142
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
InDet::DumpObjects::m_Part_vParentID
std::vector< std::vector< int > > * m_Part_vParentID
Definition: DumpObjects.h:166
python.Dumpers.barcodes
def barcodes(beg, end, sz)
Definition: Dumpers.py:2800
lumiFormat.i
int i
Definition: lumiFormat.py:85
InDet::DumpObjects::m_ntupleTreeName
std::string m_ntupleTreeName
jobOption: Ntuple tree name
Definition: DumpObjects.h:111
InDetDD::SolidStateDetectorElementBase::thickness
double thickness() const
InDetDD::SiLocalPosition::xEta
double xEta() const
position along eta direction:
Definition: SiLocalPosition.h:118
perigeeParameters::perigeeParameters
perigeeParameters(double d0, double z0, double phi, double eta, double pt, double charge)
Definition: ExtrapolatorComparisonTest.h:49
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
InDet::DumpObjects::m_pixelID
const PixelID * m_pixelID
Definition: DumpObjects.h:68
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
InDet::DumpObjects::m_TTCevent_index
int * m_TTCevent_index
Definition: DumpObjects.h:196
InDet::DumpObjects::m_Part_radius
float * m_Part_radius
Definition: DumpObjects.h:160
master.flag
bool flag
Definition: master.py:29
InDet::DumpObjects::m_CLeta_module
int * m_CLeta_module
Definition: DumpObjects.h:134
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
InDet::DumpObjects::m_SPy
double * m_SPy
Definition: DumpObjects.h:170
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
PixelID::eta_index
int eta_index(const Identifier &id) const
Definition: PixelID.h:664
InDet::DumpObjects::m_CLphi_angle
double * m_CLphi_angle
Definition: DumpObjects.h:149
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDet::DumpObjects::m_TRKndof
int * m_TRKndof
Definition: DumpObjects.h:191
InDet::DumpObjects::m_Part_vy
float * m_Part_vy
Definition: DumpObjects.h:159
InDet::DumpObjects::m_ntupleDirName
std::string m_ntupleDirName
jobOption: Ntuple directory name
Definition: DumpObjects.h:110
InDet::DumpObjects::m_SPstripCenterDistance
std::vector< std::vector< float > > * m_SPstripCenterDistance
Definition: DumpObjects.h:184
InDet::DumpObjects::m_SPhl_topstrip
float * m_SPhl_topstrip
Definition: DumpObjects.h:178
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
InDet::DumpObjects::m_Part_vx
float * m_Part_vx
Definition: DumpObjects.h:159
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
InDet::DumpObjects::m_DTTsize
int * m_DTTsize
Definition: DumpObjects.h:200
InDet::DumpObjects::m_Part_charge
float * m_Part_charge
Definition: DumpObjects.h:162
InDet::DumpObjects::m_CLglob_phi
float * m_CLglob_phi
Definition: DumpObjects.h:148
Trk::FitQualityOnSurface::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
InDet::DumpObjects::m_nDTT
int m_nDTT
Definition: DumpObjects.h:199
InDet::DumpObjects::m_Part_barcode
int * m_Part_barcode
Definition: DumpObjects.h:155
MeasurementDefs.h
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
SiLocalPosition.h
module_driven_slicing.max_eta
max_eta
Definition: module_driven_slicing.py:166
InDetDD::SolidStateDetectorElementBase::normal
virtual const Amg::Vector3D & normal() const override final
Get reconstruction local normal axes in global frame.
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TruthVertex.h
RPDUtils::nCols
unsigned constexpr int nCols
Definition: RPDUtils.h:25
InDet::DumpObjects::m_SPx
double * m_SPx
Definition: DumpObjects.h:170
InDet::DumpObjects::m_TRKparticle_hypothesis
int * m_TRKparticle_hypothesis
Definition: DumpObjects.h:189
Trk::MeasurementBase
Definition: MeasurementBase.h:58
InDet::DumpObjects::m_CLglob_eta
float * m_CLglob_eta
Definition: DumpObjects.h:148
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
InDet::DumpObjects::m_event_number
unsigned long long m_event_number
Definition: DumpObjects.h:121
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
InDetDD::SiDetectorElement::endsOfStrip
std::pair< Amg::Vector3D, Amg::Vector3D > endsOfStrip(const Amg::Vector2D &position) const
Special method for SCT to retrieve the two ends of a "strip" Returned coordinates are in global frame...
Definition: SiDetectorElement.cxx:339
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition: GenParticle.h:38
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:651
TruthTrajectory
Definition: TruthTrajectory.h:26
Amg::py
@ py
Definition: GeoPrimitives.h:39
InDet::DumpObjects::m_CLmoduleID
uint64_t * m_CLmoduleID
Definition: DumpObjects.h:137
InDet::DumpObjects::m_SPisOverlap
int * m_SPisOverlap
Definition: DumpObjects.h:172
InDet::DumpObjects::m_Part_py
float * m_Part_py
Definition: DumpObjects.h:156
InDet::DumpObjects::m_maxPart
int m_maxPart
jobOption: maximum number of particles
Definition: DumpObjects.h:113
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TrackInfo.h
RIO_OnTrack.h
InDet::DumpObjects::m_SPhl_botstrip
float * m_SPhl_botstrip
Definition: DumpObjects.h:180
InDet::DumpObjects::m_TRKmeasurementsOnTrack_pixcl_sctcl_index
std::vector< std::vector< int > > * m_TRKmeasurementsOnTrack_pixcl_sctcl_index
Definition: DumpObjects.h:193
InDet::DumpObjects::m_CLindex
int * m_CLindex
Definition: DumpObjects.h:127
charge
double charge(const T &p)
Definition: AtlasPID.h:756
InDet::DumpObjects::m_CLloc_direction3
double * m_CLloc_direction3
Definition: DumpObjects.h:143
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
InDet::DumpObjects::m_SPz
double * m_SPz
Definition: DumpObjects.h:170
SiCluster.h
InDet::DumpObjects::m_CLparticleLink_barcode
std::vector< std::vector< int > > * m_CLparticleLink_barcode
Definition: DumpObjects.h:139
InDet::DumpObjects::m_CLpixel_count
int * m_CLpixel_count
Definition: DumpObjects.h:145
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
InDet::DumpObjects::m_pixelClusterKey
SG::ReadHandleKey< InDet::PixelClusterContainer > m_pixelClusterKey
Definition: DumpObjects.h:82
InDet::DumpObjects::m_particleDataTable
const HepPDT::ParticleDataTable * m_particleDataTable
Definition: DumpObjects.h:75
InDet::DumpObjects::m_mcEventCollectionKey
SG::ReadHandleKey< McEventCollection > m_mcEventCollectionKey
Definition: DumpObjects.h:80
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
InDet::DumpObjects::m_stripSDOKey
SG::ReadHandleKey< InDetSimDataCollection > m_stripSDOKey
Definition: DumpObjects.h:86
InDet::DumpObjects::m_max_eta
float m_max_eta
Definition: DumpObjects.h:102
InDet::DumpObjects::m_particlePropSvc
ServiceHandle< IPartPropSvc > m_particlePropSvc
Definition: DumpObjects.h:74
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
SiDetectorElement.h
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
InDet::DumpObjects::m_TTCindex
int * m_TTCindex
Definition: DumpObjects.h:196
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
InDet::DumpObjects::initialize
virtual StatusCode initialize() override final
Definition: DumpObjects.cxx:78
Trk::GsfMeasurementUpdator::fitQuality
FitQualityOnSurface fitQuality(const MultiComponentState &, const MeasurementBase &)
Method for determining the chi2 of the multi-component state and the number of degrees of freedom.
Definition: GsfMeasurementUpdator.cxx:845
InDetDD::SiCellId
Definition: SiCellId.h:29
InDet::DumpObjects::m_Part_pz
float * m_Part_pz
Definition: DumpObjects.h:156
InDet::PixelClusterOnTrack::prepRawData
virtual const PixelCluster * prepRawData() const override final
returns the PrepRawData - is a SiCluster in this scope
Definition: PixelClusterOnTrack.h:179
InDet::DumpObjects::m_DTTstTruth_subDetType
std::vector< std::vector< int > > * m_DTTstTruth_subDetType
Definition: DumpObjects.h:201
InDet::DumpObjects::m_Part_vProdStatus
int * m_Part_vProdStatus
Definition: DumpObjects.h:165
InDet::DumpObjects::m_stripClusterKey
SG::ReadHandleKey< InDet::SCT_ClusterContainer > m_stripClusterKey
Definition: DumpObjects.h:83
InDet::DumpObjects::m_SPCL2_index
int * m_SPCL2_index
Definition: DumpObjects.h:171
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
InDet::PixelClusterOnTrack
Definition: PixelClusterOnTrack.h:51
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SCT_ID::strip
int strip(const Identifier &id) const
Definition: SCT_ID.h:764
InDet::compute_overlap_SP_flag
int compute_overlap_SP_flag(const int &eta_module_cl1, const int &phi_module_cl1, const int &eta_module_cl2, const int &phi_module_cl2)
PixelModuleDesign.h
TRT_PAI_physicsConstants::mb
const double mb
1mb to cm2
Definition: TRT_PAI_physicsConstants.h:15
InDetDD::SolidStateDetectorElementBase::globalPosition
HepGeom::Point3D< double > globalPosition(const HepGeom::Point3D< double > &localPos) const
transform a reconstruction local position into a global position (inline):
InDetDD::SolidStateDetectorElementBase::phiAxis
const Amg::Vector3D & phiAxis() const
Definition: SolidStateDetectorElementBase.cxx:74
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
InDet::DumpObjects::m_ntupleFileName
std::string m_ntupleFileName
jobOption: Ntuple file name
Definition: DumpObjects.h:109
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
InDet::DumpObjects::m_TRKoutliersOnTrack_pixcl_sctcl_index
std::vector< std::vector< int > > * m_TRKoutliersOnTrack_pixcl_sctcl_index
Definition: DumpObjects.h:193
InDet::DumpObjects::m_event
int m_event
Definition: DumpObjects.h:72
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
InDet::DumpObjects::m_CLloc_phi
float * m_CLloc_phi
Definition: DumpObjects.h:147
InDet::DumpObjects::m_detailedTracksTruthKey
SG::ReadHandleKey< DetailedTrackTruthCollection > m_detailedTracksTruthKey
Definition: DumpObjects.h:96
InDet::DumpObjects::m_nTRK
int m_nTRK
Definition: DumpObjects.h:187
InDet::DumpObjects::m_SEID
int * m_SEID
Definition: DumpObjects.h:124
InDet::DumpObjects::m_TRKtrack_fitter
int * m_TRKtrack_fitter
Definition: DumpObjects.h:189
module_driven_slicing.min_eta
min_eta
Definition: module_driven_slicing.py:166
InDet::DumpObjects::m_CLJan_loc_direction1
double * m_CLJan_loc_direction1
Definition: DumpObjects.h:144
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
SG::ConstAccessor< T, AuxAllocator_t< T > >::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
InDet::DumpObjects::m_CLz
double * m_CLz
Definition: DumpObjects.h:131
DetailedTrackTruthCollection
Definition: DetailedTrackTruthCollection.h:20
merge.status
status
Definition: merge.py:17
InDet::DumpObjects::m_Part_pdg_id
int * m_Part_pdg_id
Definition: DumpObjects.h:163
RPDUtils::nRows
unsigned constexpr int nRows
Definition: RPDUtils.h:24
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
InDet::DumpObjects::m_xaodPixelSpacePointContainerKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodPixelSpacePointContainerKey
Definition: DumpObjects.h:88
InDet::DumpObjects::m_CLnorm_y
float * m_CLnorm_y
Definition: DumpObjects.h:150
FitQuality.h
PixelClusterOnTrack.h
InDet::DumpObjects::m_Part_px
float * m_Part_px
Definition: DumpObjects.h:156
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
InDet::DumpObjects::m_TRKpattern
std::vector< std::vector< int > > * m_TRKpattern
Definition: DumpObjects.h:190
InDet::DumpObjects::m_Part_vParentBarcode
std::vector< std::vector< int > > * m_Part_vParentBarcode
Definition: DumpObjects.h:166
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
InDet::DumpObjects::DumpObjects
DumpObjects(const std::string &name, ISvcLocator *pSvcLocator)
Definition: DumpObjects.cxx:57
InDet::DumpObjects::m_max_barcode
int m_max_barcode
Definition: DumpObjects.h:104
InDet::DumpObjects::m_CLx
double * m_CLx
Definition: DumpObjects.h:129
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
InDet::DumpObjects::m_TRKcharge
int * m_TRKcharge
Definition: DumpObjects.h:194
InDet::DumpObjects::m_CLphi_module
int * m_CLphi_module
Definition: DumpObjects.h:135
EgEfficiencyCorr_testFixedInput.etas
list etas
Definition: EgEfficiencyCorr_testFixedInput.py:9
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
InDet::DumpObjects::m_maxCL
int m_maxCL
jobOption: maximum number of clusters
Definition: DumpObjects.h:112
Trk::FitQualityOnSurface::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
InDet::DumpObjects::finalize
virtual StatusCode finalize() override final
Definition: DumpObjects.cxx:1359
InDet::DumpObjects::m_nSE
int m_nSE
Definition: DumpObjects.h:123
InDet::DumpObjects::m_TRKmot
int * m_TRKmot
Definition: DumpObjects.h:191
InDet::DumpObjects::m_TRKindex
int * m_TRKindex
Definition: DumpObjects.h:188
InDet::DumpObjects::m_DTTstCommon_subDetType
std::vector< std::vector< int > > * m_DTTstCommon_subDetType
Definition: DumpObjects.h:202
InDet::DumpObjects::m_tracksTruthKey
SG::ReadHandleKey< TrackTruthCollection > m_tracksTruthKey
Definition: DumpObjects.h:95
InDet::DumpObjects::m_nSP
int m_nSP
Definition: DumpObjects.h:168
InDet::SCT_ClusterOnTrack
Definition: SCT_ClusterOnTrack.h:44
InDet::DumpObjects::m_Part_vProdBarcode
int * m_Part_vProdBarcode
Definition: DumpObjects.h:165
InDetDD::PixelDetectorManager::getDetectorElement
virtual SiDetectorElement * getDetectorElement(const Identifier &id) const override
access to individual elements : via Identifier
Definition: PixelDetectorManager.cxx:80
InDet::DumpObjects::m_CLJan_loc_direction2
double * m_CLJan_loc_direction2
Definition: DumpObjects.h:144
InDet::DumpObjects::m_SPcovr
double * m_SPcovr
Definition: DumpObjects.h:175
InDet::DumpObjects::m_maxTRK
int m_maxTRK
Definition: DumpObjects.h:115
InDet::DumpObjects::m_CLlayer_disk
int * m_CLlayer_disk
Definition: DumpObjects.h:133
InDet::DumpObjects::m_maxSP
int m_maxSP
jobOption: maximum number of space points
Definition: DumpObjects.h:114
Identifier
Definition: IdentifierFieldParser.cxx:14
EventInfoCnvParams::eventIndex
thread_local event_number_t eventIndex
Definition: IEvtIdModifierSvc.h:34
Generated on Sun Dec 22 2024 21:09:33 for ATLAS Offline Software by   doxygen 1.8.18