ATLAS Offline Software
ISF_HitAnalysis.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 "./ISF_HitAnalysis.h"
6 
7 #include "ISF_FastCaloSimEvent/TFCSTruthState.h"
8 #include "ISF_FastCaloSimEvent/TFCSExtrapolationState.h"
9 
10 // Section of includes for LAr calo tests
11 #include "LArSimEvent/LArHitContainer.h"
12 #include "CaloDetDescr/CaloDetDescrElement.h"
13 #include "AthenaPoolUtilities/AthenaAttributeList.h"
14 
15 // Section of includes for tile calo tests
16 #include "CaloIdentifier/CaloIdManager.h"
17 #include "CaloIdentifier/LArEM_ID.h"
18 #include "CaloIdentifier/LArFCAL_ID.h"
19 #include "CaloIdentifier/LArHEC_ID.h"
20 #include "TileConditions/TileInfo.h"
21 
22 #include "TileDetDescr/TileDetDescrManager.h"
23 #include "CaloIdentifier/TileID.h"
24 #include "TileIdentifier/TileHWID.h"
25 #include "TileSimEvent/TileHit.h"
26 #include "TileSimEvent/TileHitVector.h"
27 
28 //Track Record
29 #include "TrackRecord/TrackRecordCollection.h"
30 
31 //CaloCell
32 #include "CaloEvent/CaloCellContainer.h"
33 #include "CaloEvent/CaloClusterCellLinkContainer.h"
34 #include "xAODCaloEvent/CaloClusterContainer.h"
35 #include "xAODCaloEvent/CaloCluster.h"
36 
37 
38 #include "ISF_FastCaloSimEvent/FCS_StepInfoCollection.h"
39 
40 // For MC Truth information:
41 #include "GeneratorObjects/McEventCollection.h"
42 
43 //####################
44 #include "CaloDetDescr/CaloDepthTool.h"
45 #include "TrkParameters/TrackParameters.h"
46 #include "TrkSurfaces/CylinderSurface.h"
47 #include "TrkSurfaces/DiscSurface.h"
48 #include "TrkSurfaces/DiscBounds.h"
49 #include "TrkExInterfaces/IExtrapolator.h"
50 #include "TrkMaterialOnTrack/EnergyLoss.h"
51 #include "TrkGeometry/TrackingGeometry.h"
52 #include "HepPDT/ParticleData.hh"
53 //#########################
54 
55 #include "TTree.h"
56 #include "TFile.h"
57 #include "TString.h"
58 #include "TVector3.h"
59 #include <sstream>
60 #include <algorithm>
61 #include <cmath>
62 #include <functional>
63 #include <iostream>
64 
65 ISF_HitAnalysis::ISF_HitAnalysis(const std::string& name, ISvcLocator* pSvcLocator)
66 : AthAlgorithm(name, pSvcLocator)
67  //Note that m_xxx are pointers to vectors set to 0, not set to empty vector! see note around TBranch
68 {
69  m_surfacelist.resize(0);
70  m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerB);
71  m_surfacelist.push_back(CaloCell_ID_FCS::PreSamplerE);
72  m_surfacelist.push_back(CaloCell_ID_FCS::EME1);
73  m_surfacelist.push_back(CaloCell_ID_FCS::EME2);
74  m_surfacelist.push_back(CaloCell_ID_FCS::FCAL0);
75 }
76 
77 ISF_HitAnalysis::~ISF_HitAnalysis()
78 = default;
79 
80 StatusCode ISF_HitAnalysis::initialize ATLAS_NOT_THREAD_SAFE ()
81 {
82  ATH_MSG_VERBOSE( "Initializing ISF_HitAnalysis" );
83  //
84  // Register the callback(s):
85  //
86  ATH_CHECK(m_geoModel.retrieve());
87  ATH_CHECK(detStore()->retrieve(m_tileMgr));
88  ATH_CHECK(detStore()->retrieve(m_tileID));
89 
90  const CaloIdManager* caloIdManager{nullptr};
91  ATH_CHECK(detStore()->retrieve(caloIdManager));
92  m_larEmID=caloIdManager->getEM_ID();
93  if(m_larEmID==nullptr)
94  throw std::runtime_error("ISF_HitAnalysis: Invalid LAr EM ID helper");
95  m_larFcalID=caloIdManager->getFCAL_ID();
96  if(m_larFcalID==nullptr)
97  throw std::runtime_error("ISF_HitAnalysis: Invalid FCAL ID helper");
98  m_larHecID=caloIdManager->getHEC_ID();
99  if(m_larHecID==nullptr)
100  throw std::runtime_error("ISF_HitAnalysis: Invalid HEC ID helper");
101  m_tileID=caloIdManager->getTileID();
102  if(m_tileID==nullptr)
103  throw std::runtime_error("ISF_HitAnalysis: Invalid Tile ID helper");
104 
105  ATH_CHECK( m_fSamplKey.initialize() );
106 
107  ATH_CHECK(detStore()->retrieve(m_tileHWID));
108  ATH_CHECK( m_tileSamplingFractionKey.initialize() );
109 
110  ATH_CHECK( m_tileCablingSvc.retrieve() );
111  m_tileCabling = m_tileCablingSvc->cablingService();
112 
113  ATH_CHECK(m_caloMgrKey.initialize());
114 
115  // Get TimedExtrapolator ***************************************************************************************************
116  if (!m_extrapolator.empty() && m_extrapolator.retrieve().isFailure()) {
117  return StatusCode::FAILURE;
118  }
119  ATH_MSG_DEBUG("Extrapolator retrieved "<< m_extrapolator);
120 
121  ATH_CHECK(m_calo_tb_coord.retrieve());
122  ATH_MSG_VERBOSE("retrieved " << m_calo_tb_coord);
123 
124 
125  // Get FastCaloSimCaloExtrapolation
126  ATH_CHECK (m_FastCaloSimCaloExtrapolation.retrieve());
127 
128  // Grab the Ntuple and histogramming service for the tree
129  ATH_CHECK(m_thistSvc.retrieve());
130 
131  //#########################
132  ATH_CHECK(m_partPropSvc.retrieve());
133 
134  m_particleDataTable = (HepPDT::ParticleDataTable*) m_partPropSvc->PDT();
135  if(m_particleDataTable == nullptr) {
136  ATH_MSG_ERROR("PDG table not found");
137  return StatusCode::FAILURE;
138  }
139  //#########################
140  std::unique_ptr<TFile> dummyFile = std::unique_ptr<TFile>(TFile::Open("dummyFile.root", "RECREATE")); //This is added to suppress the error messages about memory-resident trees
141  m_tree = new TTree("FCS_ParametrizationInput", "FCS_ParametrizationInput");
142  std::string fullNtupleName = "/"+m_ntupleFileName+"/"+m_ntupleTreeName;
143  StatusCode sc = m_thistSvc->regTree(fullNtupleName, m_tree);
144  if (sc.isFailure() || !m_tree )
145  {
146  ATH_MSG_ERROR("Unable to register TTree: " << fullNtupleName);
147  return StatusCode::FAILURE;
148  }
149 
151  if (m_tree)
152  {
153  ATH_MSG_INFO("Successfull registered TTree: " << fullNtupleName);
154  //initialize the variables before creating the branches
155  m_hit_x = new std::vector<float>;
156  m_hit_y = new std::vector<float>;
157  m_hit_z = new std::vector<float>;
158  m_hit_energy = new std::vector<float>;
159  m_hit_time = new std::vector<float>;
160  m_hit_identifier = new std::vector<Long64_t>;
161  m_hit_cellidentifier = new std::vector<Long64_t>;
162  m_islarbarrel = new std::vector<bool>;
163  m_islarendcap = new std::vector<bool>;
164  m_islarhec = new std::vector<bool>;
165  m_islarfcal = new std::vector<bool>;
166  m_istile = new std::vector<bool>;
167  m_hit_sampling = new std::vector<int>;
168  m_hit_samplingfraction = new std::vector<float>;
169 
170  m_truth_energy = new std::vector<float>;
171  m_truth_px = new std::vector<float>;
172  m_truth_py = new std::vector<float>;
173  m_truth_pz = new std::vector<float>;
174  m_truth_pdg = new std::vector<int>;
175  m_truth_barcode = new std::vector<int>;
176  m_truth_vtxbarcode = new std::vector<int>;
177 
178  m_cluster_energy = new std::vector<float>;
179  m_cluster_eta = new std::vector<float>;
180  m_cluster_phi = new std::vector<float>;
181  m_cluster_size = new std::vector<unsigned>;
182  m_cluster_cellID = new std::vector<std::vector<Long64_t > >;
183 
184  m_cell_identifier = new std::vector<Long64_t>;
185  m_cell_energy = new std::vector<float>;
186  m_cell_sampling = new std::vector<int>;
187 
188  m_g4hit_energy = new std::vector<float>;
189  m_g4hit_time = new std::vector<float>;
190  m_g4hit_identifier = new std::vector<Long64_t>;
191  m_g4hit_cellidentifier = new std::vector<Long64_t>;
192  m_g4hit_samplingfraction = new std::vector<float>;
193  m_g4hit_sampling = new std::vector<int>;
194 
195  m_total_cell_e = 0;
196  m_total_hit_e = 0;
197  m_total_g4hit_e = 0;
198 
199  m_final_cell_energy = new std::vector<Float_t>;
200  m_final_hit_energy = new std::vector<Float_t>;
201  m_final_g4hit_energy = new std::vector<Float_t>;
202 
203  m_newTTC_entrance_eta = new std::vector<std::vector<float> >;
204  m_newTTC_entrance_phi = new std::vector<std::vector<float> >;
205  m_newTTC_entrance_r = new std::vector<std::vector<float> >;
206  m_newTTC_entrance_z = new std::vector<std::vector<float> >;
207  m_newTTC_entrance_detaBorder = new std::vector<std::vector<float> >;
208  m_newTTC_entrance_OK = new std::vector<std::vector<bool> >;
209  m_newTTC_back_eta = new std::vector<std::vector<float> >;
210  m_newTTC_back_phi = new std::vector<std::vector<float> >;
211  m_newTTC_back_r = new std::vector<std::vector<float> >;
212  m_newTTC_back_z = new std::vector<std::vector<float> >;
213  m_newTTC_back_detaBorder = new std::vector<std::vector<float> >;
214  m_newTTC_back_OK = new std::vector<std::vector<bool> >;
215  m_newTTC_mid_eta = new std::vector<std::vector<float> >;
216  m_newTTC_mid_phi = new std::vector<std::vector<float> >;
217  m_newTTC_mid_r = new std::vector<std::vector<float> >;
218  m_newTTC_mid_z = new std::vector<std::vector<float> >;
219  m_newTTC_mid_detaBorder = new std::vector<std::vector<float> >;
220  m_newTTC_mid_OK = new std::vector<std::vector<bool> >;
221  m_newTTC_IDCaloBoundary_eta = new std::vector<float>;
222  m_newTTC_IDCaloBoundary_phi = new std::vector<float>;
223  m_newTTC_IDCaloBoundary_r = new std::vector<float>;
224  m_newTTC_IDCaloBoundary_z = new std::vector<float>;
225  m_newTTC_Angle3D = new std::vector<float>;
226  m_newTTC_AngleEta = new std::vector<float>;
227 
228  m_MuonEntryLayer_E = new std::vector<float>;
229  m_MuonEntryLayer_px = new std::vector<float>;
230  m_MuonEntryLayer_py = new std::vector<float>;
231  m_MuonEntryLayer_pz = new std::vector<float>;
232  m_MuonEntryLayer_x = new std::vector<float>;
233  m_MuonEntryLayer_y = new std::vector<float>;
234  m_MuonEntryLayer_z = new std::vector<float>;
235  m_MuonEntryLayer_pdg = new std::vector<int>;
236 
237  // Optional branches
238  if(m_saveAllBranches){
239  m_tree->Branch("HitX", &m_hit_x);
240  m_tree->Branch("HitY", &m_hit_y);
241  m_tree->Branch("HitZ", &m_hit_z);
242  m_tree->Branch("HitE", &m_hit_energy);
243  m_tree->Branch("HitT", &m_hit_time);
244  m_tree->Branch("HitIdentifier", &m_hit_identifier);
245  m_tree->Branch("HitCellIdentifier", &m_hit_cellidentifier);
246  m_tree->Branch("HitIsLArBarrel", &m_islarbarrel);
247  m_tree->Branch("HitIsLArEndCap", &m_islarendcap);
248  m_tree->Branch("HitIsHEC", &m_islarhec);
249  m_tree->Branch("HitIsFCAL", &m_islarfcal);
250  m_tree->Branch("HitIsTile", &m_istile);
251  m_tree->Branch("HitSampling", &m_hit_sampling);
252  m_tree->Branch("HitSamplingFraction", &m_hit_samplingfraction);
253 
254  m_tree->Branch("CellIdentifier", &m_cell_identifier);
255  m_tree->Branch("CellE", &m_cell_energy);
256  m_tree->Branch("CellSampling", &m_cell_sampling);
257 
258  m_tree->Branch("G4HitE", &m_g4hit_energy);
259  m_tree->Branch("G4HitT", &m_g4hit_time);
260  m_tree->Branch("G4HitIdentifier", &m_g4hit_identifier);
261  m_tree->Branch("G4HitCellIdentifier", &m_g4hit_cellidentifier);
262  m_tree->Branch("G4HitSamplingFraction",&m_g4hit_samplingfraction);
263  m_tree->Branch("G4HitSampling", &m_g4hit_sampling);
264  }
265 
266  //CaloHitAna output variables
267  m_tree->Branch("TruthE", &m_truth_energy);
268  m_tree->Branch("TruthPx", &m_truth_px);
269  m_tree->Branch("TruthPy", &m_truth_py);
270  m_tree->Branch("TruthPz", &m_truth_pz);
271  m_tree->Branch("TruthPDG", &m_truth_pdg);
272  m_tree->Branch("TruthBarcode", &m_truth_barcode);
273  m_tree->Branch("TruthVtxBarcode", &m_truth_vtxbarcode);
274 
275  if(m_doClusterInfo){
276  m_tree->Branch("ClusterE", &m_cluster_energy);
277  m_tree->Branch("ClusterEta", &m_cluster_eta);
278  m_tree->Branch("ClusterPhi", &m_cluster_phi);
279  m_tree->Branch("ClusterSize", &m_cluster_size);
280  m_tree->Branch("ClusterCellID", &m_cluster_cellID);
281  }
282 
283  m_oneeventcells = new FCS_matchedcellvector;
284  if(m_doAllCells){
285  m_tree->Branch("AllCells", &m_oneeventcells);
286  }
287 
288  //write cells per layer
289  if(m_doLayers){
290  for (Int_t i = 0; i < MAX_LAYER; i++)
291  {
292  TString branchname = "Sampling_";
293  branchname += i;
294  m_layercells[i] = new FCS_matchedcellvector;
295  m_tree->Branch(branchname, &m_layercells[i]);
296  }
297  }
298 
299  if(m_doLayerSums){
300  //write also energies per layer:
301  m_tree->Branch("cell_energy", &m_final_cell_energy);
302  m_tree->Branch("hit_energy", &m_final_hit_energy);
303  m_tree->Branch("g4hit_energy", &m_final_g4hit_energy);
304 
305  //This is a duplicate of cell_energy[25]
306  m_tree->Branch("total_cell_energy", &m_total_cell_e);
307  m_tree->Branch("total_hit_energy", &m_total_hit_e);
308  m_tree->Branch("total_g4hit_energy", &m_total_g4hit_e);
309  }
310 
311  m_tree->Branch("newTTC_back_eta",&m_newTTC_back_eta);
312  m_tree->Branch("newTTC_back_phi",&m_newTTC_back_phi);
313  m_tree->Branch("newTTC_back_r",&m_newTTC_back_r);
314  m_tree->Branch("newTTC_back_z",&m_newTTC_back_z);
315  m_tree->Branch("newTTC_back_detaBorder",&m_newTTC_back_detaBorder);
316  m_tree->Branch("newTTC_back_OK",&m_newTTC_back_OK);
317  m_tree->Branch("newTTC_entrance_eta",&m_newTTC_entrance_eta);
318  m_tree->Branch("newTTC_entrance_phi",&m_newTTC_entrance_phi);
319  m_tree->Branch("newTTC_entrance_r",&m_newTTC_entrance_r);
320  m_tree->Branch("newTTC_entrance_z",&m_newTTC_entrance_z);
321  m_tree->Branch("newTTC_entrance_detaBorder",&m_newTTC_entrance_detaBorder);
322  m_tree->Branch("newTTC_entrance_OK",&m_newTTC_entrance_OK);
323  m_tree->Branch("newTTC_mid_eta",&m_newTTC_mid_eta);
324  m_tree->Branch("newTTC_mid_phi",&m_newTTC_mid_phi);
325  m_tree->Branch("newTTC_mid_r",&m_newTTC_mid_r);
326  m_tree->Branch("newTTC_mid_z",&m_newTTC_mid_z);
327  m_tree->Branch("newTTC_mid_detaBorder",&m_newTTC_mid_detaBorder);
328  m_tree->Branch("newTTC_mid_OK",&m_newTTC_mid_OK);
329  m_tree->Branch("newTTC_IDCaloBoundary_eta",&m_newTTC_IDCaloBoundary_eta);
330  m_tree->Branch("newTTC_IDCaloBoundary_phi",&m_newTTC_IDCaloBoundary_phi);
331  m_tree->Branch("newTTC_IDCaloBoundary_r",&m_newTTC_IDCaloBoundary_r);
332  m_tree->Branch("newTTC_IDCaloBoundary_z",&m_newTTC_IDCaloBoundary_z);
333  m_tree->Branch("newTTC_Angle3D",&m_newTTC_Angle3D);
334  m_tree->Branch("newTTC_AngleEta",&m_newTTC_AngleEta);
335 
336  m_tree->Branch("MuonEntryLayer_E",&m_MuonEntryLayer_E);
337  m_tree->Branch("MuonEntryLayer_px",&m_MuonEntryLayer_px);
338  m_tree->Branch("MuonEntryLayer_py",&m_MuonEntryLayer_py);
339  m_tree->Branch("MuonEntryLayer_pz",&m_MuonEntryLayer_pz);
340  m_tree->Branch("MuonEntryLayer_x",&m_MuonEntryLayer_x);
341  m_tree->Branch("MuonEntryLayer_y",&m_MuonEntryLayer_y);
342  m_tree->Branch("MuonEntryLayer_z",&m_MuonEntryLayer_z);
343  m_tree->Branch("MuonEntryLayer_pdg",&m_MuonEntryLayer_pdg);
344  }
345  dummyFile->Close();
346  return StatusCode::SUCCESS;
347 } //initialize
348 
349 StatusCode ISF_HitAnalysis::finalize ATLAS_NOT_THREAD_SAFE ()
350 {
351 
352  ATH_MSG_VERBOSE( "doing finalize()" );
353 
354 
355  const AthenaAttributeList* simParam = nullptr;
356  if (detStore()->retrieve(simParam, m_MC_SIM_PARAM).isFailure()) {
357  ATH_MSG_ERROR("Could not retrieve Simulation parameters");
358  return StatusCode::FAILURE;
359  } else {
360  ATH_MSG_DEBUG("Retrieved Simulation parameters");
361  for (auto attrItr = simParam->begin(); attrItr != simParam->end();
362  ++attrItr) {
363  std::stringstream outstr;
364  attrItr->toOutputStream(outstr);
365  ATH_MSG_INFO("Simulation MetaData: " << outstr.str());
366  }
367  }
368 
369  const AthenaAttributeList* digiParam = nullptr;
370  if (detStore()->retrieve(digiParam, m_MC_DIGI_PARAM).isFailure()) {
371  ATH_MSG_ERROR("Could not retrieve Digitization parameters");
372  return StatusCode::FAILURE;
373  } else {
374  ATH_MSG_DEBUG("Retrieved Digitization parameters");
375  for (auto attrItr = digiParam->begin(); attrItr != digiParam->end();
376  ++attrItr) {
377  std::stringstream outstr;
378  attrItr->toOutputStream(outstr);
379  ATH_MSG_INFO("Digitization MetaData: " << outstr.str());
380  }
381  }
382  std::unique_ptr<TFile> dummyGeoFile = std::unique_ptr<TFile>(TFile::Open("dummyGeoFile.root", "RECREATE")); //This is added to suppress the error messages about memory-resident trees
383  TTree* geo = new TTree( m_geoModel->atlasVersion().c_str() , m_geoModel->atlasVersion().c_str() );
384  std::string fullNtupleName = "/"+m_geoFileName+"/"+m_geoModel->atlasVersion();
385  StatusCode sc = m_thistSvc->regTree(fullNtupleName, geo);
386  if(sc.isFailure() || !geo )
387  {
388  ATH_MSG_ERROR("Unable to register TTree: " << fullNtupleName);
389  return StatusCode::FAILURE;
390  }
391 
394  using GEOCELL = struct
395  {
396  Long64_t identifier;
397  Int_t calosample;
398  float eta,phi,r,eta_raw,phi_raw,r_raw,x,y,z,x_raw,y_raw,z_raw;
399  float deta,dphi,dr,dx,dy,dz;
400  };
401 
402  static GEOCELL geocell;
403 
404  if(geo)
405  {
406  ATH_MSG_INFO("Successfull registered TTree: " << fullNtupleName);
407  //this actually creates the vector itself! And only if it succeeds! Note that the result is not checked! And the code is probably leaking memory in the end
408  //geo->Branch("cells", &geocell,"identifier/L:eta,phi,r,eta_raw,phi_raw,r_raw,x,y,z,x_raw,y_raw,z_raw/F:Deta,Dphi,Dr,Dx,Dy,Dz/F");
409  geo->Branch("identifier", &geocell.identifier,"identifier/L");
410  geo->Branch("calosample", &geocell.calosample,"calosample/I");
411 
412  geo->Branch("eta", &geocell.eta,"eta/F");
413  geo->Branch("phi", &geocell.phi,"phi/F");
414  geo->Branch("r", &geocell.r,"r/F");
415  geo->Branch("eta_raw", &geocell.eta_raw,"eta_raw/F");
416  geo->Branch("phi_raw", &geocell.phi_raw,"phi_raw/F");
417  geo->Branch("r_raw", &geocell.r_raw,"r_raw/F");
418 
419  geo->Branch("x", &geocell.x,"x/F");
420  geo->Branch("y", &geocell.y,"y/F");
421  geo->Branch("z", &geocell.z,"z/F");
422  geo->Branch("x_raw", &geocell.x_raw,"x_raw/F");
423  geo->Branch("y_raw", &geocell.y_raw,"y_raw/F");
424  geo->Branch("z_raw", &geocell.z_raw,"z_raw/F");
425 
426  geo->Branch("deta", &geocell.deta,"deta/F");
427  geo->Branch("dphi", &geocell.dphi,"dphi/F");
428  geo->Branch("dr", &geocell.dr,"dr/F");
429  geo->Branch("dx", &geocell.dx,"dx/F");
430  geo->Branch("dy", &geocell.dy,"dy/F");
431  geo->Branch("dz", &geocell.dz,"dz/F");
432  }
433 
434  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,Gaudi::Hive::currentContext()};
435  ATH_CHECK(caloMgrHandle.isValid());
436  const CaloDetDescrManager* calo_dd_man = *caloMgrHandle;
437 
438  int ncells=0;
439  for (const CaloDetDescrElement* theDDE : calo_dd_man->element_range())
440  {
441  if(theDDE)
442  {
443  CaloCell_ID::CaloSample sample=theDDE->getSampling();
444  //CaloCell_ID::SUBCALO calo=theDDE->getSubCalo();
445  ++ncells;
446  if(geo)
447  {
448  geocell.identifier=theDDE->identify().get_compact();
449  geocell.calosample=sample;
450  geocell.eta=theDDE->eta();
451  geocell.phi=theDDE->phi();
452  geocell.r=theDDE->r();
453  geocell.eta_raw=theDDE->eta_raw();
454  geocell.phi_raw=theDDE->phi_raw();
455  geocell.r_raw=theDDE->r_raw();
456  geocell.x=theDDE->x();
457  geocell.y=theDDE->y();
458  geocell.z=theDDE->z();
459  geocell.x_raw=theDDE->x_raw();
460  geocell.y_raw=theDDE->y_raw();
461  geocell.z_raw=theDDE->z_raw();
462  geocell.deta=theDDE->deta();
463  geocell.dphi=theDDE->dphi();
464  geocell.dr=theDDE->dr();
465  geocell.dx=theDDE->dx();
466  geocell.dy=theDDE->dy();
467  geocell.dz=theDDE->dz();
468 
469  geo->Fill();
470  }
471  }
472  }
473 
474  ATH_MSG_INFO( ncells<<" cells found" );
475 
476  dummyGeoFile->Close();
477  return StatusCode::SUCCESS;
478 } //finalize
479 
480 
481 StatusCode ISF_HitAnalysis::execute()
482 {
483 
484  ATH_MSG_DEBUG( "In ISF_HitAnalysis::execute()" );
485 
486  if (! m_tree)
487  {
488  ATH_MSG_ERROR( "tree not registered" );
489  return StatusCode::FAILURE;
490  }
491 
492  SG::ReadCondHandle<ILArfSampl> fSamplHdl(m_fSamplKey,Gaudi::Hive::currentContext());
493  const ILArfSampl* fSampl=*fSamplHdl;
494 
495  SG::ReadCondHandle<TileSamplingFraction> tileSamplingFraction(m_tileSamplingFractionKey,Gaudi::Hive::currentContext());
496  ATH_CHECK( tileSamplingFraction.isValid() );
497 
498 
499  //now if the branches were created correctly, the pointers point to something and it is possible to clear the vectors
500  TVector3 vectest;
501  vectest.SetPtEtaPhi(1.,1.,1.);
502  m_hit_x->clear();
503  m_hit_y->clear();
504  m_hit_z->clear();
505  m_hit_energy->clear();
506  m_hit_time->clear();
507  m_hit_identifier->clear();
508  m_hit_cellidentifier->clear();
509  m_islarbarrel->clear();
510  m_islarendcap->clear();
511  m_islarhec->clear();
512  m_islarfcal->clear();
513  m_istile->clear();
514  m_hit_sampling->clear();
515  m_hit_samplingfraction->clear();
516  m_truth_energy->clear();
517  m_truth_px->clear();
518  m_truth_py->clear();
519  m_truth_pz->clear();
520  m_truth_pdg->clear();
521  m_truth_barcode->clear();
522  m_truth_vtxbarcode->clear();
523  m_cluster_energy->clear();
524  m_cluster_eta->clear();
525  m_cluster_phi->clear();
526  m_cluster_size->clear();
527  m_cluster_cellID->clear();
528  m_cell_identifier->clear();
529  m_cell_energy->clear();
530  m_cell_sampling->clear();
531  m_g4hit_energy->clear();
532  m_g4hit_time->clear();
533  m_g4hit_identifier->clear();
534  m_g4hit_cellidentifier->clear();
535  m_g4hit_sampling->clear();
536  m_g4hit_samplingfraction->clear();
537  //which fails for this one!!
538  //m_matched_cells->clear();
539  std::map<Long64_t, FCS_cell> cells; //read all objects and collect them by identifier (Long64_t)
540  std::map<Long64_t, std::vector<FCS_g4hit> > g4hits;
541  std::map<Long64_t, std::vector<FCS_hit> > hits;
542 
543  cells.clear();
544  g4hits.clear();
545  hits.clear();
546 
547  FCS_cell one_cell{}; //note that this is not extra safe if I don't have a clear method!
548  FCS_g4hit one_g4hit{};
549  FCS_hit one_hit{};
550  FCS_matchedcell one_matchedcell;
551 
552  m_oneeventcells->m_vector.clear();
553  m_final_g4hit_energy->clear();
554  m_final_hit_energy->clear();
555  m_final_cell_energy->clear();
556 
557  m_newTTC_back_eta->clear();
558  m_newTTC_back_phi->clear();
559  m_newTTC_back_r->clear();
560  m_newTTC_back_z->clear();
561  m_newTTC_back_detaBorder->clear();
562  m_newTTC_back_OK->clear();
563  m_newTTC_entrance_eta->clear();
564  m_newTTC_entrance_phi->clear();
565  m_newTTC_entrance_r->clear();
566  m_newTTC_entrance_z->clear();
567  m_newTTC_entrance_detaBorder->clear();
568  m_newTTC_entrance_OK->clear();
569  m_newTTC_mid_eta->clear();
570  m_newTTC_mid_phi->clear();
571  m_newTTC_mid_r->clear();
572  m_newTTC_mid_z->clear();
573  m_newTTC_mid_detaBorder->clear();
574  m_newTTC_mid_OK->clear();
575  m_newTTC_IDCaloBoundary_eta->clear();
576  m_newTTC_IDCaloBoundary_phi->clear();
577  m_newTTC_IDCaloBoundary_r->clear();
578  m_newTTC_IDCaloBoundary_z->clear();
579  m_newTTC_Angle3D->clear();
580  m_newTTC_AngleEta->clear();
581 
582 
583  m_MuonEntryLayer_E->clear();
584  m_MuonEntryLayer_x->clear();
585  m_MuonEntryLayer_y->clear();
586  m_MuonEntryLayer_z->clear();
587  m_MuonEntryLayer_px->clear();
588  m_MuonEntryLayer_py->clear();
589  m_MuonEntryLayer_pz->clear();
590  m_MuonEntryLayer_pdg->clear();
591 
592  //##########################
593 
594  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,Gaudi::Hive::currentContext()};
595  ATH_CHECK(caloMgrHandle.isValid());
596  const CaloDetDescrManager* calo_dd_man = *caloMgrHandle;
597 
598  //Get the FastCaloSim step info collection from store
599  const ISF_FCS_Parametrization::FCS_StepInfoCollection* eventStepsES;
600  StatusCode sc = evtStore()->retrieve(eventStepsES, "MergedEventSteps");
601  if (sc.isFailure()) {
602  ATH_MSG_WARNING( "No FastCaloSim steps read from StoreGate?" );
603  //return StatusCode::FAILURE;
604  } else {
605  ATH_MSG_INFO("Read: "<<eventStepsES->size()<<" position hits");
606  for (ISF_FCS_Parametrization::FCS_StepInfoCollection::const_iterator it = eventStepsES->begin(); it != eventStepsES->end(); ++it) {
607  m_hit_x->push_back( (*it)->x() );
608  m_hit_y->push_back( (*it)->y() );
609  m_hit_z->push_back( (*it)->z() );
610  m_hit_energy->push_back( (*it)->energy() );
611  m_hit_time->push_back( (*it)->time());
612 
613  //Try to get the samplings, sampling fractions from identifiers
614  bool larbarrel=false;
615  bool larendcap=false;
616  bool larhec=false;
617  bool larfcal=false;
618  bool tile=false;
619  int sampling=-1;
620  double sampfrac=0.0;
621 
622  Identifier id = (*it)->identify();
623  Identifier cell_id = (*it)->identify(); //to be replaced by cell_id in tile
624 
625  if(calo_dd_man->get_element(id)) {
626  CaloCell_ID::CaloSample layer = calo_dd_man->get_element(id)->getSampling();
627  sampling = layer; //use CaloCell layer immediately
628  } else {
629  ATH_MSG_WARNING( "Warning no sampling info for "<<id.getString());
630  }
631 
632  if(m_larEmID->is_lar_em(id) || m_larHecID->is_lar_hec(id) || m_larFcalID->is_lar_fcal(id)) sampfrac=fSampl->FSAMPL(id);
633  if (m_tileID->is_tile(id)) {
634  HWIdentifier channel_id = m_tileCabling->s2h_channel_id(id);
635  int channel = m_tileHWID->channel(channel_id);
636  int drawerIdx = m_tileHWID->drawerIdx(channel_id);
637  sampfrac = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
638  }
639  if(m_larEmID->is_lar_em(id)) {
640  //LAr EM cells
641  if (m_larEmID->is_em_barrel(id)) larbarrel=true;
642  else if(m_larEmID->is_em_endcap(id)) larendcap=true;
643  } else if(m_larHecID->is_lar_hec(id)) {
644  //LAr HEC cells
645  larhec = true;
646  } else if(m_larFcalID->is_lar_fcal(id)) {
647  //LAr FCal cells
648  larfcal = true;
649  } else if (m_tileID->is_tile_aux(id)) {
650  // special case for E4'
651  tile = true;
652  cell_id = m_tileID->cell_id(id);
653  sampling = CaloCell_ID::TileGap3;
654  } else if(m_tileID->is_tile_barrel(id) || m_tileID->is_tile_extbarrel(id) || m_tileID->is_tile_gap(id)) {
655  // all other Tile cells
656  tile = true;
657  cell_id = m_tileID->cell_id(id);
658  Int_t tile_sampling = -1;
659  if(calo_dd_man->get_element(cell_id)) {
660  tile_sampling = calo_dd_man->get_element(cell_id)->getSampling();
661  }
662  if(tile_sampling!= -1) sampling = tile_sampling; //calo_dd_man needs to be called with cell_id not pmt_id!!
663  } else {
664  ATH_MSG_WARNING( "This hit is somewhere. Please check!");
665  }
666 
667  m_hit_identifier->push_back(id.get_compact());
668  m_hit_cellidentifier->push_back(cell_id.get_compact());
669  //push things into vectors:
670  m_islarbarrel->push_back(larbarrel);
671  m_islarendcap->push_back(larendcap);
672  m_islarhec->push_back(larhec);
673  m_islarfcal->push_back(larfcal);
674  m_istile->push_back(tile);
675  m_hit_sampling->push_back(sampling);
676  m_hit_samplingfraction->push_back(sampfrac);
677 
678  } //event steps
679  }//event steps read correctly
680 
681  //Get truth particle info
682  //Note that there can be more truth particles, the first one is usually the one we need.
683  const McEventCollection* mcEvent;
684  sc = evtStore()->retrieve(mcEvent,"TruthEvent");
685  if(sc.isFailure()) {
686  ATH_MSG_WARNING( "No truth event!");
687  } else {
688  if(mcEvent) {
689  //std::cout<<"ISF_HitAnalysis: MC event size: "<<mcEvent->size()<<std::endl;
690  if(!mcEvent->empty()) {
691  int particleIndex=0;
692  int loopEnd = m_NtruthParticles;
693  int particles_size=(*mcEvent->begin())->particles_size();
694  if(loopEnd==-1) {
695  loopEnd = particles_size; //is this the correct thing?
696  }
697 #ifdef HEPMC3
698  for (const auto& part: *(*mcEvent->begin()))
699 #else
700  for (const auto part: *(*mcEvent->begin()))
701 #endif
702  {
703 
704  ATH_MSG_DEBUG("Number truth particles="<<particles_size<<" loopEnd="<<loopEnd);
705  particleIndex++;
706 
707  if (particleIndex>loopEnd) break; //enough particles
708 
709  //UPDATE EXTRAPOLATION WITH ALGTOOL***********************************************
710 
711  TFCSTruthState truth(part->momentum().px(),part->momentum().py(),part->momentum().pz(),part->momentum().e(),part->pdg_id());
712 
713  //calculate the vertex
714  TVector3 moment;
715  moment.SetXYZ(part->momentum().px(),part->momentum().py(),part->momentum().pz());
716  TVector3 direction=moment.Unit();
717 
718  //does it hit the barrel or the EC?
719 
720  if(std::abs(direction.Z())/m_CaloBoundaryZ < direction.Perp()/m_CaloBoundaryR) {
721  //BARREL
722  direction*=m_CaloBoundaryR/direction.Perp();
723  } else {
724  //EC
725  direction*=m_CaloBoundaryZ/abs(direction.Z());
726  }
727 
728  if((part)->production_vertex()) {
729  truth.set_vertex((part)->production_vertex()->position().x(), (part)->production_vertex()->position().y(), (part)->production_vertex()->position().z());
730  } else {
731  truth.set_vertex(direction.X(),direction.Y(),direction.Z());
732  ATH_MSG_WARNING("No particle production vetext, use VERTEX from direction: x "<<direction.X()<<" y "<<direction.Y()<<" z "<<direction.Z());
733  }
734 
735  if( std::abs(direction.X()-truth.vertex().X())>0.1 || std::abs(direction.Y()-truth.vertex().Y())>0.1 || std::abs(direction.Z()-truth.vertex().Z())>0.1 ) {
736  ATH_MSG_WARNING("VERTEX from direction: x "<<direction.X()<<" y "<<direction.Y()<<" z "<<direction.Z());
737  ATH_MSG_WARNING("but VERTEX from hepmc: x "<<truth.vertex().X()<<" y "<<truth.vertex().Y()<<" z "<<truth.vertex().Z());
738  }
739 
740  TFCSExtrapolationState result;
741  m_FastCaloSimCaloExtrapolation->extrapolate(result,&truth);
742 
743  //write the result into the ntuple variables:
744 
745  ATH_MSG_DEBUG("IDCaloBoundary_eta() "<<result.IDCaloBoundary_eta());
746  ATH_MSG_DEBUG("IDCaloBoundary_phi() "<<result.IDCaloBoundary_phi());
747  ATH_MSG_DEBUG("IDCaloBoundary_r() "<<result.IDCaloBoundary_r());
748  ATH_MSG_DEBUG("IDCaloBoundary_z() "<<result.IDCaloBoundary_z());
749  ATH_MSG_DEBUG("AngleEta "<<result.IDCaloBoundary_AngleEta());
750  ATH_MSG_DEBUG("Angle3D "<<result.IDCaloBoundary_Angle3D());
751 
752  m_newTTC_IDCaloBoundary_eta->push_back(float(result.IDCaloBoundary_eta()));
753  m_newTTC_IDCaloBoundary_phi->push_back(float(result.IDCaloBoundary_phi()));
754  m_newTTC_IDCaloBoundary_r->push_back(float(result.IDCaloBoundary_r()));
755  m_newTTC_IDCaloBoundary_z->push_back(float(result.IDCaloBoundary_z()));
756  m_newTTC_Angle3D ->push_back(float(result.IDCaloBoundary_Angle3D()));
757  m_newTTC_AngleEta->push_back(float(result.IDCaloBoundary_AngleEta()));
758 
759  std::vector<float> eta_vec_ENT;
760  std::vector<float> phi_vec_ENT;
761  std::vector<float> r_vec_ENT;
762  std::vector<float> z_vec_ENT;
763  std::vector<float> detaBorder_vec_ENT;
764  std::vector<bool> OK_vec_ENT;
765 
766  std::vector<float> eta_vec_EXT;
767  std::vector<float> phi_vec_EXT;
768  std::vector<float> r_vec_EXT;
769  std::vector<float> z_vec_EXT;
770  std::vector<float> detaBorder_vec_EXT;
771  std::vector<bool> OK_vec_EXT;
772 
773  std::vector<float> eta_vec_MID;
774  std::vector<float> phi_vec_MID;
775  std::vector<float> r_vec_MID;
776  std::vector<float> z_vec_MID;
777  std::vector<float> detaBorder_vec_MID;
778  std::vector<bool> OK_vec_MID;
779 
780  for(int sample=CaloCell_ID_FCS::FirstSample;sample<CaloCell_ID_FCS::MaxSample;++sample) {
781  ATH_MSG_DEBUG("sample "<<sample);
782  ATH_MSG_DEBUG(" eta ENT "<<result.eta(sample,1)<<" eta EXT "<<result.eta(sample,2));
783  ATH_MSG_DEBUG(" phi ENT "<<result.phi(sample,1)<<" phi EXT "<<result.phi(sample,2));
784  ATH_MSG_DEBUG(" r ENT "<<result.r(sample,1) <<" r EXT "<<result.r(sample,2) );
785  ATH_MSG_DEBUG(" z ENT "<<result.z(sample,1) <<" z EXT "<<result.z(sample,2) );
786  ATH_MSG_DEBUG(" detaBorder ENT "<<result.detaBorder(sample,1) <<" detaBorder EXT "<<result.detaBorder(sample,2) );
787  ATH_MSG_DEBUG(" OK ENT "<<result.OK(sample,1) <<" OK EXT "<<result.OK(sample,2) );
788  eta_vec_ENT.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_ENT)));
789  eta_vec_EXT.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_EXT)));
790  eta_vec_MID.push_back(float(result.eta(sample,TFCSExtrapolationState::SUBPOS_MID)));
791  phi_vec_ENT.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_ENT)));
792  phi_vec_EXT.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_EXT)));
793  phi_vec_MID.push_back(float(result.phi(sample,TFCSExtrapolationState::SUBPOS_MID)));
794  r_vec_ENT.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_ENT)));
795  r_vec_EXT.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_EXT)));
796  r_vec_MID.push_back(float(result.r(sample,TFCSExtrapolationState::SUBPOS_MID)));
797  z_vec_ENT.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_ENT)));
798  z_vec_EXT.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_EXT)));
799  z_vec_MID.push_back(float(result.z(sample,TFCSExtrapolationState::SUBPOS_MID)));
800  detaBorder_vec_ENT.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_ENT)));
801  detaBorder_vec_EXT.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_EXT)));
802  detaBorder_vec_MID.push_back(float(result.detaBorder(sample,TFCSExtrapolationState::SUBPOS_MID)));
803  OK_vec_ENT.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_ENT));
804  OK_vec_EXT.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_EXT));
805  OK_vec_MID.push_back(result.OK(sample,TFCSExtrapolationState::SUBPOS_MID));
806  }
807 
808  m_newTTC_back_eta->push_back(eta_vec_EXT);
809  m_newTTC_back_phi->push_back(phi_vec_EXT);
810  m_newTTC_back_r ->push_back(r_vec_EXT);
811  m_newTTC_back_z ->push_back(z_vec_EXT);
812  m_newTTC_back_detaBorder ->push_back(detaBorder_vec_EXT);
813  m_newTTC_back_OK ->push_back(OK_vec_EXT);
814  m_newTTC_entrance_eta->push_back(eta_vec_ENT);
815  m_newTTC_entrance_phi->push_back(phi_vec_ENT);
816  m_newTTC_entrance_r ->push_back(r_vec_ENT);
817  m_newTTC_entrance_z ->push_back(z_vec_ENT);
818  m_newTTC_entrance_detaBorder ->push_back(detaBorder_vec_ENT);
819  m_newTTC_entrance_OK ->push_back(OK_vec_ENT);
820  m_newTTC_mid_eta->push_back(eta_vec_MID);
821  m_newTTC_mid_phi->push_back(phi_vec_MID);
822  m_newTTC_mid_r ->push_back(r_vec_MID);
823  m_newTTC_mid_z ->push_back(z_vec_MID);
824  m_newTTC_mid_detaBorder ->push_back(detaBorder_vec_MID);
825  m_newTTC_mid_OK ->push_back(OK_vec_MID);
826 
827  m_truth_energy->push_back((part)->momentum().e());
828  m_truth_px->push_back((part)->momentum().px());
829  m_truth_py->push_back((part)->momentum().py());
830  m_truth_pz->push_back((part)->momentum().pz());
831  m_truth_pdg->push_back((part)->pdg_id());
832  m_truth_barcode->push_back(HepMC::barcode(part));
833 
834  } //for mcevent
835  } //mcevent size
836  } //mcEvent
837  }//truth event
838 
839  //Retrieve and save MuonEntryLayer information
840  const TrackRecordCollection *MuonEntry = nullptr;
841  sc = evtStore()->retrieve(MuonEntry, "MuonEntryLayer");
842  if (sc.isFailure())
843  {
844  ATH_MSG_WARNING( "Couldn't read MuonEntry from StoreGate");
845  //return NULL;
846  }
847  else{
848  for ( const TrackRecord &record : *MuonEntry){
849  m_MuonEntryLayer_E->push_back((record).GetEnergy());
850  m_MuonEntryLayer_px->push_back((record).GetMomentum().getX());
851  m_MuonEntryLayer_py->push_back((record).GetMomentum().getY());
852  m_MuonEntryLayer_pz->push_back((record).GetMomentum().getZ());
853  m_MuonEntryLayer_x->push_back((record).GetPosition().getX());
854  m_MuonEntryLayer_y->push_back((record).GetPosition().getY());
855  m_MuonEntryLayer_z->push_back((record).GetPosition().getZ());
856  m_MuonEntryLayer_pdg->push_back((record).GetPDGCode());
857  }
858  }
859 
860  // Get the reco clusters if available
861 // retreiving cluster container
862  const xAOD::CaloClusterContainer* theClusters;
863  std::string clusterContainerName = "CaloCalTopoClusters"; //Local hadron calibrated Topo-clusters , raw is the EM scale
864  sc = evtStore()->retrieve(theClusters, clusterContainerName);
865  if (sc.isFailure()) {
866  ATH_MSG_WARNING(" Couldn't get cluster container '" << clusterContainerName << "'");
867  return StatusCode::SUCCESS;
868  }
869  xAOD::CaloClusterContainer::const_iterator itrClus = theClusters->begin();
870  xAOD::CaloClusterContainer::const_iterator itrLastClus = theClusters->end();
871  for ( ; itrClus!=itrLastClus; ++itrClus){
872  const xAOD::CaloCluster *cluster =(*itrClus);
873  m_cluster_energy->push_back(cluster->e(xAOD::CaloCluster::UNCALIBRATED)); // getRawE, cluster->e() is the Local hadron calibrated topo-clusters
874  m_cluster_eta->push_back(cluster->eta(xAOD::CaloCluster::UNCALIBRATED));
875  m_cluster_phi->push_back(cluster->phi(xAOD::CaloCluster::UNCALIBRATED));
876  ATH_MSG_VERBOSE("Cluster energy: " << cluster->e() << " EMscale: " << cluster->e(xAOD::CaloCluster::UNCALIBRATED) << " cells: " << " links: " << cluster->getCellLinks());
877 
878  const CaloClusterCellLink* cellLinks = cluster->getCellLinks();
879  if (!cellLinks) {
880  ATH_MSG_DEBUG( "No cell links for this cluster" );
881  continue;
882  }
883 
884  const CaloCellContainer* cellCont=cellLinks->getCellContainer();
885  if (!cellCont) {
886  ATH_MSG_DEBUG( "DataLink to cell container is broken" );
887  continue;
888  }
889  unsigned cellcount = 0;
890  std::vector<Long64_t> cellIDs_in_cluster;
891  xAOD::CaloCluster::const_cell_iterator cellIter =cluster->cell_begin();
892  xAOD::CaloCluster::const_cell_iterator cellIterEnd =cluster->cell_end();
893  for ( ;cellIter !=cellIterEnd;cellIter++) {
894  ++cellcount;
895  const CaloCell* cell= (*cellIter);
896  cellIDs_in_cluster.push_back(cell->ID().get_compact());
897  float EnergyCell=cell->energy(); //ID, time, phi, eta
898  ATH_MSG_DEBUG(" Cell energy: " << EnergyCell);
899  }// end of cells inside cluster loop
900  m_cluster_size->push_back(cellcount);
901  m_cluster_cellID->push_back(cellIDs_in_cluster);
902  }
903 
904  //Get reco cells if available
905  const CaloCellContainer *cellColl = nullptr;
906  sc = evtStore()->retrieve(cellColl, "AllCalo");
907 
908  if (sc.isFailure())
909  {
910  ATH_MSG_WARNING( "Couldn't read AllCalo cells from StoreGate");
911  }
912  else
913  {
914  ATH_MSG_INFO( "Found: "<<cellColl->size()<<" calorimeter cells");
915  CaloCellContainer::const_iterator itrCell = cellColl->begin();
916  CaloCellContainer::const_iterator itrLastCell = cellColl->end();
917  for ( ; itrCell!=itrLastCell; ++itrCell)
918  {
919  m_cell_energy->push_back((*itrCell)->energy());
920  m_cell_identifier->push_back((*itrCell)->ID().get_compact());
921  if (m_tileID->is_tile_aux((*itrCell)->ID())) {
922  // special case for E4'
923  m_cell_sampling->push_back(CaloCell_ID::TileGap3);
924  }
925  else if (calo_dd_man->get_element((*itrCell)->ID()))
926  {
927  // all other Tile cells
928  CaloCell_ID::CaloSample layer = calo_dd_man->get_element((*itrCell)->ID())->getSampling();
929  m_cell_sampling->push_back(layer);
930  }
931  else
932  m_cell_sampling->push_back(-1);
933  }
934  } //calorimeter cells
935 
936  //Get all G4Hits (from CaloHitAnalysis)
937  std::string lArKey [4] = {"LArHitEMB", "LArHitEMEC", "LArHitFCAL", "LArHitHEC"};
938  for (unsigned int i=0;i<4;i++)
939  {
940  const LArHitContainer* iter;
941  ATH_MSG_DEBUG( "Checking G4Hits: "<<lArKey[i]);
942  if(evtStore()->retrieve(iter,lArKey[i])==StatusCode::SUCCESS)
943  {
944  LArHitContainer::const_iterator hi;
945  int hitnumber = 0;
946  for (hi=(*iter).begin();hi!=(*iter).end();++hi) {
947  hitnumber++;
948  const LArHit* larHit = *hi;
949  const CaloDetDescrElement *hitElement = calo_dd_man->get_element(larHit->cellID());
950  if(!hitElement)
951  continue;
952  Identifier larhitid = hitElement->identify();
953  if(calo_dd_man->get_element(larhitid)) {
954  CaloCell_ID::CaloSample larlayer = calo_dd_man->get_element(larhitid)->getSampling();
955 
956  float larsampfrac=fSampl->FSAMPL(larhitid);
957  m_g4hit_energy->push_back( larHit->energy() );
958  m_g4hit_time->push_back( larHit->time() );
959  m_g4hit_identifier->push_back( larhitid.get_compact() );
960  m_g4hit_cellidentifier->push_back( larhitid.get_compact() );
961  m_g4hit_sampling->push_back( larlayer);
962  m_g4hit_samplingfraction->push_back( larsampfrac );
963  }
964  } // End while LAr hits
965  ATH_MSG_INFO( "Read "<<hitnumber<<" G4Hits from "<<lArKey[i]);
966  }
967  else
968  {
969  ATH_MSG_INFO( "Can't retrieve LAr hits");
970  }// End statuscode success upon retrieval of hits
971  //std::cout <<"ZH G4Hit size: "<<m_g4hit_e->size()<<std::endl;
972  }// End detector type loop
973 
974  const TileHitVector * hitVec = nullptr;
975  if (evtStore()->retrieve(hitVec,"TileHitVec")==StatusCode::SUCCESS && m_tileMgr && m_tileID )
976  {
977  int hitnumber = 0;
978  for(TileHitVecConstIterator i_hit=hitVec->begin() ; i_hit!=hitVec->end() ; ++i_hit)
979  {
980  hitnumber++;
981  Identifier pmt_id = (*i_hit).identify();
982  Identifier cell_id = m_tileID->cell_id(pmt_id);
983 
984  if (calo_dd_man->get_element(cell_id)){
985  CaloCell_ID::CaloSample layer = calo_dd_man->get_element(cell_id)->getSampling();
986 
987  HWIdentifier channel_id = m_tileCabling->s2h_channel_id(pmt_id);
988  int channel = m_tileHWID->channel(channel_id);
989  int drawerIdx = m_tileHWID->drawerIdx(channel_id);
990  float tilesampfrac = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
991 
992  //could there be more subhits??
993  for (int tilesubhit_i = 0; tilesubhit_i<(*i_hit).size(); tilesubhit_i++)
994  {
995  m_g4hit_energy->push_back( (*i_hit).energy(tilesubhit_i) );
996  m_g4hit_time->push_back( (*i_hit).time(tilesubhit_i) );
997  m_g4hit_identifier->push_back( pmt_id.get_compact() );
998  m_g4hit_cellidentifier->push_back( cell_id.get_compact() );
999  m_g4hit_sampling->push_back( layer );
1000  m_g4hit_samplingfraction->push_back( tilesampfrac );
1001  }
1002  }
1003  }
1004  ATH_MSG_INFO( "Read "<<hitnumber<<" G4Hits from TileHitVec");
1005  }
1006 
1007 
1008  // CaloHitAna
1009  ATH_MSG_DEBUG("CaloHitAna begin!");
1010 
1011  //cells
1012  for (unsigned int cell_i = 0; cell_i < m_cell_identifier->size(); cell_i++){
1013  if (cells.find((*m_cell_identifier)[cell_i]) == cells.end()) { //doesn't exist
1014  one_cell.cell_identifier = (*m_cell_identifier)[cell_i];
1015  one_cell.sampling = (*m_cell_sampling)[cell_i];
1016  one_cell.energy = (*m_cell_energy)[cell_i];
1017  one_cell.center_x = 0.0; //for now
1018  one_cell.center_y = 0.0;
1019  one_cell.center_z = 0.0;
1020  cells.insert(std::pair<Long64_t, FCS_cell>(one_cell.cell_identifier, one_cell));
1021  }
1022  else
1023  {
1024  //there shouldn't be a cell with the same identifier in this event
1025  ATH_MSG_DEBUG("ISF_HitAnalysis: Same cell???? ERROR");
1026  }
1027  }
1028 
1029  // g4 hits
1030  if(m_doG4Hits){
1031  for (unsigned int g4hit_i = 0; g4hit_i < m_g4hit_identifier->size(); g4hit_i++)
1032  {
1033  if ((*m_g4hit_sampling)[g4hit_i] >= 0 && (*m_g4hit_sampling)[g4hit_i] <= 25 && (*m_g4hit_time)[g4hit_i] > m_TimingCut)
1034  {
1035  ATH_MSG_DEBUG("Ignoring G4hit, time too large: " << g4hit_i << " time: " << (*m_g4hit_time)[g4hit_i]);
1036  continue;
1037  }
1038 
1039  if (g4hits.find((*m_g4hit_cellidentifier)[g4hit_i]) == g4hits.end())
1040  {
1041  //this G4 hit doesn't exist yet
1042  one_g4hit.identifier = (*m_g4hit_identifier)[g4hit_i];
1043  one_g4hit.cell_identifier = (*m_g4hit_cellidentifier)[g4hit_i];
1044  one_g4hit.sampling = (*m_g4hit_sampling)[g4hit_i];
1045  one_g4hit.hit_time = (*m_g4hit_time)[g4hit_i];
1046  //scale the hit energy with the sampling fraction
1047  if (one_g4hit.sampling >= 12 && one_g4hit.sampling <= 20)
1048  { //tile
1049  if ((*m_g4hit_samplingfraction)[g4hit_i])
1050  {
1051  one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] * (*m_g4hit_samplingfraction)[g4hit_i];
1052  }
1053  else one_g4hit.hit_energy = 0.;
1054  }
1055  else
1056  {
1057  one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] / (*m_g4hit_samplingfraction)[g4hit_i];
1058  }
1059  g4hits.insert(std::pair<Long64_t, std::vector<FCS_g4hit> >(one_g4hit.cell_identifier, std::vector<FCS_g4hit>(1, one_g4hit)));
1060  }
1061  else
1062  {
1063  //G4 hit exists in this identifier -> push_back new to the vector //FCS_g4hit one_g4hit;
1064  one_g4hit.identifier = (*m_g4hit_identifier)[g4hit_i];
1065  one_g4hit.cell_identifier = (*m_g4hit_cellidentifier)[g4hit_i];
1066  one_g4hit.sampling = (*m_g4hit_sampling)[g4hit_i];
1067  one_g4hit.hit_time = (*m_g4hit_time)[g4hit_i];
1068  if (one_g4hit.sampling >= 12 && one_g4hit.sampling <= 20)
1069  { //tile
1070  if ((*m_g4hit_samplingfraction)[g4hit_i])
1071  {
1072  one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] * (*m_g4hit_samplingfraction)[g4hit_i];
1073  }
1074  else one_g4hit.hit_energy = 0.;
1075  }
1076  else
1077  {
1078  one_g4hit.hit_energy = (*m_g4hit_energy)[g4hit_i] / (*m_g4hit_samplingfraction)[g4hit_i];
1079  }
1080  g4hits[(*m_g4hit_cellidentifier)[g4hit_i]].push_back(one_g4hit);
1081  }
1082  }
1083  }
1084 
1085  //hits
1086  for (unsigned int hit_i = 0; hit_i < m_hit_identifier->size(); hit_i++)
1087  {
1088  if ((*m_hit_sampling)[hit_i] >= 0 && (*m_hit_sampling)[hit_i] <= 25 && (*m_hit_time)[hit_i] > m_TimingCut)
1089  {
1090  ATH_MSG_DEBUG("Ignoring FCS hit, time too large: " << hit_i << " time: " << (*m_hit_time)[hit_i]);
1091  continue;
1092  }
1093  if (hits.find((*m_hit_cellidentifier)[hit_i]) == hits.end())
1094  {
1095  //Detailed hit doesn't exist yet
1096  one_hit.identifier = (*m_hit_identifier)[hit_i];
1097  one_hit.cell_identifier = (*m_hit_cellidentifier)[hit_i];
1098  one_hit.sampling = (*m_hit_sampling)[hit_i];
1099 
1100  if (one_hit.sampling >= 12 && one_hit.sampling <= 20)
1101  { //tile
1102  if ((*m_hit_samplingfraction)[hit_i])
1103  {
1104  one_hit.hit_energy = (*m_hit_energy)[hit_i] * (*m_hit_samplingfraction)[hit_i];
1105  }
1106  else one_hit.hit_energy = 0.;
1107  }
1108  else
1109  {
1110  one_hit.hit_energy = (*m_hit_energy)[hit_i] / (*m_hit_samplingfraction)[hit_i];
1111  }
1112  //one_hit.hit_sampfrac = (*m_hit_samplingfraction)[hit_i];
1113  one_hit.hit_time = (*m_hit_time)[hit_i];
1114  one_hit.hit_x = (*m_hit_x)[hit_i];
1115  one_hit.hit_y = (*m_hit_y)[hit_i];
1116  one_hit.hit_z = (*m_hit_z)[hit_i];
1117  hits.insert(std::pair<Long64_t, std::vector<FCS_hit> >(one_hit.cell_identifier, std::vector<FCS_hit>(1, one_hit)));
1118  }
1119  else
1120  {
1121  //Detailed hit exists in this identifier -> push_back new to the vector
1122  one_hit.identifier = (*m_hit_identifier)[hit_i];
1123  one_hit.cell_identifier = (*m_hit_cellidentifier)[hit_i];
1124  one_hit.sampling = (*m_hit_sampling)[hit_i];
1125  //one_hit.hit_energy = (*m_hit_energy)[hit_i];
1126  if (one_hit.sampling >= 12 && one_hit.sampling <= 20)
1127  { //tile
1128  if ((*m_hit_samplingfraction)[hit_i])
1129  {
1130  one_hit.hit_energy = (*m_hit_energy)[hit_i] * (*m_hit_samplingfraction)[hit_i];
1131  }
1132  else one_hit.hit_energy = 0.;
1133  }
1134  else
1135  {
1136  one_hit.hit_energy = (*m_hit_energy)[hit_i] / (*m_hit_samplingfraction)[hit_i];
1137  }
1138  //one_hit.hit_sampfrac = (*m_hit_samplingfraction)[hit_i];
1139  one_hit.hit_time = (*m_hit_time)[hit_i];
1140  one_hit.hit_x = (*m_hit_x)[hit_i];
1141  one_hit.hit_y = (*m_hit_y)[hit_i];
1142  one_hit.hit_z = (*m_hit_z)[hit_i];
1143  hits[(*m_hit_cellidentifier)[hit_i]].push_back(one_hit);
1144  }
1145  }
1146 
1147  //Start matching:
1148  for (std::map<Long64_t, FCS_cell>::iterator it = cells.begin(); it != cells.end(); )
1149  {
1150  one_matchedcell.clear(); //maybe not completely necessery, as we're not pushing_back into vectors
1151  //set the cell part
1152  one_matchedcell.cell = it->second;
1153  //now look for FCS detailed hits in this cell
1154  std::map<Long64_t, std::vector<FCS_hit> >::iterator it2 = hits.find(it->first);
1155  if (it2 != hits.end())
1156  {
1157  //std::cout <<"FCS hits found in this cell"<<std::endl;
1158  one_matchedcell.hit = it2->second;
1159  hits.erase(it2); //remove it
1160  }
1161  else
1162  {
1163  //no hit found for this cell
1164  one_matchedcell.hit.clear(); //important!
1165  }
1166  //now look for G4hits in this cell
1167  std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it3 = g4hits.find(it->first);
1168  if (it3 != g4hits.end())
1169  {
1170  one_matchedcell.g4hit = it3->second;
1171  g4hits.erase(it3);
1172  }
1173  else
1174  {
1175  //no g4hit found for this cell
1176  one_matchedcell.g4hit.clear();//important!
1177  }
1178  cells.erase(it++);
1179  //push_back matched cell for event jentry
1180  m_oneeventcells->push_back(one_matchedcell);
1181  }
1182 
1183  //ok, cells should be empty, what about hits and g4hits?
1184  //There could be G4hits/FCS hits for which we don't have a cell ->create a dummy empty cell with 0 energy, take the cell identifier from the hit
1185  ATH_MSG_DEBUG("ISF_HitAnalysis Check after cells: " << cells.size() << " " << g4hits.size() << " " << hits.size());
1186 
1187  for (std::map<Long64_t, std::vector<FCS_hit> >::iterator it = hits.begin(); it != hits.end();)
1188  {
1189  one_matchedcell.clear();
1190  one_matchedcell.cell.cell_identifier = it->first;
1191  //std::cout <<"This hit didn't exist in cell: "<<it->first<<std::endl;
1192  if (!it->second.empty())
1193  {
1194  one_matchedcell.cell.sampling = (it->second)[0].sampling;
1195  }
1196  else
1197  {
1198  one_matchedcell.cell.sampling = -1; //
1199  //ok, but you really shouldn't be here
1200  ATH_MSG_DEBUG("ERROR: You shouldn't really be here");
1201  }
1202  one_matchedcell.cell.energy = 0.;
1203  one_matchedcell.cell.center_x = 0.0;
1204  one_matchedcell.cell.center_y = 0.0;
1205  one_matchedcell.cell.center_z = 0.0;
1206  one_matchedcell.hit = it->second;
1207  std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it3 = g4hits.find(it->first);
1208  if (it3 != g4hits.end())
1209  {
1210  one_matchedcell.g4hit = it3->second;
1211  g4hits.erase(it3);
1212  }
1213  else
1214  {
1215  //no g4hit found for this cell
1216  one_matchedcell.g4hit.clear(); //important!
1217  }
1218  hits.erase(it++);
1219  m_oneeventcells->push_back(one_matchedcell);
1220 
1221  }
1222 
1223  //ok, hits should be empty, what about g4hits?
1224  ATH_MSG_DEBUG("ISF_HitAnalysis Check after hits: " << cells.size() << " " << g4hits.size() << " " << hits.size());
1225  for (std::map<Long64_t, std::vector<FCS_g4hit> >::iterator it = g4hits.begin(); it != g4hits.end();)
1226  {
1227  one_matchedcell.clear(); //maybe not so important
1228  one_matchedcell.cell.cell_identifier = it->first;
1229  if (!it->second.empty())
1230  {
1231  one_matchedcell.cell.sampling = (it->second)[0].sampling;
1232  }
1233  else
1234  {
1235  one_matchedcell.cell.sampling = -1; //
1236  //not really
1237  ATH_MSG_DEBUG("ERROR: You shouldn't really be here");
1238  }
1239  one_matchedcell.cell.energy = 0.;
1240  one_matchedcell.cell.center_x = 0.0;
1241  one_matchedcell.cell.center_y = 0.0;
1242  one_matchedcell.cell.center_z = 0.0;
1243  one_matchedcell.g4hit = it->second;
1244  one_matchedcell.hit.clear(); //important!!
1245  g4hits.erase(it++);
1246  m_oneeventcells->push_back(one_matchedcell);
1247  }
1248 
1249  //Can fill the output tree already here:
1250  m_total_cell_e = 0;
1251  m_total_hit_e = 0;
1252  m_total_g4hit_e = 0;
1253 
1254  for (int j = 0; j < MAX_LAYER - 1; j++)
1255  {
1256  m_layercells[j]->m_vector = m_oneeventcells->GetLayer(j);
1257  }
1258 
1259  //this is for invalid cells
1260  m_layercells[MAX_LAYER - 1]->m_vector = m_oneeventcells->GetLayer(-1);
1261  for (int i = 0; i < MAX_LAYER; i++)
1262  {
1263  m_final_cell_energy->push_back(0.0); //zero for each event!
1264  m_final_hit_energy->push_back(0.0);
1265  m_final_g4hit_energy->push_back(0.0);
1266 
1267  for (unsigned int cellindex = 0; cellindex < m_layercells[i]->size(); cellindex++)
1268  {
1269  if (i != MAX_LAYER - 1)
1270  {
1271  m_final_cell_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).cell.energy;
1272  m_total_cell_e += m_layercells[i]->m_vector.at(cellindex).cell.energy;
1273  }
1274  else
1275  {
1276  //don't add the energy in the invalid layer to the total energy (if there is any (shouldn't)
1277  m_final_cell_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).cell.energy; //this should be here anyway
1278  }
1279 
1280  //sum energy of all FCS detailed hits in this layer/cell
1281  for (unsigned int j = 0; j < m_layercells[i]->m_vector.at(cellindex).hit.size(); j++)
1282  {
1283  if (i != MAX_LAYER - 1)
1284  {
1285  m_total_hit_e += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1286  m_final_hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1287  }
1288  else
1289  {
1290  //again, don't add invalid layer energy to the sum
1291  m_final_hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).hit[j].hit_energy;
1292  }
1293  }
1294 
1295  //sum energy of all G4 hits in this layer/cell
1296  for (unsigned int j = 0; j < m_layercells[i]->m_vector.at(cellindex).g4hit.size(); j++)
1297  {
1298  if (i != MAX_LAYER - 1)
1299  {
1300  m_total_g4hit_e += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1301  m_final_g4hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1302  }
1303  else
1304  {
1305  //don't add invalied layer energy to the sum
1306  m_final_g4hit_energy->at(i) += m_layercells[i]->m_vector.at(cellindex).g4hit[j].hit_energy;
1307  }
1308  }
1309  }
1310  }
1311 
1312  // push_back for total energy
1313  m_final_cell_energy->push_back(0.0);
1314  m_final_hit_energy->push_back(0.0);
1315  m_final_g4hit_energy->push_back(0.0);
1316 
1317  m_final_cell_energy->at(MAX_LAYER) = m_total_cell_e;
1318  m_final_hit_energy->at(MAX_LAYER) = m_total_hit_e;
1319  m_final_g4hit_energy->at(MAX_LAYER) = m_total_g4hit_e;
1320 
1321  //Fill the tree and finish
1322  if (m_tree) m_tree->Fill();
1323 
1324  return StatusCode::SUCCESS;
1325 
1326 } //execute
1327 
1328 std::vector<Trk::HitInfo>* ISF_HitAnalysis::caloHits(const HepMC::GenParticle& part) const
1329 {
1330  // Start calo extrapolation
1331  ATH_MSG_DEBUG ("[ fastCaloSim transport ] processing particle "<<part.pdg_id() );
1332 
1333  std::vector<Trk::HitInfo>* hitVector = new std::vector<Trk::HitInfo>;
1334 
1335  int pdgId = part.pdg_id();
1336  double charge = HepPDT::ParticleID(pdgId).charge();
1337 
1338  // particle Hypothesis for the extrapolation
1339  Trk::ParticleHypothesis pHypothesis = m_pdgToParticleHypothesis.convert(pdgId,charge);
1340 
1341  ATH_MSG_DEBUG ("particle hypothesis "<< pHypothesis );
1342 
1343  // geantinos not handled by PdgToParticleHypothesis - fix there
1344  if( pdgId == 999 ) pHypothesis = Trk::geantino;
1345 
1346  auto vtx = part.production_vertex();
1347  Amg::Vector3D pos(0.,0.,0.); // default
1348 
1349  if (vtx)
1350  {
1351  pos = Amg::Vector3D( vtx->position().x(),vtx->position().y(), vtx->position().z());
1352  }
1353 
1354  Amg::Vector3D mom(part.momentum().x(),part.momentum().y(),part.momentum().z());
1355  ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting transport from position eta="<<pos.eta()<<" phi="<<pos.phi()<<" d="<<pos.mag()<<" pT="<<mom.perp() );
1356 
1357  // input parameters : curvilinear parameters
1358  Trk::CurvilinearParameters inputPar(pos,mom,charge);
1359 
1360  // stable vs. unstable check : ADAPT for FASTCALOSIM
1361  //double freepath = ( !m_particleDecayHelper.empty()) ? m_particleDecayHelper->freePath(isp) : - 1.;
1362  double freepath = -1.;
1363  //ATH_MSG_VERBOSE( "[ fatras transport ] Particle free path : " << freepath);
1364  // path limit -> time limit ( TODO : extract life-time directly from decay helper )
1365  double tDec = freepath > 0. ? freepath : -1.;
1366  int decayProc = 0;
1367 
1368  /* uncomment if unstable particles used by FastCaloSim
1369  // beta calculated here for further use in validation
1370  double mass = m_particleMasses.mass[pHypothesis];
1371  double mom = isp.momentum().mag();
1372  double beta = mom/sqrt(mom*mom+mass*mass);
1373 
1374  if ( tDec>0.)
1375  {
1376  tDec = tDec/beta/CLHEP::c_light + isp.timeStamp();
1377  decayProc = 201;
1378  }
1379  */
1380 
1381  Trk::TimeLimit timeLim(tDec,0.,decayProc); // TODO: set vertex time info
1382 
1383  // prompt decay ( uncomment if unstable particles used )
1384  //if ( freepath>0. && freepath<0.01 ) {
1385  // if (!m_particleDecayHelper.empty()) {
1386  // ATH_MSG_VERBOSE( "[ fatras transport ] Decay is triggered for input particle.");
1387  // m_particleDecayHelper->decay(isp);
1388  // }
1389  // return 0;
1390  //}
1391 
1392  // presample interactions - ADAPT FOR FASTCALOSIM
1393  Trk::PathLimit pathLim(-1.,0);
1394  //if (absPdg!=999 && pHypothesis<99) pathLim = m_samplingTool->sampleProcess(mom,isp.charge(),pHypothesis);
1395 
1396  Trk::GeometrySignature nextGeoID=Trk::Calo;
1397 
1398  // first extrapolation to reach the ID boundary
1399  ATH_MSG_DEBUG( "[ fastCaloSim transport ] before calo entrance ");
1400 
1401  // get CaloEntrance if not done already
1402  if (!m_caloEntrance.get())
1403  {
1404  m_caloEntrance.set(m_extrapolator->trackingGeometry()->trackingVolume(m_caloEntranceName));
1405  if(!m_caloEntrance.get())
1406  ATH_MSG_INFO("CaloEntrance not found ");
1407  else
1408  ATH_MSG_INFO("CaloEntrance found ");
1409  }
1410 
1411  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo entrance ");
1412 
1413  std::unique_ptr<const Trk::TrackParameters> caloEntry = nullptr;
1414 
1415  if(m_caloEntrance.get() && m_caloEntrance.get()->inside(pos,0.001) && !m_extrapolator->trackingGeometry()->atVolumeBoundary(pos,m_caloEntrance.get(),0.001))
1416  {
1417  std::vector<Trk::HitInfo>* dummyHitVector = nullptr;
1418  if (charge == 0) {
1419  caloEntry =
1420  m_extrapolator->transportNeutralsWithPathLimit(inputPar,
1421  pathLim,
1422  timeLim,
1423  Trk::alongMomentum,
1424  pHypothesis,
1425  dummyHitVector,
1426  nextGeoID,
1427  m_caloEntrance.get());
1428  } else {
1429  caloEntry = m_extrapolator->extrapolateWithPathLimit(inputPar,
1430  pathLim,
1431  timeLim,
1432  Trk::alongMomentum,
1433  pHypothesis,
1434  dummyHitVector,
1435  nextGeoID,
1436  m_caloEntrance.get());
1437  }
1438  } else{
1439  caloEntry = inputPar.uniqueClone();
1440  }
1441 
1442  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo caloEntry ");
1443 
1444  if(caloEntry)
1445  {
1446  std::unique_ptr<const Trk::TrackParameters> eParameters = nullptr;
1447 
1448  // save Calo entry hit (fallback info)
1449  hitVector->push_back(Trk::HitInfo(caloEntry->uniqueClone(),timeLim.time,nextGeoID,0.));
1450 
1451  ATH_MSG_DEBUG( "[ fastCaloSim transport ] starting Calo transport from position eta="<<caloEntry->position().eta()<<" phi="<<caloEntry->position().phi()<<" d="<<caloEntry->position().mag() );
1452 
1453  if (charge == 0) {
1454  eParameters =
1455  m_extrapolator->transportNeutralsWithPathLimit(*caloEntry,
1456  pathLim,
1457  timeLim,
1458  Trk::alongMomentum,
1459  pHypothesis,
1460  hitVector,
1461  nextGeoID);
1462  } else {
1463  eParameters = m_extrapolator->extrapolateWithPathLimit(*caloEntry,
1464  pathLim,
1465  timeLim,
1466  Trk::alongMomentum,
1467  pHypothesis,
1468  hitVector,
1469  nextGeoID);
1470  }
1471  // save Calo exit hit (fallback info)
1472  if (eParameters) hitVector->push_back(Trk::HitInfo(std::move(eParameters),timeLim.time,nextGeoID,0.));
1473  //delete eParameters; // HitInfo took ownership
1474  }
1475 
1476  if(msgLvl(MSG::DEBUG))
1477  {
1478  std::vector<Trk::HitInfo>::iterator it = hitVector->begin();
1479  while (it < hitVector->end() )
1480  {
1481  int sample=(*it).detID;
1482  Amg::Vector3D hitPos = (*it).trackParms->position();
1483  ATH_MSG_DEBUG(" HIT: layer="<<sample<<" sample="<<sample-3000<<" eta="<<hitPos.eta()<<" phi="<<hitPos.phi()<<" d="<<hitPos.mag());
1484  ++it;
1485  }
1486  }
1487 
1488  return hitVector;
1489 } //caloHits
ISF_HitAnalysis::m_truth_vtxbarcode
std::vector< int > * m_truth_vtxbarcode
Definition: ISF_HitAnalysis.h:158
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
ISF_HitAnalysis::m_MuonEntryLayer_E
std::vector< float > * m_MuonEntryLayer_E
Definition: ISF_HitAnalysis.h:228
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
TileSamplingFraction::getSamplingFraction
float getSamplingFraction(unsigned int drawerIdx, unsigned int channel) const
Return Tile Calorimeter sampling fraction.
Definition: TileSamplingFraction.h:53
Tile_Base_ID::is_tile_aux
bool is_tile_aux(const Identifier &id) const
Definition: Tile_Base_ID.cxx:236
beamspotman.r
def r
Definition: beamspotman.py:672
ISF_HitAnalysis::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition: ISF_HitAnalysis.h:240
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:281
CaloDetDescrManager_Base::element_range
calo_element_range element_range() const
Range over element vector.
Definition: CaloDetDescrManager.cxx:123
ISF_HitAnalysis::m_newTTC_back_detaBorder
std::vector< std::vector< float > > * m_newTTC_back_detaBorder
Definition: ISF_HitAnalysis.h:213
ISF_HitAnalysis::m_truth_pz
std::vector< float > * m_truth_pz
Definition: ISF_HitAnalysis.h:155
EnergyLoss.h
ISF_HitAnalysis::m_FastCaloSimCaloExtrapolation
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation
The FastCaloSimCaloExtrapolation tool.
Definition: ISF_HitAnalysis.h:113
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
xAOD::CaloCluster_v1::cell_begin
const_cell_iterator cell_begin() const
Iterator of the underlying CaloClusterCellLink (const version)
Definition: CaloCluster_v1.h:815
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
FCS_StepInfoCollection.h
ISF_HitAnalysis::m_newTTC_entrance_eta
std::vector< std::vector< float > > * m_newTTC_entrance_eta
Definition: ISF_HitAnalysis.h:203
LArEM_ID.h
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
get_generator_info.result
result
Definition: get_generator_info.py:21
test_pyathena.px
px
Definition: test_pyathena.py:18
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
ISF_HitAnalysis::m_final_hit_energy
std::vector< Float_t > * m_final_hit_energy
Definition: ISF_HitAnalysis.h:187
DiscBounds.h
TrackParameters.h
ISF_HitAnalysis::m_cluster_phi
std::vector< float > * m_cluster_phi
Definition: ISF_HitAnalysis.h:162
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ISF_HitAnalysis::m_cell_energy
std::vector< float > * m_cell_energy
Definition: ISF_HitAnalysis.h:168
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ISF_HitAnalysis::m_cluster_energy
std::vector< float > * m_cluster_energy
Definition: ISF_HitAnalysis.h:160
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ISF_HitAnalysis::m_CaloBoundaryZ
DoubleProperty m_CaloBoundaryZ
Definition: ISF_HitAnalysis.h:115
Trk::PdgToParticleHypothesis::convert
Trk::ParticleHypothesis convert(int pdg, bool &stable, bool &exiting, double charge=1.) const
Converter method : PDG -> Particle Hyptothesis.
ISF_HitAnalysis::m_newTTC_Angle3D
std::vector< float > * m_newTTC_Angle3D
Definition: ISF_HitAnalysis.h:225
CaloCell_ID_FCS::FirstSample
@ FirstSample
Definition: FastCaloSim_CaloCell_ID.h:18
ISF_HitAnalysis::m_newTTC_mid_r
std::vector< std::vector< float > > * m_newTTC_mid_r
Definition: ISF_HitAnalysis.h:217
ISF_HitAnalysis::m_newTTC_entrance_r
std::vector< std::vector< float > > * m_newTTC_entrance_r
Definition: ISF_HitAnalysis.h:205
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:834
Tile_Base_ID::is_tile_gap
bool is_tile_gap(const Identifier &id) const
Definition: Tile_Base_ID.cxx:227
FCS_matchedcell::clear
void clear()
Definition: FCS_Cell.h:61
TileHitVecConstIterator
AtlasHitsVector< TileHit >::const_iterator TileHitVecConstIterator
Definition: TileHitVector.h:30
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
FCS_matchedcell::cell
FCS_cell cell
Definition: FCS_Cell.h:58
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
ATLAS_NOT_THREAD_SAFE
StatusCode ISF_HitAnalysis::initialize ATLAS_NOT_THREAD_SAFE()
Install fatal handler with default options.
Definition: ISF_HitAnalysis.cxx:80
ISF_HitAnalysis::m_tileID
const TileID * m_tileID
Definition: ISF_HitAnalysis.h:130
ISF_HitAnalysis::ISF_HitAnalysis
ISF_HitAnalysis(const std::string &name, ISvcLocator *pSvcLocator)
Definition: ISF_HitAnalysis.cxx:65
ISF_HitAnalysis::m_oneeventcells
FCS_matchedcellvector * m_oneeventcells
Definition: ISF_HitAnalysis.h:179
ISF_HitAnalysis::m_TimingCut
IntegerProperty m_TimingCut
Definition: ISF_HitAnalysis.h:123
initialize
void initialize()
Definition: run_EoverP.cxx:894
FCS_g4hit
Definition: FCS_Cell.h:47
ISF_HitAnalysis.h
ISF_HitAnalysis::m_MuonEntryLayer_pz
std::vector< float > * m_MuonEntryLayer_pz
Definition: ISF_HitAnalysis.h:231
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
FCS_hit
Definition: FCS_Cell.h:34
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ISF_HitAnalysis::m_truth_barcode
std::vector< int > * m_truth_barcode
Definition: ISF_HitAnalysis.h:157
hitVector
std::vector< FPGATrackSimHit > hitVector
Definition: FPGATrackSimCluster.h:22
ISF_HitAnalysis::MAX_LAYER
static const int MAX_LAYER
Definition: ISF_HitAnalysis.h:76
AtlasHitsVector
Definition: AtlasHitsVector.h:32
skel.it
it
Definition: skel.GENtoEVGEN.py:407
ISF_HitAnalysis::m_caloEntranceName
StringProperty m_caloEntranceName
Definition: ISF_HitAnalysis.h:111
ISF_HitAnalysis::m_islarendcap
std::vector< bool > * m_islarendcap
Definition: ISF_HitAnalysis.h:145
CaloDepthTool.h
Declaration of CaloDepthTool. Created by Claire Bourdarios, 25.10.2004.
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_eta
std::vector< float > * m_newTTC_IDCaloBoundary_eta
Definition: ISF_HitAnalysis.h:221
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
CaloCell_ID_FCS::EME1
@ EME1
Definition: FastCaloSim_CaloCell_ID.h:24
Identifier::get_compact
value_type get_compact() const
Get the compact id.
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
Tile_Base_ID::is_tile_extbarrel
bool is_tile_extbarrel(const Identifier &id) const
Definition: Tile_Base_ID.cxx:218
ISF_HitAnalysis::m_hit_samplingfraction
std::vector< float > * m_hit_samplingfraction
Definition: ISF_HitAnalysis.h:150
TileInfo.h
LArHit::energy
double energy() const
Definition: LArHit.h:113
LArHitContainer
Hit collection.
Definition: LArHitContainer.h:26
IExtrapolator.h
TFCSExtrapolationState::SUBPOS_ENT
@ SUBPOS_ENT
Definition: TFCSExtrapolationState.h:21
ISF_HitAnalysis::m_final_cell_energy
std::vector< Float_t > * m_final_cell_energy
Definition: ISF_HitAnalysis.h:186
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
ISF_HitAnalysis::m_cell_sampling
std::vector< int > * m_cell_sampling
Definition: ISF_HitAnalysis.h:169
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:111
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_z
std::vector< float > * m_newTTC_IDCaloBoundary_z
Definition: ISF_HitAnalysis.h:224
ISF_HitAnalysis::m_hit_x
std::vector< float > * m_hit_x
Simple variables by Ketevi.
Definition: ISF_HitAnalysis.h:137
TFCSExtrapolationState
Definition: TFCSExtrapolationState.h:13
TFCSExtrapolationState::SUBPOS_MID
@ SUBPOS_MID
Definition: TFCSExtrapolationState.h:20
xAOD::identifier
identifier
Definition: UncalibratedMeasurement_v1.cxx:15
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LArHEC_ID.h
CaloCell_ID_FCS::EME2
@ EME2
Definition: FastCaloSim_CaloCell_ID.h:25
HWIdentifier
Definition: HWIdentifier.h:13
Trk::Calo
@ Calo
Definition: GeometrySignature.h:28
AtlasHitsVector::begin
const_iterator begin() const
Definition: AtlasHitsVector.h:130
x
#define x
ISF_HitAnalysis::m_hit_sampling
std::vector< int > * m_hit_sampling
Definition: ISF_HitAnalysis.h:149
TFCSExtrapolationState::SUBPOS_EXT
@ SUBPOS_EXT
Definition: TFCSExtrapolationState.h:22
AthenaAttributeList.h
ISF_HitAnalysis::m_hit_identifier
std::vector< Long64_t > * m_hit_identifier
Definition: ISF_HitAnalysis.h:142
ISF_HitAnalysis::m_MuonEntryLayer_x
std::vector< float > * m_MuonEntryLayer_x
Definition: ISF_HitAnalysis.h:232
ISF_HitAnalysis::m_islarbarrel
std::vector< bool > * m_islarbarrel
Definition: ISF_HitAnalysis.h:144
ISF_HitAnalysis::m_istile
std::vector< bool > * m_istile
Definition: ISF_HitAnalysis.h:148
FCS_matchedcell::g4hit
std::vector< FCS_g4hit > g4hit
Definition: FCS_Cell.h:59
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
TFCSTruthState::vertex
const TLorentzVector & vertex() const
Definition: TFCSTruthState.h:28
ISF_HitAnalysis::m_g4hit_identifier
std::vector< Long64_t > * m_g4hit_identifier
Definition: ISF_HitAnalysis.h:173
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
ISF_HitAnalysis::m_newTTC_entrance_OK
std::vector< std::vector< bool > > * m_newTTC_entrance_OK
Definition: ISF_HitAnalysis.h:208
TileID.h
TileDetDescrManager.h
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CxxUtils::CachedPointer::set
void set(pointer_t elt) const
Set the element, assuming it is currently null.
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
RTTAlgmain.branchname
string branchname
Definition: RTTAlgmain.py:60
ISF_HitAnalysis::m_newTTC_mid_z
std::vector< std::vector< float > > * m_newTTC_mid_z
Definition: ISF_HitAnalysis.h:218
AthenaHitsVector< LArHit >::const_iterator
boost::transform_iterator< make_const, typename CONT::const_iterator > const_iterator
Definition: AthenaHitsVector.h:67
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_r
std::vector< float > * m_newTTC_IDCaloBoundary_r
Definition: ISF_HitAnalysis.h:223
ReadCellNoiseFromCool.tile
tile
Definition: ReadCellNoiseFromCool.py:92
ISF_HitAnalysis::m_tileHWID
const TileHWID * m_tileHWID
Definition: ISF_HitAnalysis.h:131
ISF_HitAnalysis::m_hit_energy
std::vector< float > * m_hit_energy
Definition: ISF_HitAnalysis.h:140
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:28
ISF_HitAnalysis::m_cluster_size
std::vector< unsigned > * m_cluster_size
Definition: ISF_HitAnalysis.h:163
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ISF_HitAnalysis::m_newTTC_entrance_phi
std::vector< std::vector< float > > * m_newTTC_entrance_phi
Definition: ISF_HitAnalysis.h:204
ISF_HitAnalysis::m_total_g4hit_e
Float_t m_total_g4hit_e
Definition: ISF_HitAnalysis.h:184
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
CaloCell_ID_FCS::MaxSample
@ MaxSample
Definition: FastCaloSim_CaloCell_ID.h:47
Trk::GeometrySignature
GeometrySignature
Definition: GeometrySignature.h:24
ISF_HitAnalysis::m_layercells
FCS_matchedcellvector * m_layercells[MAX_LAYER]
Definition: ISF_HitAnalysis.h:180
FCS_cell::center_x
float center_x
Definition: FCS_Cell.h:35
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
ISF_HitAnalysis::m_cluster_eta
std::vector< float > * m_cluster_eta
Definition: ISF_HitAnalysis.h:161
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ISF_HitAnalysis::m_hit_y
std::vector< float > * m_hit_y
Definition: ISF_HitAnalysis.h:138
FCS_matchedcell
Definition: FCS_Cell.h:57
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
McEventCollection.h
FCS_cell::sampling
int sampling
Definition: FCS_Cell.h:33
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
ISF_HitAnalysis::m_newTTC_IDCaloBoundary_phi
std::vector< float > * m_newTTC_IDCaloBoundary_phi
Definition: ISF_HitAnalysis.h:222
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
CaloCluster.h
z
#define z
ISF_HitAnalysis::m_g4hit_sampling
std::vector< int > * m_g4hit_sampling
Definition: ISF_HitAnalysis.h:176
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArHit::time
double time() const
Definition: LArHit.h:118
ISF_HitAnalysis::m_total_cell_e
Float_t m_total_cell_e
Definition: ISF_HitAnalysis.h:182
createCoolChannelIdFile.channel_id
channel_id
Definition: createCoolChannelIdFile.py:51
CylinderSurface.h
Trk::geantino
@ geantino
Definition: ParticleHypothesis.h:29
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
ISF_HitAnalysis::m_MuonEntryLayer_pdg
std::vector< int > * m_MuonEntryLayer_pdg
Definition: ISF_HitAnalysis.h:235
ISF_HitAnalysis::m_newTTC_back_z
std::vector< std::vector< float > > * m_newTTC_back_z
Definition: ISF_HitAnalysis.h:212
jobOptions.ParticleID
ParticleID
Definition: jobOptions.decayer.py:85
ISF_HitAnalysis::m_larFcalID
const LArFCAL_ID * m_larFcalID
Definition: ISF_HitAnalysis.h:128
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FCS_cell::center_z
float center_z
Definition: FCS_Cell.h:37
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table. The name and type of eac...
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:45
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:690
ISF_HitAnalysis::m_final_g4hit_energy
std::vector< Float_t > * m_final_g4hit_energy
Definition: ISF_HitAnalysis.h:188
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:824
FCS_cell::cell_identifier
Long64_t cell_identifier
Definition: FCS_Cell.h:32
ISF_HitAnalysis::m_NtruthParticles
IntegerProperty m_NtruthParticles
Definition: ISF_HitAnalysis.h:106
ISF_HitAnalysis::m_g4hit_cellidentifier
std::vector< Long64_t > * m_g4hit_cellidentifier
Definition: ISF_HitAnalysis.h:174
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
ISF_HitAnalysis::m_tileCabling
const TileCablingService * m_tileCabling
Definition: ISF_HitAnalysis.h:132
ISF_HitAnalysis::m_newTTC_back_eta
std::vector< std::vector< float > > * m_newTTC_back_eta
Definition: ISF_HitAnalysis.h:209
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:32
Trk::TimeLimit
Definition: HelperStructs.h:58
ISF_HitAnalysis::m_tileSamplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_tileSamplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: ISF_HitAnalysis.h:95
ISF_HitAnalysis::m_newTTC_entrance_detaBorder
std::vector< std::vector< float > > * m_newTTC_entrance_detaBorder
Definition: ISF_HitAnalysis.h:207
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
FCS_matchedcellvector::size
unsigned int size()
Definition: FCS_Cell.h:77
xAOD::CaloCluster_v1::getCellLinks
const CaloClusterCellLink * getCellLinks() const
Get a pointer to the CaloClusterCellLink object (const version)
Definition: CaloCluster_v1.cxx:829
AthAlgorithm
Definition: AthAlgorithm.h:47
ISF_HitAnalysis::m_newTTC_back_phi
std::vector< std::vector< float > > * m_newTTC_back_phi
Definition: ISF_HitAnalysis.h:210
ISF_HitAnalysis::m_MuonEntryLayer_y
std::vector< float > * m_MuonEntryLayer_y
Definition: ISF_HitAnalysis.h:233
ISF_HitAnalysis::m_cell_identifier
std::vector< Long64_t > * m_cell_identifier
Definition: ISF_HitAnalysis.h:167
LArHit::cellID
Identifier cellID() const
Definition: LArHit.h:108
FCS_matchedcellvector
Definition: FCS_Cell.h:71
xAOD::CaloCluster_v1::UNCALIBRATED
@ UNCALIBRATED
Definition: CaloCluster_v1.h:309
ISF_HitAnalysis::m_total_hit_e
Float_t m_total_hit_e
Definition: ISF_HitAnalysis.h:183
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Amg::py
@ py
Definition: GeoPrimitives.h:39
TileHitVector.h
ISF_HitAnalysis::execute
virtual StatusCode execute() override
Definition: ISF_HitAnalysis.cxx:481
TileHit.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ISF_HitAnalysis::m_islarfcal
std::vector< bool > * m_islarfcal
Definition: ISF_HitAnalysis.h:147
TileHWID::drawerIdx
int drawerIdx(const HWIdentifier &id) const
construct drawer index from HW identifier
Definition: TileHWID.h:175
ISF_HitAnalysis::m_doG4Hits
BooleanProperty m_doG4Hits
Definition: ISF_HitAnalysis.h:122
ISF_HitAnalysis::m_CaloBoundaryR
DoubleProperty m_CaloBoundaryR
Definition: ISF_HitAnalysis.h:114
ISF_HitAnalysis::m_newTTC_entrance_z
std::vector< std::vector< float > > * m_newTTC_entrance_z
Definition: ISF_HitAnalysis.h:206
TrackRecordCollection.h
charge
double charge(const T &p)
Definition: AtlasPID.h:997
runIDPVM.pdgId
pdgId
Definition: runIDPVM.py:91
FCS_cell::energy
float energy
Definition: FCS_Cell.h:34
ISF_HitAnalysis::~ISF_HitAnalysis
~ISF_HitAnalysis()
Trk::PathLimit
Definition: HelperStructs.h:34
ISF_HitAnalysis::m_hit_z
std::vector< float > * m_hit_z
Definition: ISF_HitAnalysis.h:139
LArHit
Class to store hit energy and time in LAr cell from G4 simulation.
Definition: LArHit.h:25
ISF_HitAnalysis::m_newTTC_AngleEta
std::vector< float > * m_newTTC_AngleEta
Definition: ISF_HitAnalysis.h:226
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
ISF_HitAnalysis::m_MuonEntryLayer_z
std::vector< float > * m_MuonEntryLayer_z
Definition: ISF_HitAnalysis.h:234
TrackRecord
Definition: TrackRecord.h:12
ISF_HitAnalysis::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition: ISF_HitAnalysis.h:90
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
LArFCAL_ID.h
ISF_HitAnalysis::m_tree
TTree * m_tree
Definition: ISF_HitAnalysis.h:190
ISF_HitAnalysis::m_truth_energy
std::vector< float > * m_truth_energy
Definition: ISF_HitAnalysis.h:152
ISF_HitAnalysis::m_hit_cellidentifier
std::vector< Long64_t > * m_hit_cellidentifier
Definition: ISF_HitAnalysis.h:143
TFCSTruthState.h
y
#define y
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
FCS_matchedcellvector::GetLayer
std::vector< FCS_matchedcell > GetLayer(int layer)
Definition: FCS_Cell.h:75
ISF_HitAnalysis::m_MuonEntryLayer_px
std::vector< float > * m_MuonEntryLayer_px
Definition: ISF_HitAnalysis.h:229
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
ISF_HitAnalysis::m_newTTC_mid_phi
std::vector< std::vector< float > > * m_newTTC_mid_phi
Definition: ISF_HitAnalysis.h:216
FCS_cell
Definition: FCS_Cell.h:23
LArEM_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArHitContainer.h
ISF_HitAnalysis::m_extrapolator
PublicToolHandle< Trk::ITimedExtrapolator > m_extrapolator
Definition: ISF_HitAnalysis.h:109
TFCSExtrapolationState.h
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
AtlasHitsVector::end
const_iterator end() const
Definition: AtlasHitsVector.h:133
LArCellConditions.geo
bool geo
Definition: LArCellConditions.py:46
ISF_HitAnalysis::m_newTTC_mid_OK
std::vector< std::vector< bool > > * m_newTTC_mid_OK
Definition: ISF_HitAnalysis.h:220
ISF_HitAnalysis::m_cluster_cellID
std::vector< std::vector< Long64_t > > * m_cluster_cellID
Definition: ISF_HitAnalysis.h:164
DEBUG
#define DEBUG
Definition: page_access.h:11
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
xAOD::CaloCluster_v1::cell_end
const_cell_iterator cell_end() const
Definition: CaloCluster_v1.h:816
ISF_HitAnalysis::m_hit_time
std::vector< float > * m_hit_time
Definition: ISF_HitAnalysis.h:141
TFCSTruthState::set_vertex
void set_vertex(const TLorentzVector &val)
Definition: TFCSTruthState.h:19
ISF_HitAnalysis::m_tileMgr
const TileDetDescrManager * m_tileMgr
Definition: ISF_HitAnalysis.h:134
FCS_cell::center_y
float center_y
Definition: FCS_Cell.h:36
ISF_HitAnalysis::caloHits
std::vector< Trk::HitInfo > * caloHits(const HepMC::GenParticle &part) const
Definition: ISF_HitAnalysis.cxx:1328
CaloClusterContainer.h
Trk::TimeLimit::time
float time
Definition: HelperStructs.h:60
DiscSurface.h
CxxUtils::CachedPointer::get
pointer_t get() const
Return the current value of the element.
ISF_HitAnalysis::m_newTTC_back_OK
std::vector< std::vector< bool > > * m_newTTC_back_OK
Definition: ISF_HitAnalysis.h:214
ISF_HitAnalysis::m_islarhec
std::vector< bool > * m_islarhec
Definition: ISF_HitAnalysis.h:146
FCS_matchedcellvector::m_vector
std::vector< FCS_matchedcell > m_vector
Definition: FCS_Cell.h:74
ISF_FCS_Parametrization::FCS_StepInfoCollection
Class for collection of StepInfo class (G4 hits) copied and modified version to ISF.
Definition: FCS_StepInfoCollection.h:30
FCS_matchedcellvector::push_back
void push_back(const FCS_matchedcell &cell)
Definition: FCS_Cell.h:78
CaloIdManager.h
TrackingGeometry.h
Trk::HitInfo
Definition: HelperStructs.h:12
ISF_HitAnalysis::m_truth_pdg
std::vector< int > * m_truth_pdg
Definition: ISF_HitAnalysis.h:156
ISF_HitAnalysis::m_newTTC_mid_detaBorder
std::vector< std::vector< float > > * m_newTTC_mid_detaBorder
Definition: ISF_HitAnalysis.h:219
ISF_HitAnalysis::m_newTTC_back_r
std::vector< std::vector< float > > * m_newTTC_back_r
Definition: ISF_HitAnalysis.h:211
GetEnergy
int GetEnergy()
Definition: GetEnergy.cxx:81
ISF_HitAnalysis::m_larEmID
const LArEM_ID * m_larEmID
Definition: ISF_HitAnalysis.h:127
ISF_HitAnalysis::m_surfacelist
std::vector< CaloCell_ID_FCS::CaloSample > m_surfacelist
Definition: ISF_HitAnalysis.h:244
Tile_Base_ID::is_tile_barrel
bool is_tile_barrel(const Identifier &id) const
Test of an Identifier to see if it belongs to a particular part of the calorimeter.
Definition: Tile_Base_ID.cxx:209
ISF_HitAnalysis::m_g4hit_energy
std::vector< float > * m_g4hit_energy
Definition: ISF_HitAnalysis.h:171
Tile_Base_ID::cell_id
Identifier cell_id(const Identifier &any_id) const
Definition: Tile_Base_ID.cxx:585
ISF_HitAnalysis::m_g4hit_time
std::vector< float > * m_g4hit_time
Definition: ISF_HitAnalysis.h:172
FCS_matchedcell::hit
std::vector< FCS_hit > hit
Definition: FCS_Cell.h:60
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CaloClusterCellLink::const_iterator
const_iterator to loop over cells belonging to a cluster
Definition: CaloClusterCellLink.h:57
ISF_HitAnalysis::m_caloEntrance
CxxUtils::CachedPointer< const Trk::TrackingVolume > m_caloEntrance
The new Extrapolator setup.
Definition: ISF_HitAnalysis.h:238
ISF_HitAnalysis::m_truth_py
std::vector< float > * m_truth_py
Definition: ISF_HitAnalysis.h:154
TFCSTruthState
Definition: TFCSTruthState.h:13
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:813
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
ISF_HitAnalysis::m_truth_px
std::vector< float > * m_truth_px
Definition: ISF_HitAnalysis.h:153
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
ISF_HitAnalysis::m_larHecID
const LArHEC_ID * m_larHecID
Definition: ISF_HitAnalysis.h:129
LArEM_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
ISF_HitAnalysis::m_newTTC_mid_eta
std::vector< std::vector< float > > * m_newTTC_mid_eta
Definition: ISF_HitAnalysis.h:215
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
ILArfSampl
Definition: ILArfSampl.h:14
TileCablingService::s2h_channel_id
HWIdentifier s2h_channel_id(const Identifier &id) const
Definition: TileCablingService.cxx:1076
ISF_HitAnalysis::m_g4hit_samplingfraction
std::vector< float > * m_g4hit_samplingfraction
Definition: ISF_HitAnalysis.h:175
ISF_HitAnalysis::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: ISF_HitAnalysis.h:86
ISF_HitAnalysis::m_MuonEntryLayer_py
std::vector< float > * m_MuonEntryLayer_py
Definition: ISF_HitAnalysis.h:230
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Oct 30 2025 21:11:49 for ATLAS Offline Software by   doxygen 1.8.18