Loading [MathJax]/jax/output/SVG/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Functions
ISF_HitAnalysis.cxx File Reference
#include "./ISF_HitAnalysis.h"
#include "ISF_FastCaloSimEvent/TFCSTruthState.h"
#include "ISF_FastCaloSimEvent/TFCSExtrapolationState.h"
#include "LArSimEvent/LArHitContainer.h"
#include "CaloDetDescr/CaloDetDescrElement.h"
#include "AthenaPoolUtilities/AthenaAttributeList.h"
#include "CaloIdentifier/CaloIdManager.h"
#include "CaloIdentifier/LArEM_ID.h"
#include "CaloIdentifier/LArFCAL_ID.h"
#include "CaloIdentifier/LArHEC_ID.h"
#include "TileConditions/TileInfo.h"
#include "TileDetDescr/TileDetDescrManager.h"
#include "CaloIdentifier/TileID.h"
#include "TileIdentifier/TileHWID.h"
#include "TileSimEvent/TileHit.h"
#include "TileSimEvent/TileHitVector.h"
#include "TrackRecord/TrackRecordCollection.h"
#include "CaloEvent/CaloCellContainer.h"
#include "CaloEvent/CaloClusterCellLinkContainer.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODCaloEvent/CaloCluster.h"
#include "ISF_FastCaloSimEvent/FCS_StepInfoCollection.h"
#include "GeneratorObjects/McEventCollection.h"
#include "CaloDetDescr/CaloDepthTool.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkSurfaces/CylinderSurface.h"
#include "TrkSurfaces/DiscSurface.h"
#include "TrkSurfaces/DiscBounds.h"
#include "TrkExInterfaces/IExtrapolator.h"
#include "TrkMaterialOnTrack/EnergyLoss.h"
#include "TrkGeometry/TrackingGeometry.h"
#include "HepPDT/ParticleData.hh"
#include "TTree.h"
#include "TFile.h"
#include "TString.h"
#include "TVector3.h"
#include <sstream>
#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>

Go to the source code of this file.

Functions

StatusCode ISF_HitAnalysis::initialize ATLAS_NOT_THREAD_SAFE ()
 Install fatal handler with default options. More...
 

Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

StatusCode ISF_HitAnalysis::initialize ATLAS_NOT_THREAD_SAFE ( )
inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

now add branches and leaves to the tree

now add branches and leaves to the tree

Definition at line 80 of file ISF_HitAnalysis.cxx.

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
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RTTAlgmain.branchname
string branchname
Definition: RTTAlgmain.py:60
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FCS_matchedcellvector
Definition: FCS_Cell.h:73
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Generated on Sun Mar 30 2025 21:24:49 for ATLAS Offline Software by   doxygen 1.8.18