ATLAS Offline Software
LarEMSamplingFraction.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
12 
13 #include "GaudiKernel/ServiceHandle.h"
14 #include "GaudiKernel/ITHistSvc.h"
15 #include "Gaudi/Property.h"
16 
18 
19 #include "TString.h"
20 #include <iterator>
21 #include <cmath>
22 #include <map>
23 
24 using namespace std;
25 
26 //###############################################################################
28  , ISvcLocator* pSvcLocator)
29  : AthAlgorithm(name, pSvcLocator)
30 {
31  // Name of ClusterContainer to use
32  declareProperty("DoCells",m_docells);
33  declareProperty("CalibrationHitContainerNames",m_CalibrationHitContainerNames);
34 }
35 
36 //###############################################################################
37 
39 { }
40 
41 //###############################################################################
42 
44 {
45  //---- initialize the StoreGateSvc ptr ----------------
46 
47  ServiceHandle<ITHistSvc> histSvc("THistSvc",name());
48  ATH_CHECK( histSvc.retrieve() );
49 
50  m_mytree = new TTree("mytree","mytree");
51  m_mytree->Branch("energy_reco", &m_energy_reco);
52  m_mytree->Branch("energy_hit", &m_energy_hit);
53  m_mytree->Branch("energy_inactive_total",&m_energy_inactive_total);
54  m_mytree->Branch("energy_inactive_em", &m_energy_inactive_em);
55  m_mytree->Branch("energy_inactive_nonem",&m_energy_inactive_nonem);
56  m_mytree->Branch("energy_inactive_inv", &m_energy_inactive_inv);
57  m_mytree->Branch("energy_inactive_esc", &m_energy_inactive_esc);
58  m_mytree->Branch("energy_active_total_corrected",&m_energy_active_total_corrected);
59  m_mytree->Branch("energy_active_total",&m_energy_active_total);
60  m_mytree->Branch("energy_active_em", &m_energy_active_em);
61  m_mytree->Branch("energy_active_nonem",&m_energy_active_nonem);
62  m_mytree->Branch("energy_active_inv", &m_energy_active_inv);
63  m_mytree->Branch("energy_active_esc", &m_energy_active_esc);
64  m_mytree->Branch("mc_pdg", &m_mc_pdg);
65  m_mytree->Branch("mc_eta", &m_mc_eta);
66  m_mytree->Branch("mc_phi", &m_mc_phi);
67  m_mytree->Branch("mc_e", &m_mc_e);
68  m_mytree->Branch("mc_pt", &m_mc_pt);
69 
70  if(m_docells) {
71  m_mytree->Branch("cell_identifier",&m_cell_identifier);
72  m_mytree->Branch("cell_energy_reco",&m_cell_energy_reco);
73  m_mytree->Branch("cell_energy_inactive_total",&m_cell_energy_inactive_total);
74  m_mytree->Branch("cell_energy_active_total_corrected",&m_cell_energy_active_total_corrected);
75  m_mytree->Branch("cell_energy_active_total",&m_cell_energy_active_total);
76  m_mytree->Branch("cell_sampling",&m_cell_sampling);
77  m_mytree->Branch("cell_eta",&m_cell_eta);
78  m_mytree->Branch("cell_phi",&m_cell_phi);
79  }
80 
81  histSvc->regTree("/MYSTREAM/myTree",m_mytree).ignore();
82 
83  // pointer to detector manager:
85  ATH_CHECK(detStore()->retrieve(m_calo_id, "CaloCell_ID"));
86 
87  const CaloIdManager* caloIdManager;
88  ATH_CHECK(detStore()->retrieve(caloIdManager));
89 
90  m_tileID=caloIdManager->getTileID();
91  if(m_tileID==0) throw std::runtime_error("ISF_HitAnalysis: Invalid Tile ID helper");
92 
94 
97 
98  ATH_CHECK( m_tileCablingSvc.retrieve() );
99  m_tileCabling = m_tileCablingSvc->cablingService();
100 
101  return StatusCode::SUCCESS;
102 }
103 
104 //###############################################################################
105 
107 {
108 
109  return StatusCode::SUCCESS;
110 }
111 
112 //###############################################################################
113 
115 {
117  const ILArfSampl* fSampl=*fSamplHdl;
118 
120  ATH_CHECK( tileSamplingFraction.isValid() );
121 
122  const CaloCalibrationHitContainer* cchc;
123  std::vector<const CaloCalibrationHitContainer *> v_cchc;
124  for (const std::string& containerName : m_CalibrationHitContainerNames) {
125  if ( !evtStore()->contains<CaloCalibrationHitContainer>(containerName))
126  {
127  ATH_MSG_ERROR("SG does not contain calibration hit container " << containerName);
128  return StatusCode::FAILURE;
129  }
130  else
131  {
132  StatusCode sc = evtStore()->retrieve(cchc,containerName);
133  if (sc.isFailure() )
134  {
135  ATH_MSG_ERROR("Cannot retrieve calibration hit container " << containerName);
136  return sc;
137  }
138  else
139  {
140  v_cchc.push_back(cchc);
141  }
142  }
143  }
144 
145  const McEventCollection* truthEvent{};
146  StatusCode sc = evtStore()->retrieve(truthEvent, "TruthEvent");
147  if (sc.isFailure()||!truthEvent)
148  {
149  ATH_MSG_ERROR("No McEventCollection found");
150  return StatusCode::FAILURE;
151  }
152  auto gen = *HepMC::begin(*truthEvent->at(0));
153  m_mc_pdg = gen->pdg_id();
154  m_mc_eta = gen->momentum().pseudoRapidity();
155  m_mc_phi = gen->momentum().phi();
156  m_mc_e = gen->momentum().e();
157  m_mc_pt = sqrt(pow(gen->momentum().px(),2)+pow(gen->momentum().py(),2));
158 
159  //inspiration:
160  //see https://gitlab.cern.ch/atlas/athena/blob/master/Calorimeter/CaloCalibHitRec/src/CalibHitToCaloCell.cxx
161  //and https://gitlab.cern.ch/atlas/athena/blob/master/Calorimeter/CaloCalibHitRec/src/CaloDmEnergy.cxx
162 
164  ATH_CHECK(caloMgrHandle.isValid());
165  const CaloDetDescrManager* caloMgr = *caloMgrHandle;
166 
167  m_energy_reco =new vector<float>;
168  m_energy_hit =new vector<float>;
169 
170  m_energy_inactive_total=new vector<float>;
171  m_energy_inactive_em =new vector<float>;
172  m_energy_inactive_nonem=new vector<float>;
173  m_energy_inactive_inv =new vector<float>;
174  m_energy_inactive_esc =new vector<float>;
175 
176  m_energy_active_total_corrected=new vector<float>;
177  m_energy_active_total=new vector<float>;
178  m_energy_active_em =new vector<float>;
179  m_energy_active_nonem=new vector<float>;
180  m_energy_active_inv =new vector<float>;
181  m_energy_active_esc =new vector<float>;
182 
183  if(m_docells) {
184  m_cell_identifier =new std::vector<Long64_t>;
185  m_cell_energy_reco =new std::vector<float>;
186  m_cell_energy_active_total_corrected=new std::vector<float>;
187  m_cell_energy_active_total =new std::vector<float>;
188  m_cell_energy_inactive_total =new std::vector<float>;
189  m_cell_sampling =new std::vector<int>;
190  m_cell_eta =new std::vector<float>;
191  m_cell_phi =new std::vector<float>;
192  }
193 
194  struct cell_info {
195  Long64_t cell_identifier=0;
196  float cell_energy_reco=0;
197  float cell_energy_active_total_corrected=0;
198  float cell_energy_active_total=0;
199  float cell_energy_inactive_total=0;
200  int cell_sampling=0;
201  float cell_eta=0;
202  float cell_phi=0;
203  };
204 
205  std::map< Long64_t , cell_info > cell_info_map;
206 
207  for(int s=0;s<24;s++)
208  {
209  m_energy_reco->push_back(0.0);
210  m_energy_hit->push_back(0.0);
211 
212  m_energy_inactive_total->push_back(0.0);
213  m_energy_inactive_em ->push_back(0.0);
214  m_energy_inactive_nonem->push_back(0.0);
215  m_energy_inactive_inv ->push_back(0.0);
216  m_energy_inactive_esc ->push_back(0.0);
217 
218  m_energy_active_total_corrected->push_back(0.0);
219  m_energy_active_total->push_back(0.0);
220  m_energy_active_em ->push_back(0.0);
221  m_energy_active_nonem->push_back(0.0);
222  m_energy_active_inv ->push_back(0.0);
223  m_energy_active_esc ->push_back(0.0);
224  }
225 
226  int count=0;
227  for (const CaloCalibrationHitContainer* calibHitContainer: v_cchc)
228  {
230  for(const CaloCalibrationHit* calibHit : *calibHitContainer)
231  {
232  Identifier id=calibHit->cellID();
233 
234  double Etot = calibHit->energyTotal();
235  double Eem = calibHit->energyEM();
236  double Enonem = calibHit->energyNonEM();
237  double Einv = calibHit->energyInvisible();
238  double Eesc = calibHit->energyEscaped();
239 
240  double Efactor=1.0;
241 
242  const CaloDetDescrElement* caloDDE = caloMgr->get_element(id);
243  int sampling=-1;
244  if(caloDDE) {
245  sampling = caloDDE->getSampling();
246 
247  if((sampling>=0 && sampling<=11) || (sampling>=21 && sampling<=23)) Efactor=1/fSampl->FSAMPL(id);
248  if((sampling>=12 && sampling<=20)) {
249  HWIdentifier channel_id = m_tileCabling->s2h_channel_id(id);
251  int drawerIdx = m_tileHWID->drawerIdx(channel_id);
252  Efactor = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
253  Identifier cell_id = m_tileID->cell_id(id);
254  if(caloMgr->get_element(cell_id)) {
255  id=cell_id;
256  }
257  }
258  }
259 
260  ATH_MSG_VERBOSE( "cellID "<<id<<" layer "<<sampling<<" energyTotal "<<Etot<<" Eem "<<Eem<<" Enonem "<<Enonem<<" Einv "<<Einv<<" Eesc "<<Eesc<<" Efactor="<<Efactor);
261 
262  if(sampling>=0 && sampling<=23)
263  {
264  if(m_docells) {
265  cell_info_map[id.get_compact()].cell_identifier=id.get_compact();
266  cell_info_map[id.get_compact()].cell_sampling=sampling;
267  cell_info_map[id.get_compact()].cell_eta=caloDDE->eta_raw();
268  cell_info_map[id.get_compact()].cell_phi=caloDDE->phi_raw();
269  }
270 
271  if(m_CalibrationHitContainerNames[count]=="LArCalibrationHitInactive" || m_CalibrationHitContainerNames[count]=="TileCalibHitInactiveCell")
272  {
273  m_energy_inactive_total->at(sampling)+=Etot;
274  m_energy_inactive_em ->at(sampling)+=Eem;
275  m_energy_inactive_nonem->at(sampling)+=Enonem;
276  m_energy_inactive_inv ->at(sampling)+=Einv;
277  m_energy_inactive_esc ->at(sampling)+=Eesc;
278 
279  if(m_docells) cell_info_map[id.get_compact()].cell_energy_inactive_total+=Etot;
280  }
281 
282  if(m_CalibrationHitContainerNames[count]=="LArCalibrationHitActive" || m_CalibrationHitContainerNames[count]=="TileCalibHitActiveCell")
283  {
284  m_energy_active_total_corrected->at(sampling)+=Etot*Efactor;
285  m_energy_active_total->at(sampling)+=Etot;
286  m_energy_active_em ->at(sampling)+=Eem;
287  m_energy_active_nonem->at(sampling)+=Enonem;
288  m_energy_active_inv ->at(sampling)+=Einv;
289  m_energy_active_esc ->at(sampling)+=Eesc;
290 
291  if(m_docells) {
292  cell_info_map[id.get_compact()].cell_energy_active_total_corrected+=Etot*Efactor;
293  cell_info_map[id.get_compact()].cell_energy_active_total+=Etot;
294  }
295  }
296 
297  }
298 
299  }
300 
301  count++;
302  }
303 
304  //Get reco cells if available
305  const CaloCellContainer *cellColl{};
306  sc = evtStore()->retrieve(cellColl, "AllCalo");
307 
308  if (sc.isFailure()) {
309  ATH_MSG_WARNING( "Couldn't read AllCalo cells from StoreGate");
310  //return NULL;
311  } else {
312  ATH_MSG_DEBUG( "Found: "<<cellColl->size()<<" calorimeter cells");
313  for (const CaloCell* cell : *cellColl) {
314  Identifier id=cell->ID();
315  const CaloDetDescrElement* caloDDE = caloMgr->get_element(id);
316  int sampling=-1;
317  if(caloDDE) {
318  sampling = caloDDE->getSampling();
319  m_energy_reco->at(sampling)+=cell->energy();
320  if((sampling>=12 && sampling<=20)) {
321  Identifier cell_id = m_tileID->cell_id(id);
322  if(caloMgr->get_element(cell_id)) {
323  id=cell_id;
324  }
325  }
326  }
327  if(m_docells) {
328  cell_info_map[id.get_compact()].cell_identifier=id.get_compact();
329  cell_info_map[id.get_compact()].cell_sampling=sampling;
330  cell_info_map[id.get_compact()].cell_eta=caloDDE->eta_raw();
331  cell_info_map[id.get_compact()].cell_phi=caloDDE->phi_raw();
332  cell_info_map[id.get_compact()].cell_energy_reco+=cell->energy();
333  }
334  }
335  } //calorimeter cells
336 
337 
338  //Get all G4Hits (from CaloHitAnalysis)
339  const std::vector<std::string> lArKeys = {"LArHitEMB", "LArHitEMEC", "LArHitFCAL", "LArHitHEC"};
340  for (const std::string& containerName: lArKeys) {
341  const LArHitContainer* larContainer{};
342  ATH_MSG_DEBUG( "Checking G4Hits: "<<containerName);
343  if(evtStore()->retrieve(larContainer,containerName)==StatusCode::SUCCESS) {
344  int hitnumber = 0;
345  for (const LArHit* larHit : *larContainer) {
346  hitnumber++;
347  const CaloDetDescrElement *hitElement = caloMgr->get_element(larHit->cellID());
348  if(!hitElement) continue;
349  Identifier larhitid = hitElement->identify();
350  if(caloMgr->get_element(larhitid)) {
351  CaloCell_ID::CaloSample larlayer = caloMgr->get_element(larhitid)->getSampling();
352  m_energy_hit->at(larlayer)+=larHit->energy();
353  }
354  } // End while LAr hits
355  ATH_MSG_DEBUG( "Read "<<hitnumber<<" G4Hits from "<<containerName);
356  }
357  else {
358  ATH_MSG_INFO( "Can't retrieve LAr hits");
359  }// End statuscode success upon retrieval of hits
360  }// End detector type loop
361 
362  const TileHitVector * hitVec{};
363  if (evtStore()->retrieve(hitVec,"TileHitVec")==StatusCode::SUCCESS && m_tileID ) {
364  int hitnumber = 0;
365  for(const TileHit& hit : *hitVec) {
366  ++hitnumber;
367  Identifier pmt_id = hit.identify();
368  Identifier cell_id = m_tileID->cell_id(pmt_id);
369 
370  if (caloMgr->get_element(cell_id)) {
371  CaloCell_ID::CaloSample layer = caloMgr->get_element(cell_id)->getSampling();
372 
373  //could there be more subhits??
374  for (int tilesubhit_i = 0; tilesubhit_i<hit.size(); tilesubhit_i++) {
376  ATH_MSG_DEBUG( "Tile subhit: "<<tilesubhit_i<<"/"<<hit.size()<< " E: "<<hit.energy(tilesubhit_i) );
377  m_energy_hit->at(layer) += hit.energy(tilesubhit_i);
378  }
379  }
380  }
381  ATH_MSG_DEBUG( "Read "<<hitnumber<<" G4Hits from TileHitVec");
382  }
383 
384  for(auto& cell:cell_info_map) {
385  m_cell_identifier ->push_back(cell.second.cell_identifier);
386  m_cell_sampling ->push_back(cell.second.cell_sampling);
387  m_cell_eta ->push_back(cell.second.cell_eta);
388  m_cell_phi ->push_back(cell.second.cell_phi);
389  m_cell_energy_reco ->push_back(cell.second.cell_energy_reco);
390  m_cell_energy_active_total_corrected->push_back(cell.second.cell_energy_active_total_corrected);
391  m_cell_energy_active_total ->push_back(cell.second.cell_energy_active_total);
392  m_cell_energy_inactive_total ->push_back(cell.second.cell_energy_inactive_total);
393  }
394 
395  m_mytree->Fill();
396 
397  delete m_energy_reco;
398  delete m_energy_hit;
400  delete m_energy_inactive_em;
402  delete m_energy_inactive_inv;
403  delete m_energy_inactive_esc;
404 
406  delete m_energy_active_total;
407  delete m_energy_active_em;
408  delete m_energy_active_nonem;
409  delete m_energy_active_inv;
410  delete m_energy_active_esc;
411 
412  if(m_docells) {
413  delete m_cell_identifier;
414  delete m_cell_energy_reco;
418  delete m_cell_sampling;
419  delete m_cell_eta;
420  delete m_cell_phi;
421  }
422 
423  return StatusCode::SUCCESS;
424 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LarEMSamplingFraction::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LarEMSamplingFraction.h:80
LarEMSamplingFraction::m_tileHWID
const TileHWID * m_tileHWID
Definition: LarEMSamplingFraction.h:88
TileSamplingFraction::getSamplingFraction
float getSamplingFraction(unsigned int drawerIdx, unsigned int channel) const
Return Tile Calorimeter sampling fraction.
Definition: TileSamplingFraction.h:53
CaloCalibrationHitContainer
Definition: CaloCalibrationHitContainer.h:25
LarEMSamplingFraction.h
LarEMSamplingFraction::m_mc_phi
double m_mc_phi
Definition: LarEMSamplingFraction.h:47
LarEMSamplingFraction::m_mc_eta
double m_mc_eta
Definition: LarEMSamplingFraction.h:46
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
LarEMSamplingFraction::m_mc_e
double m_mc_e
Definition: LarEMSamplingFraction.h:48
CaloCalibrationHit.h
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
LarEMSamplingFraction::m_energy_inactive_nonem
std::vector< float > * m_energy_inactive_nonem
Definition: LarEMSamplingFraction.h:65
LarEMSamplingFraction::m_energy_active_total
std::vector< float > * m_energy_active_total
Definition: LarEMSamplingFraction.h:70
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LarEMSamplingFraction::m_mc_pdg
int m_mc_pdg
Definition: LarEMSamplingFraction.h:45
LarEMSamplingFraction::m_cell_energy_inactive_total
std::vector< float > * m_cell_energy_inactive_total
Definition: LarEMSamplingFraction.h:55
LarEMSamplingFraction::finalize
virtual StatusCode finalize() override
Definition: LarEMSamplingFraction.cxx:106
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LarEMSamplingFraction::m_tileCablingSvc
ServiceHandle< TileCablingSvc > m_tileCablingSvc
Name of Tile cabling service.
Definition: LarEMSamplingFraction.h:102
LarEMSamplingFraction::m_cell_eta
std::vector< float > * m_cell_eta
Definition: LarEMSamplingFraction.h:57
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
AtlasHitsVector
Definition: AtlasHitsVector.h:33
McEventCollection
McEventCollection
Definition: GeneratorObjectsTPCnv.cxx:60
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
LArHitContainer
Hit collection.
Definition: LArHitContainer.h:26
LarEMSamplingFraction::m_tileSamplingFractionKey
SG::ReadCondHandleKey< TileSamplingFraction > m_tileSamplingFractionKey
Name of TileSamplingFraction in condition store.
Definition: LarEMSamplingFraction.h:96
LarEMSamplingFraction::m_docells
bool m_docells
Definition: LarEMSamplingFraction.h:43
LarEMSamplingFraction::execute
virtual StatusCode execute() override
Definition: LarEMSamplingFraction.cxx:114
LarEMSamplingFraction::~LarEMSamplingFraction
virtual ~LarEMSamplingFraction()
Definition: LarEMSamplingFraction.cxx:38
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
CaloCalibrationHitContainer.h
LarEMSamplingFraction::m_cell_identifier
std::vector< Long64_t > * m_cell_identifier
Definition: LarEMSamplingFraction.h:51
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
master.gen
gen
Definition: master.py:32
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
LarEMSamplingFraction::m_energy_inactive_total
std::vector< float > * m_energy_inactive_total
Definition: LarEMSamplingFraction.h:63
LarEMSamplingFraction::m_CalibrationHitContainerNames
std::vector< std::string > m_CalibrationHitContainerNames
Definition: LarEMSamplingFraction.h:78
LarEMSamplingFraction::LarEMSamplingFraction
LarEMSamplingFraction()
Default constructor:
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CaloIdManager::getTileID
const TileID * getTileID(void) const
Definition: CaloIdManager.cxx:100
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:64
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LarEMSamplingFraction::m_energy_active_total_corrected
std::vector< float > * m_energy_active_total_corrected
Definition: LarEMSamplingFraction.h:69
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
LarEMSamplingFraction::m_energy_active_esc
std::vector< float > * m_energy_active_esc
Definition: LarEMSamplingFraction.h:74
LarEMSamplingFraction::initialize
virtual StatusCode initialize() override
Definition: LarEMSamplingFraction.cxx:43
McEventCollection.h
LarEMSamplingFraction::m_energy_active_inv
std::vector< float > * m_energy_active_inv
Definition: LarEMSamplingFraction.h:73
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
LarEMSamplingFraction::m_calo_id
const CaloCell_ID * m_calo_id
Definition: LarEMSamplingFraction.h:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LarEMSamplingFraction::m_energy_inactive_inv
std::vector< float > * m_energy_inactive_inv
Definition: LarEMSamplingFraction.h:66
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
LarEMSamplingFraction::m_cell_phi
std::vector< float > * m_cell_phi
Definition: LarEMSamplingFraction.h:58
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LarEMSamplingFraction::m_mc_pt
double m_mc_pt
Definition: LarEMSamplingFraction.h:49
createCoolChannelIdFile.channel_id
channel_id
Definition: createCoolChannelIdFile.py:52
MuonSegmentReaderConfig.histSvc
histSvc
Definition: MuonSegmentReaderConfig.py:96
LarEMSamplingFraction::m_cell_energy_active_total_corrected
std::vector< float > * m_cell_energy_active_total_corrected
Definition: LarEMSamplingFraction.h:53
LarEMSamplingFraction::m_tileID
const TileID * m_tileID
Definition: LarEMSamplingFraction.h:87
LarEMSamplingFraction::m_energy_reco
std::vector< float > * m_energy_reco
Definition: LarEMSamplingFraction.h:60
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LarEMSamplingFraction::m_energy_active_em
std::vector< float > * m_energy_active_em
Definition: LarEMSamplingFraction.h:71
LarEMSamplingFraction::m_mytree
TTree * m_mytree
Definition: LarEMSamplingFraction.h:76
AthAlgorithm
Definition: AthAlgorithm.h:47
LarEMSamplingFraction::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition: LarEMSamplingFraction.h:91
LarEMSamplingFraction::m_cell_sampling
std::vector< int > * m_cell_sampling
Definition: LarEMSamplingFraction.h:56
CaloCalibrationHit
Class to store calorimeter calibration hit.
Definition: CaloCalibrationHit.h:23
TileHitVector.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TileHWID::drawerIdx
int drawerIdx(const HWIdentifier &id) const
construct drawer index from HW identifier
Definition: TileHWID.h:175
LarEMSamplingFraction::m_tileCabling
const TileCablingService * m_tileCabling
Definition: LarEMSamplingFraction.h:89
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TileHit
Definition: TileSimEvent/TileSimEvent/TileHit.h:30
LArHit
Class to store hit energy and time in LAr cell from G4 simulation.
Definition: LArHit.h:25
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
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
LarEMSamplingFraction::m_cell_energy_active_total
std::vector< float > * m_cell_energy_active_total
Definition: LarEMSamplingFraction.h:54
LarEMSamplingFraction::m_energy_active_nonem
std::vector< float > * m_energy_active_nonem
Definition: LarEMSamplingFraction.h:72
HepMC::begin
GenEvent::particle_iterator begin(HepMC::GenEvent &e)
Definition: GenEvent.h:620
LarEMSamplingFraction::m_energy_inactive_esc
std::vector< float > * m_energy_inactive_esc
Definition: LarEMSamplingFraction.h:67
Tile_Base_ID::cell_id
Identifier cell_id(const Identifier &any_id) const
Definition: Tile_Base_ID.cxx:581
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
LarEMSamplingFraction::m_cell_energy_reco
std::vector< float > * m_cell_energy_reco
Definition: LarEMSamplingFraction.h:52
LarEMSamplingFraction::m_energy_hit
std::vector< float > * m_energy_hit
Definition: LarEMSamplingFraction.h:61
LarEMSamplingFraction::m_energy_inactive_em
std::vector< float > * m_energy_inactive_em
Definition: LarEMSamplingFraction.h:64
ILArfSampl
Definition: ILArfSampl.h:14
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
TileCablingService::s2h_channel_id
HWIdentifier s2h_channel_id(const Identifier &id) const
Definition: TileCablingService.cxx:1076
ServiceHandle< ITHistSvc >
Identifier
Definition: IdentifierFieldParser.cxx:14