ATLAS Offline Software
TileLookForMuAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //***************************************************************************
6 // Filename : TileLookForMuAlg.cxx
7 // Author : G Usai
8 // Created : June 2003
9 //***************************************************************************
10 
11 // Tile includes
12 #include "TileMuId/TileLookForMuAlg.h"
13 #include "TileEvent/TileCell.h"
14 
15 // Calo includes
16 #include "CaloIdentifier/TileID.h"
17 #include "CaloIdentifier/CaloCell_ID.h"
18 
19 // Athena includes
20 #include "AthenaKernel/errorcheck.h"
21 #include "StoreGate/ReadHandle.h"
22 #include "StoreGate/WriteHandle.h"
23 
24 //Library Includes
25 #include <algorithm>
26 #include <cmath>
27 
28 TileLookForMuAlg::TileLookForMuAlg(const std::string& name,
29  ISvcLocator* pSvcLocator)
30  : AthReentrantAlgorithm(name, pSvcLocator)
31  , m_tileID(0)
32  , m_etaD()
33  , m_etaBC()
34  , m_etaA()
35  , m_nMuMax(30)
36 {
37  declareProperty("LowerTresh0MeV", m_loThrA=80.0);
38  declareProperty("LowerTresh1MeV", m_loThrBC=80.0);
39  declareProperty("LowerTresh2MeV", m_loThrD=80.0);
40  declareProperty("LowerTreshScinMeV", m_loThrITC=160.0);
41  declareProperty("UpperTresh2MeV", m_hiThrD);
42  declareProperty("UpperTresh1MeV", m_hiThrBC);
43  declareProperty("UpperTresh0MeV", m_hiThrA);
44  declareProperty("From3to2", m_fromDtoBC);
45  declareProperty("From2to1", m_fromBCtoA);
46 
47 }
48 
49 TileLookForMuAlg::~TileLookForMuAlg() {
50 }
51 
53 //Initialization /
55 StatusCode TileLookForMuAlg::initialize() {
56 
57  // retrieve TileID helper and TileIfno from det store
58 
59  CHECK( detStore()->retrieve(m_tileID) );
60 
61 
62  // define a numbering scheme for the cells
63  double eta_D = -1.2;
64  for (int iCellD = 0; iCellD < N_CELLS_D; ++iCellD) {
65  m_etaD[iCellD] = eta_D;
66  eta_D += 0.2;
67  }
68 
69  if (msgLvl(MSG::DEBUG)) {
70  for (int iCellD = 0; iCellD < N_CELLS_D; ++iCellD) {
71  msg(MSG::DEBUG) << " etaD[" << iCellD << "] = " << m_etaD[iCellD] << endmsg;
72  }
73  }
74 
75 
76  double eta_BC_A = -1.45;
77  for (int iCell = 0; iCell < N_CELLS_BC; ++iCell) {
78  m_etaBC[iCell] = eta_BC_A;
79  m_etaA[iCell] = eta_BC_A;
80  eta_BC_A += 0.1;
81  }
82 
83 
84  if (msgLvl(MSG::DEBUG)) {
85  for (int iCell = 0; iCell < N_CELLS_BC; ++iCell) {
86  msg(MSG::DEBUG) << " etaBC[" << iCell << "] = " << m_etaBC[iCell] << endmsg;
87  msg(MSG::DEBUG) << " etaA[" << iCell << "] = " << m_etaA[iCell] << endmsg;
88  }
89  }
90 
91 
92  ATH_CHECK( m_cellContainerKey.initialize() );
93  ATH_CHECK( m_muContainerKey.initialize() );
94 
95  ATH_MSG_DEBUG("TileLookForMuAlg initialization completed");
96 
97  return StatusCode::SUCCESS;
98 }
99 
101 //Execution /
103 StatusCode TileLookForMuAlg::execute (const EventContext& ctx) const {
104 
105  ATH_MSG_DEBUG("TileLookForMuAlg execution started");
106 
107  double eneA[N_CELLS_A][N_MODULES]; // calorimeter cell matrices
108  double eneBC[N_CELLS_BC][N_MODULES];
109  double eneD[N_CELLS_D][N_MODULES];
110 
111  memset(eneA, 0, sizeof(eneA));
112  memset(eneBC, 0, sizeof(eneBC));
113  memset(eneD, 0, sizeof(eneD));
114 
115  SG::WriteHandle<TileMuContainer> muContainer(m_muContainerKey, ctx);
116  ATH_CHECK( muContainer.record(std::make_unique<TileMuContainer>()) );
117 
118 
119  // Get CaloCell Container
120  std::vector<const CaloCell*> cellList;
121 
122  SG::ReadHandle<CaloCellContainer> cellContainer(m_cellContainerKey, ctx);
123  ATH_CHECK( cellContainer.isValid() );
124 
125  CaloCell_ID::SUBCALO tileCell_ID = CaloCell_ID::TILE;
126  CaloCellContainer::const_iterator currentCell =
127  cellContainer->beginConstCalo(tileCell_ID);
128  CaloCellContainer::const_iterator lastCell =
129  cellContainer->endConstCalo(tileCell_ID);
130 
131  ATH_MSG_DEBUG( "Calo Container size "
132  << cellContainer->nCellsCalo(tileCell_ID));
133 
134  double phi[64] = { 0 };
135 // TileID::SAMPLE cellSample;
136  for (; currentCell != lastCell; ++currentCell) {
137  int iCell = -1;
138  double cellEta = (*currentCell)->eta();
139  if (cellEta > -1.5 && cellEta < 1.5) {
140  int cellModule;
141  int cellSample = m_tileID->sample((*currentCell)->ID());
142  switch (cellSample) {
143  case TileID::SAMP_A:
144  iCell = (cellEta + 1.5) * 10;
145  cellModule = m_tileID->module((*currentCell)->ID());
146  eneA[iCell][cellModule] = (*currentCell)->energy();
147  phi[cellModule] = (*currentCell)->phi();
148  break;
149  case TileID::SAMP_BC:
150  iCell = (cellEta + 1.5) * 10;
151  cellModule = m_tileID->module((*currentCell)->ID());
152  eneBC[iCell][cellModule] = (*currentCell)->energy();
153  phi[cellModule] = (*currentCell)->phi();
154  break;
155  case TileID::SAMP_D:
156  iCell = (cellEta + 1.3) * 5;
157  cellModule = m_tileID->module((*currentCell)->ID());
158  eneD[iCell][cellModule] = (*currentCell)->energy();
159  phi[cellModule] = (*currentCell)->phi();
160  cellList.push_back(*currentCell);
161  break;
162  case TileID::SAMP_E:
163  iCell = (cellEta + 1.5) * 10;
164  if (iCell == 4 || iCell == 25) {
165  cellModule = m_tileID->module((*currentCell)->ID());
166  eneA[iCell][cellModule] = (*currentCell)->energy();
167  phi[cellModule] = (*currentCell)->phi();
168  }
169  break;
170  }
171  }
172 
173  if (msgLvl(MSG::VERBOSE)) {
174  msg(MSG::VERBOSE) << "scintillators sample, eta, phi, ene => "
175  << m_tileID->sample((*currentCell)->ID()) << ","
176  << cellEta << ","
177  << (*currentCell)->phi() << ","
178  << (*currentCell)->energy() << endmsg;
179 
180  msg(MSG::VERBOSE) << "sample, tower, eta => "
181  << m_tileID->sample((*currentCell)->ID()) << ", "
182  << m_tileID->tower((*currentCell)->ID()) << ", "
183  << cellEta << endmsg;
184  }
185  } /* end of Tile cells loop*/
186 
187  std::vector<double> muEtaD;
188  std::vector<float> muEneD;
189  std::vector<int> muModule;
190  std::vector<int> muCellD;
191  std::vector<int> muSplitted;
192  std::vector<int> muQualityD;
193  std::vector<int> muFound;
194  muEtaD.reserve(m_nMuMax);
195  muEneD.reserve(m_nMuMax);
196  muModule.reserve(m_nMuMax);
197  muCellD.reserve(m_nMuMax);
198  muSplitted.reserve(m_nMuMax);
199  muQualityD.reserve(m_nMuMax);
200  muFound.reserve(m_nMuMax);
201 
202  int nCandidates = 0, ntri = 0;
203  int nSplitted = 0;
204 
205  ATH_MSG_VERBOSE("Start the muon search candidates ");
206 
207  // find muon candidates
208  int lastMuCell = -3;
209  int lastMuModule = -3;
210  for (int iModule = 0; iModule < N_MODULES; ++iModule) {
211  int prevCell = -2;
212  for (int iCellD = 0; iCellD < N_CELLS_D; ++iCellD) {
213  float energy = eneD[iCellD][iModule];
214  if (energy >= m_loThrD) {
215  int splitted = -1;
216  double eta = m_etaD[iCellD];
217  double hiThr = m_hiThrD[iCellD];
218  int quality = (energy < hiThr) ? 0 : 1;
219  // check for muon splitting (same phi bin and neighboring eta bin)
220  if (prevCell == lastMuCell && iModule == lastMuModule) {
221  int sumQuality = quality + muQualityD.back();
222  float sumEnergy = energy + eneD[prevCell][iModule];
223  double hiPrevThr = m_hiThrD[prevCell];
224  double maxHiThr = (hiThr > hiPrevThr) ? hiThr : hiPrevThr;
225  if ((sumQuality == 0 && sumEnergy < maxHiThr) || sumQuality == 1) {
226  // possible splitting with last found muon candidate
227  splitted = nCandidates - 1; // idx of splitting mu candidate
228  energy = sumEnergy;
229  eta = (eta + m_etaD[prevCell]) / 2;
230  ++nSplitted;
231  ATH_MSG_VERBOSE( "Possible splits between mu candidates ("
232  << (splitted + 1) << ", " << splitted
233  << "): etaD1, etaD2, eta => "
234  << m_etaD[iCellD] << ", "
235  << m_etaD[prevCell] << ", "
236  << eta
237  << "; eneD1, eneD2, energy => "
238  << eneD[iCellD][iModule] << ", "
239  << eneD[prevCell][iModule] << ", "
240  << energy);
241  }
242  }
243  muModule.push_back(iModule);
244  muCellD.push_back(iCellD);
245  muSplitted.push_back(splitted);
246  muFound.push_back(0);
247  muEneD.push_back(energy);
248  muQualityD.push_back(quality);
249  muEtaD.push_back(eta);
250  ++nCandidates;
251  lastMuCell = iCellD;
252  lastMuModule = iModule;
253  ATH_MSG_VERBOSE( "Candidate number= " << nCandidates
254  << ", tower index (iCellD)= " << iCellD
255  << ", module index(iModuleD)= " << iModule
256  << ", Energy(iCellD)(iModuleD) = " << eneD[iCellD][iModule]
257  << ", threshold2(iCellD)= " << m_hiThrD[iCellD]);
258  } else {
259  // ATH_MSG_VERBOSE ( "no candidates" );
260  }
261  prevCell = iCellD;
262  }
263  }
264 
265  // debug ----------------------------------------
266  if (msgLvl(MSG::VERBOSE)) {
267  for (int i = 0; i < nCandidates; ++i) {
268  msg(MSG::VERBOSE) << "Candidates list: number phi,ene, eta "
269  << i << ","
270  << muModule[i] << ","
271  << muEneD[i] << ","
272  << muCellD[i]
273  << "nSplitted,muSplitted(cand)" << nSplitted << ", "
274  << muSplitted[i] << endmsg;
275  }
276  }
277 
278  //*************** loop on the candidates----------------------*
279 
280  for (int iMu = 0; iMu < nCandidates; ++iMu) {
281  int splitted = muSplitted[iMu];
282  if (splitted < 0 || muFound[splitted] == 0) {
283 
284  // the most important information on mu is in the 3rd sample
285  // to avoid multiple counting due to splitting in 2nd and 1st Sp. cells
286  // the loop stop when the candidate is found
287 
288  int module = muModule[iMu];
289  ATH_MSG_VERBOSE(
290  "loop on mu candidates: iMu, module = " << iMu << ", " << module);
291  int idxD = 6 * muCellD[iMu];
292  ATH_MSG_VERBOSE ("number of cells in BC layer to check = " << m_fromDtoBC[idxD]);
293  int endIdxD = idxD + m_fromDtoBC[idxD];
294  while (++idxD <= endIdxD && muFound[iMu] != 1) {
295  int cellBC = m_fromDtoBC[idxD];
296  float energyBC = eneBC[cellBC][module];
297  ATH_MSG_VERBOSE( "cellBC = " << cellBC
298  << ", module=" << module
299  << ", eneBC =" << energyBC);
300  if (energyBC > m_loThrBC) {
301  int qualityBC = (energyBC < m_hiThrBC[cellBC]) ? 0 : 1;
302  int idxBC = 6 * cellBC;
303  ATH_MSG_VERBOSE ("number of cells in A layer to check for mu = " << m_fromBCtoA[idxBC]);
304  int endIdxBC = idxBC + m_fromBCtoA[idxBC];
305  while (++idxBC <= endIdxBC && muFound[iMu] != 1) {
306  int cellA = m_fromBCtoA[idxBC];
307  float energyA = eneA[cellA][module];
308  ATH_MSG_VERBOSE( "cellA index = " << cellA
309  << ", module=" << module
310  << ", eneA =" << energyA);
311 
312  if ( energyA > ( (cellA == 4 || cellA == 25) ? m_loThrITC : m_loThrA ) ) {
313 
314  int qualityA = (energyA < m_hiThrA[cellA]) ? 0 : 1;
315 
316  // We have a muon like signature
317 
318  int muQuality = muQualityD[iMu] + qualityBC + qualityA;
319  if (muQuality <= 1) {
320  muFound[iMu] = 1;
321  double muEta = (muEtaD[iMu] + m_etaBC[cellBC] + m_etaA[cellA]) / 3;
322  double muPhi = phi[module];
323  std::vector<float> muEnergy;
324  muEnergy.reserve(4);
325  muEnergy.push_back(energyA);
326  muEnergy.push_back(energyBC);
327  muEnergy.push_back(muEneD[iMu]);
328  float eneAround = 0;
329 
330  ATH_MSG_VERBOSE( "tag ntri eta,phi,ene[0]= " << (++ntri) << ", "
331  << muEta << ", "
332  << muPhi << ", "
333  << muEnergy[0] << ", "
334  << muEnergy[1] << ", "
335  << muEnergy[2]
336  << " tag eta 1st, 2nd, 3rd,"
337  << m_etaA[cellA] << ", "
338  << m_etaBC[cellBC] << ", "
339  << m_etaD[muCellD[iMu]]);
340 
341  int nextModule = (module != 63) ? (module + 1) : 0;
342  int prevModule = (module != 0) ? (module - 1) : 63;
343  eneAround = eneA[cellA][nextModule] + eneA[cellA][prevModule]
344  + eneBC[cellBC][nextModule] + eneBC[cellBC][prevModule]; //phi neigh
345 
346  int nextCellA = cellA + 1;
347  int prevCellA = cellA - 1;
348  if (nextCellA < N_CELLS_A && prevCellA > 0) {
349  eneAround += eneA[nextCellA][module] + eneA[prevCellA][module]
350  + eneA[nextCellA][nextModule]
351  + eneA[nextCellA][prevModule]
352  + eneA[prevCellA][nextModule]
353  + eneA[prevCellA][prevModule];
354 
355  }
356 
357  int nextCellBC = cellBC + 1;
358  int prevCellBC = cellBC - 1;
359  if (nextCellBC < N_CELLS_BC && prevCellBC > 0) {
360  eneAround += eneBC[nextCellBC][module]
361  + eneBC[prevCellBC][module]
362  + eneBC[nextCellBC][nextModule]
363  + eneBC[nextCellBC][prevModule]
364  + eneBC[prevCellBC][nextModule]
365  + eneBC[prevCellBC][prevModule];
366 
367  }
368 
369  muEnergy.push_back(eneAround);
370  std::unique_ptr<TileMu> muon = std::make_unique<TileMu>((float) muEta,
371  (float) muPhi,
372  muEnergy,
373  muQuality);
374 
375  ATH_MSG_VERBOSE( "muon tag eta=" << muon->eta()
376  << " muon tag phi=" << muon->phi()
377  << " energydepVec[0]=" << muon->enedep()[0]
378  << " energydepVec[1]=" << muon->enedep()[1]
379  << " energydepVec[2]=" << muon->enedep()[2]
380  << " energydepVec[3]=" << muon->enedep()[3]
381  << " muon tag Q factor=" << muon->quality()
382  << " ene around= " << eneAround);
383 
384  muContainer->push_back(muon.release());
385  }
386 
387  } else {
388  ATH_MSG_VERBOSE(" tag eneA out");
389  } //endif eneA is in the range
390  } //end loop on pattern 1st layer
391  } else {
392  ATH_MSG_VERBOSE(" tag eneBC out");
393  } //endif eneBC is in the range
394  } //endloop on pattern 2nd layer
395  } else {
396  break;
397  }
398  } //endloop on candidate
399 
400 //-----debug-----------------------------------------------
401  // cellList contain the 3rd layer cell information
402  if (msgLvl(MSG::VERBOSE)) {
403  for (const CaloCell* cell : cellList) {
404  msg(MSG::VERBOSE) << " tag Cell (sect,side,mod,tow,sam)=("
405  << m_tileID->section(cell->ID()) << " "
406  << m_tileID->side(cell->ID()) << " "
407  << m_tileID->module(cell->ID()) << " "
408  << m_tileID->tower(cell->ID()) << " "
409  << m_tileID->sample(cell->ID())
410  << "),(eta,phi,energy)=("
411  << cell->eta() << ","
412  << cell->phi() << ","
413  << cell->energy() << ")" << endmsg;
414  }
415  }
416 
417  //debug---------------------------------------------------
418  // check the mu tag container
419  if (msgLvl(MSG::DEBUG)) {
420  for (const TileMu* mu : *muContainer) {
421  msg(MSG::DEBUG) << "Container name = " << m_muContainerKey.key()
422  << " eta = " << mu->eta()
423  << " phi = " << mu->phi()
424  << " enedep[0] = " << (mu->enedep())[0]
425  << " enedep[1] = " << (mu->enedep())[1]
426  << " enedep[2] = " << (mu->enedep())[2]
427  << " enedep[3] = " << (mu->enedep())[3]
428  << " quality = " << mu->quality() << endmsg;
429  }
430  }
431  //-------------------debug-------------------------
432 
433  return StatusCode::SUCCESS;
434 }
435 
436 StatusCode TileLookForMuAlg::finalize() {
437  ATH_MSG_DEBUG("TileLookForMuAlg finalization completed");
438  return StatusCode::SUCCESS;
439 }
440 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileLookForMuAlg::m_fromDtoBC
std::vector< int > m_fromDtoBC
Definition: TileLookForMuAlg.h:73
TileLookForMuAlg.h
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
TileLookForMuAlg::m_loThrA
double m_loThrA
Definition: TileLookForMuAlg.h:77
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
TileLookForMuAlg::m_nMuMax
const int m_nMuMax
Definition: TileLookForMuAlg.h:71
TileLookForMuAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override
Definition: TileLookForMuAlg.cxx:103
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Tile_Base_ID::SAMP_A
@ SAMP_A
Definition: Tile_Base_ID.h:53
TileLookForMuAlg::m_loThrBC
double m_loThrBC
Definition: TileLookForMuAlg.h:78
Tile_Base_ID::SAMP_BC
@ SAMP_BC
Definition: Tile_Base_ID.h:54
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
CaloCellContainer::beginConstCalo
CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const
get const iterators on cell of just one calo
Definition: CaloCellContainer.cxx:119
TileLookForMuAlg::m_etaA
double m_etaA[N_CELLS_A]
Definition: TileLookForMuAlg.h:70
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileLookForMuAlg::m_etaD
double m_etaD[N_CELLS_D]
Definition: TileLookForMuAlg.h:68
TileLookForMuAlg::m_etaBC
double m_etaBC[N_CELLS_BC]
Definition: TileLookForMuAlg.h:69
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
Tile_Base_ID::SAMP_E
@ SAMP_E
Definition: Tile_Base_ID.h:55
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileLookForMuAlg::m_fromBCtoA
std::vector< int > m_fromBCtoA
Definition: TileLookForMuAlg.h:74
TileID.h
TileLookForMuAlg::N_CELLS_BC
@ N_CELLS_BC
Definition: TileLookForMuAlg.h:63
TileLookForMuAlg::TileLookForMuAlg
TileLookForMuAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileLookForMuAlg.cxx:28
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
python.PyAthena.module
module
Definition: PyAthena.py:131
TileLookForMuAlg::N_MODULES
@ N_MODULES
Definition: TileLookForMuAlg.h:66
WriteHandle.h
Handle class for recording to StoreGate.
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
TileLookForMuAlg::initialize
virtual StatusCode initialize() override
Definition: TileLookForMuAlg.cxx:55
TileLookForMuAlg::finalize
virtual StatusCode finalize() override
Definition: TileLookForMuAlg.cxx:436
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
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
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:46
CaloCellContainer::nCellsCalo
int nCellsCalo(const CaloCell_ID::SUBCALO caloNum) const
get number of cels of given calorimeter
Definition: CaloCellContainer.cxx:145
TileCell.h
TileLookForMuAlg::m_tileID
const TileID * m_tileID
Definition: TileLookForMuAlg.h:59
TileLookForMuAlg::m_hiThrA
std::vector< double > m_hiThrA
Definition: TileLookForMuAlg.h:84
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileLookForMuAlg::N_CELLS_A
@ N_CELLS_A
Definition: TileLookForMuAlg.h:63
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileLookForMuAlg::N_CELLS_D
@ N_CELLS_D
Definition: TileLookForMuAlg.h:63
TileLookForMuAlg::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: TileLookForMuAlg.h:86
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
errorcheck.h
Helpers for checking error return status codes and reporting errors.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
TileLookForMuAlg::m_hiThrD
std::vector< double > m_hiThrD
Definition: TileLookForMuAlg.h:82
Tile_Base_ID::SAMP_D
@ SAMP_D
Definition: Tile_Base_ID.h:55
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TrackLeptonConfig.quality
quality
Definition: TrackLeptonConfig.py:16
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CaloCellContainer::endConstCalo
CaloCellContainer::const_iterator endConstCalo(CaloCell_ID::SUBCALO caloNum) const
Definition: CaloCellContainer.cxx:133
TileLookForMuAlg::m_muContainerKey
SG::WriteHandleKey< TileMuContainer > m_muContainerKey
Definition: TileLookForMuAlg.h:90
TileLookForMuAlg::m_loThrITC
double m_loThrITC
Definition: TileLookForMuAlg.h:80
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
Tile_Base_ID::section
int section(const Identifier &id) const
Definition: Tile_Base_ID.cxx:147
ReadHandle.h
Handle class for reading from StoreGate.
TileLookForMuAlg::~TileLookForMuAlg
virtual ~TileLookForMuAlg()
Definition: TileLookForMuAlg.cxx:49
TileLookForMuAlg::m_loThrD
double m_loThrD
Definition: TileLookForMuAlg.h:79
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
TileLookForMuAlg::m_hiThrBC
std::vector< double > m_hiThrBC
Definition: TileLookForMuAlg.h:83
TileMu
Class to store TileMuId quantities.
Definition: TileMu.h:25
Generated on Mon Mar 17 2025 21:20:28 for ATLAS Offline Software by   doxygen 1.8.18