ATLAS Offline Software
CaloCellsHandlerTool.cxx
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #include <vector>
6 #include <fstream>
7 #include "TMath.h"
10 
12  const std::string& name,
13  const IInterface* parent): AthAlgTool(type, name, parent){
14 }
15 
17 
18 
20 
23 
24  // CaloIndentifier
25  CHECK( detStore()->retrieve (m_CaloCell_ID, "CaloCell_ID") );
26 
27  ATH_MSG_INFO("Hardware-style energy encoding for GEP cells has been set to " << m_doGepHardwareStyleEnergyEncoding.value());
28  if (!m_doGepHardwareStyleEnergyEncoding) ATH_MSG_WARNING("Hardware-style energy encoding for GEP cells has been disabled. Cell energies will have larger precision than realistically possible");
29 
30  ATH_MSG_INFO("Truncation of Gep cells from FEBs which are overflowing has been set to " << m_doTruncationOfOverflowingFEBs.value());
31  if (!m_doTruncationOfOverflowingFEBs) ATH_MSG_WARNING("Truncation of GEP cells from overflowing FEBs has been disabled. More GEP cells will be send to algorithms than realistically possible");
32 
33  // Setting up GEP energy encoding scheme
35 
36  // Read values of Gep readout scheme from argument
37  int GepScheme[3];
38  for (int i = 0; i < 3; ++i) {
39  GepScheme[i] = std::stoi(m_GepEnergyEncodingScheme.value().substr(0,m_GepEnergyEncodingScheme.value().find("-")));
40  m_GepEnergyEncodingScheme.value().erase(0, m_GepEnergyEncodingScheme.value().find("-")+1);
41  }
42 
43  CHECK(setNumberOfEnergyBits(GepScheme[0]));
44  CHECK(setLeastSignificantBit(GepScheme[1]));
45  CHECK(setG(GepScheme[2]));
46 
48 
49  m_readoutRanges[0] = 0;
54 
55  ATH_MSG_INFO("Readout scheme with " << m_nEnergyBits << "-bits provides the following four energy thresholds (with " << m_stepsPerRange << " discrete steps on each threshold)");
56  ATH_MSG_INFO("GEP cell energy range 0: min = " << m_readoutRanges[0] << " MeV -> max = " << m_readoutRanges[1] << " MeV");
57  ATH_MSG_INFO("GEP cell energy range 1: min = " << m_readoutRanges[1] + m_valLeastSigBit << " MeV -> max = " << m_readoutRanges[2] << " MeV");
58  ATH_MSG_INFO("GEP cell energy range 2: min = " << m_readoutRanges[2]+(m_valG*m_valLeastSigBit) << " MeV -> max = " << m_readoutRanges[3] << " MeV");
59  ATH_MSG_INFO("GEP cell energy range 3: min = " << m_readoutRanges[3]+(m_valG*m_valG*m_valLeastSigBit) << " MeV -> max = " << m_readoutRanges[4] << " MeV");
60  }
61 
63  // Loading the invariant cell data and storing in m_gepCellsBase for later use on event-by-event basis
64  m_gepCellsBase.clear();
65 
66  ATH_MSG_INFO("Loading cell map associating cells to FEBs");
67 
68  std::string cellMapPath = PathResolverFindCalibFile(m_LArCellMap);
69  if(cellMapPath.empty()) ATH_MSG_ERROR("Could not find file with cell map data: " << m_LArCellMap.value());
70 
71  std::ifstream file(cellMapPath.c_str());
72 
73  unsigned n_cells = 0;
74 
75  // Read input file
76  if (file.is_open()) {
77 
78  int online_id, offline_id, ch, con_num, fbr;
79  std::string feb, con_type;
80 
81  // Skipping header of file
82  std::getline(file, feb);
83 
84  // start reading data
85  while (true) {
86 
87  file >> offline_id >> online_id >> feb >> ch >> con_type >> con_num >> fbr;
88 
89  if (file.eof()) break;
90 
91  Gep::GepCaloCell caloCell;
92  caloCell.id = offline_id;
93  caloCell.FEB = feb;
94  caloCell.channel = ch;
95  caloCell.fiber = fbr;
96  caloCell.connection_type = con_type;
97  caloCell.connection_number = con_num;
98 
99  m_gepCellsBase.insert(std::pair<unsigned int, Gep::GepCaloCell>(caloCell.id, caloCell));
100 
101  ++n_cells;
102  }
103  }
104  else {
105  ATH_MSG_ERROR("Could not open file containing the cell to FEB association");
106  return StatusCode::FAILURE;
107  }
108 
109  ATH_MSG_INFO("Loaded FEB information for " << n_cells << " cells");
110  }
111 
112  return StatusCode::SUCCESS;
113 }
114 
115 // Get calo cells map
116 
118  pGepCellMap& gepCellsMap,
119  const EventContext& ctx) const {
120 
121  // PS this function creates and returns a map which has Gep::GepCaloCells as its values
122  // The cells are made up of data which is invariant for all events, and dynamic
123  // data which varies with event.
124  // The invariant data should be setup in initialize(), and the dynamic
125  // data should be updated here in a way which is compatible with the const-ness of this
126  // function.
127  // This will be attended to in the future.
128 
129  SG::ReadCondHandle<CaloNoise> electronicNoiseHdl{m_electronicNoiseKey, ctx};
130  if (!electronicNoiseHdl.isValid()) {return StatusCode::FAILURE;}
131  const CaloNoise* electronicNoiseCDO = *electronicNoiseHdl;
132 
134  if (!totalNoiseHdl.isValid()) {return StatusCode::FAILURE;}
135  const CaloNoise* totalNoiseCDO = *totalNoiseHdl;
136 
137  int idx = -1;
138  std::map<std::string,std::vector<Gep::GepCaloCell>> gepCellsPerFEB;
139 
140  for(const auto *cell: cells){
141 
142  Gep::GepCaloCell caloCell;
143  ++idx;
144 
145  caloCell.id = (cell->ID().get_identifier32()).get_compact();
146  auto base_cell_itr = m_gepCellsBase.find(caloCell.id);
147  if (base_cell_itr != m_gepCellsBase.end()) caloCell = base_cell_itr->second;
148  else {
149  // Tile cells are not included in the cell base map
150  // In the future this might change, for now just setting FEB value to a dummy
151  caloCell.FEB = "Tile";
152  }
153 
154  float electronicNoise = electronicNoiseCDO->getNoise(cell->ID(), cell->gain());
155  float totalNoise = totalNoiseCDO->getNoise(cell->ID(), cell->gain());
156 
157  // Only send positive-energy 2sigma cells to the GEP
158  if ((cell->energy() / totalNoise) < 2.0) continue;
159 
160  // GEP will only have ET available for LAr cells, so convert to energy from ET
162  caloCell.et = getGepEnergy(cell->energy() / TMath::CosH(cell->eta()));
163  caloCell.e = caloCell.et * TMath::CosH(cell->eta());
164  }
165  else {
166  caloCell.e = cell->energy();
167  caloCell.et = caloCell.e / TMath::CosH(cell->eta());
168  }
169  caloCell.time = cell->time();
170  caloCell.quality = cell->quality();
171  caloCell.provenance = cell->provenance();
172 
173  caloCell.totalNoise = totalNoise;
174  caloCell.electronicNoise = electronicNoise;
175  caloCell.sigma = cell->energy() / totalNoise;
176 
177  caloCell.isBad = cell->badcell();
178  caloCell.eta = cell->eta();
179  caloCell.phi = cell->phi();
180  caloCell.sinTh = cell->sinTh();
181  caloCell.cosTh = cell->cosTh();
182  caloCell.sinPhi = cell->sinPhi();
183  caloCell.cosPhi = cell->cosPhi();
184  caloCell.cotTh = cell->cotTh();
185  caloCell.x = cell->x();
186  caloCell.y = cell->y();
187  caloCell.z = cell->z();
188 
189  unsigned int samplingEnum = m_CaloCell_ID->calo_sample(cell->ID());
190 
191  bool IsEM = m_CaloCell_ID->is_em(cell->ID());
192  bool IsEM_Barrel=false;
193  bool IsEM_EndCap=false;
194  bool IsEM_BarrelPos=false;
195  bool IsEM_BarrelNeg=false;
196  if(IsEM){
197  IsEM_Barrel=m_CaloCell_ID->is_em_barrel(cell->ID());
198  if(IsEM_Barrel){
199  if(m_CaloCell_ID->pos_neg(cell->ID())>0) IsEM_BarrelPos=true;
200  }
201  IsEM_EndCap=m_CaloCell_ID->is_em_endcap(cell->ID());
202  }
203 
204  caloCell.isEM = IsEM;
205  caloCell.isEM_barrel = IsEM_Barrel;
206  caloCell.isEM_endCap = IsEM_EndCap;
207  caloCell.isEM_barrelPos = IsEM_BarrelPos;
208  caloCell.isEM_barrelNeg = IsEM_BarrelNeg; //always false?
209  caloCell.isFCAL = m_CaloCell_ID->is_fcal(cell->ID());
210  caloCell.isHEC = m_CaloCell_ID->is_hec(cell->ID());
211  caloCell.isTile = m_CaloCell_ID->is_tile(cell->ID());
212 
213  caloCell.sampling = samplingEnum;
214  caloCell.detName = CaloSampling::getSamplingName(samplingEnum);
215 
216  caloCell.neighbours = getNeighbours(cells, cell, ctx);
217  caloCell.id = (cell->ID().get_identifier32()).get_compact();
218 
219  const CaloDetDescriptor *elt = cell->caloDDE()->descriptor();
220  caloCell.layer = cell->caloDDE()->getLayer();
221 
222  float deta = elt->deta();
223  float dphi = elt->dphi();
224 
225  float etamin = caloCell.eta - (0.5*deta);
226  float etamax = caloCell.eta + (0.5*deta);
227 
228  float phimin = caloCell.phi - (0.5*dphi);
229  float phimax = caloCell.phi + (0.5*dphi);
230 
231  caloCell.etaMin = etamin;
232  caloCell.etaMax = etamax;
233  caloCell.phiMin = phimin;
234  caloCell.phiMax = phimax;
235  caloCell.etaGranularity = deta;
236  caloCell.phiGranularity = dphi;
237 
238  caloCell.index = idx;
239 
240  // Fill cells into map according to FEB
241  auto feb_itr = gepCellsPerFEB.find(caloCell.FEB);
242  if (feb_itr != gepCellsPerFEB.end()) feb_itr->second.push_back(caloCell);
243  else {
244  std::vector<Gep::GepCaloCell> cellsThisFEB;
245  cellsThisFEB.push_back(caloCell);
246  gepCellsPerFEB.insert(std::pair<std::string,std::vector<Gep::GepCaloCell>>(caloCell.FEB,cellsThisFEB));
247  }
248  }
249 
250  // store cells map
251  auto itr = gepCellsPerFEB.begin();
252  for ( ;itr != gepCellsPerFEB.end(); ++itr) {
253 
254  // LAr FEBs might overflow, so they will get truncated
255  if (m_doTruncationOfOverflowingFEBs && itr->second.size() > m_maxCellsPerFEB && itr->first != "Tile") {
256  ATH_MSG_DEBUG("FEB " << itr->first << " is sending " << itr->second.size() << " cells, which is more cells than GEP can receive. Removing all but the possible " << m_maxCellsPerFEB << " cells.");
257  CHECK(removeCellsFromOverloadedFEB(itr->second));
258  }
259  for (const Gep::GepCaloCell& cell : itr->second)
260  gepCellsMap->insert(std::pair<unsigned int, Gep::GepCaloCell>(cell.id, cell));
261  }
262  ATH_MSG_DEBUG("GEP is receiving a total of " << gepCellsMap->size() << " cells in this event");
263 
264  return StatusCode::SUCCESS;
265 }
266 
267 
268 
269 int CaloCellsHandlerTool::getGepEnergy(float offline_et) const {
270 
271  // If cell saturates readout range, largest possible value is send
272  if (offline_et > m_readoutRanges[4]) return m_readoutRanges[4];
273 
274  int readoutRange = 0;
275  for (int i = 1; i <= 3; ++i) {
276  if (offline_et > m_readoutRanges[i]) readoutRange = i;
277  }
278 
279  float step = ((float) m_readoutRanges[readoutRange+1] - (float) m_readoutRanges[readoutRange]) / (m_stepsPerRange-1);
280  int gep_energy = -1;
281  for (int i = 0; i < m_stepsPerRange; ++i) {
282  if (offline_et < (m_readoutRanges[readoutRange]+(step*i))) break;
283  gep_energy = m_readoutRanges[readoutRange]+(step*i);
284  }
285 
286  return gep_energy;
287 }
288 
289 
290 
291 // Get neighbours of a given calo cell
292 std::vector<unsigned int>
294  const CaloCell* acell,
295  const EventContext&) const {
296 
297  // get all neighboring cells
298  std::vector<IdentifierHash> cellNeighbours;
299 
300  IdentifierHash cellHashID = m_CaloCell_ID->calo_cell_hash(acell->ID());
301  m_CaloCell_ID->get_neighbours(cellHashID,LArNeighbours::super3D,cellNeighbours);
302 
303  std::vector<unsigned int> neighbour_ids;
304  for (unsigned int iNeighbour = 0;
305  iNeighbour < cellNeighbours.size();
306  ++iNeighbour) {
307 
308  const CaloCell* neighbour = allcells.findCell(cellNeighbours[iNeighbour]);
309  if (neighbour) {
310  neighbour_ids.push_back((neighbour->ID().get_identifier32()).get_compact());
311  } else {
312  ATH_MSG_ERROR("Couldn't access neighbour #" << iNeighbour
313  << " for cell ID "
314  << (acell->ID().get_identifier32()).get_compact());
315  }
316  }
317  return neighbour_ids;
318 }
319 
320 
321 
323 
324  std::map<int,Gep::GepCaloCell> orderedCells;
325  for (const Gep::GepCaloCell& cell : cells)
326  orderedCells.insert(std::pair<int,Gep::GepCaloCell>(cell.channel,cell));
327 
328  cells.clear();
329 
330  std::map<int,Gep::GepCaloCell>::iterator cell_itr = orderedCells.begin();
331  for ( ;cell_itr != orderedCells.end(); ++cell_itr) {
332  cells.push_back(cell_itr->second);
333  if (cells.size() == m_maxCellsPerFEB) break;
334  }
335 
336  return StatusCode::SUCCESS;
337 }
338 
339 
340 
341 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:271
CaloCellsHandlerTool::removeCellsFromOverloadedFEB
StatusCode removeCellsFromOverloadedFEB(std::vector< Gep::GepCaloCell > &cells) const
Definition: CaloCellsHandlerTool.cxx:322
Gep::GepCaloCell::fiber
int fiber
Definition: GepCaloCell.h:56
egammaPIDObs::IsEM
@ IsEM
cut-based identification for egamma objects (cluster and track-based)
Definition: egammaPIDdefsObs.h:55
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
CaloCellsHandlerTool::m_valG
int m_valG
Definition: CaloCellsHandlerTool.h:91
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellsHandlerTool::m_maxCellsPerFEB
unsigned m_maxCellsPerFEB
Definition: CaloCellsHandlerTool.h:94
CaloCellsHandlerTool::m_gepCellsBase
std::map< unsigned int, Gep::GepCaloCell > m_gepCellsBase
Definition: CaloCellsHandlerTool.h:96
CaloCell_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
CaloDetDescriptor::dphi
double dphi() const
delta phi
Definition: CaloDetDescriptor.h:593
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
CaloCellsHandlerTool::getGepEnergy
int getGepEnergy(float offline_et) const
Definition: CaloCellsHandlerTool.cxx:269
CaloCellsHandlerTool::m_electronicNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_electronicNoiseKey
Definition: CaloCellsHandlerTool.h:104
CaloCell_Base_ID::calo_sample
int calo_sample(const Identifier id) const
returns an int taken from Sampling enum and describing the subCalo to which the Id belongs.
Definition: CaloCell_Base_ID.cxx:141
CaloCell_Base_ID::is_tile
bool is_tile(const Identifier id) const
test if the id belongs to the Tiles
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
CaloCellsHandlerTool::m_nEnergyBits
int m_nEnergyBits
Key of the CaloNoise Conditions data object.
Definition: CaloCellsHandlerTool.h:89
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
CaloCellsHandlerTool::m_doTruncationOfOverflowingFEBs
Gaudi::Property< bool > m_doTruncationOfOverflowingFEBs
Definition: CaloCellsHandlerTool.h:100
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Gep::GepCaloCell::channel
int channel
Definition: GepCaloCell.h:55
CaloCellsHandlerTool::m_totalNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_totalNoiseKey
Definition: CaloCellsHandlerTool.h:111
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
Gep::GepCaloCell::id
unsigned int id
Definition: GepCaloCell.h:52
CaloCellsHandlerTool::setLeastSignificantBit
StatusCode setLeastSignificantBit(int value)
Definition: CaloCellsHandlerTool.h:61
CaloCellsHandlerTool::m_valLeastSigBit
int m_valLeastSigBit
Definition: CaloCellsHandlerTool.h:90
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
Gep::GepCaloCell::connection_type
std::string connection_type
Definition: GepCaloCell.h:57
file
TFile * file
Definition: tile_monitor.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
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
CaloCellsHandlerTool::getGepCellMap
StatusCode getGepCellMap(const CaloCellContainer &cells, pGepCellMap &, const EventContext &ctx) const
Definition: CaloCellsHandlerTool.cxx:117
CaloCellsHandlerTool.h
Gep::GepCaloCell
Definition: GepCaloCell.h:13
CaloDetDescriptor::deta
double deta() const
delta eta
Definition: CaloDetDescriptor.h:588
LArNeighbours::super3D
@ super3D
Definition: LArNeighbours.h:29
CaloCellsHandlerTool::m_doGepHardwareStyleEnergyEncoding
Gaudi::Property< bool > m_doGepHardwareStyleEnergyEncoding
Definition: CaloCellsHandlerTool.h:99
CaloCellsHandlerTool::m_LArCellMap
Gaudi::Property< std::string > m_LArCellMap
Definition: CaloCellsHandlerTool.h:101
CaloCellsHandlerTool::setNumberOfEnergyBits
StatusCode setNumberOfEnergyBits(int value)
Definition: CaloCellsHandlerTool.h:42
CaloCellContainer::findCell
const CaloCell * findCell(const IdentifierHash theHash) const
fast find method given identifier hash.
Definition: CaloCellContainer.cxx:345
CaloNoise
Definition: CaloNoise.h:16
CaloCellsHandlerTool::CaloCellsHandlerTool
CaloCellsHandlerTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: CaloCellsHandlerTool.cxx:11
CaloCell_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
CaloCellsHandlerTool::m_readoutRanges
int m_readoutRanges[5]
Definition: CaloCellsHandlerTool.h:92
Gep::GepCaloCell::FEB
std::string FEB
Definition: GepCaloCell.h:54
CaloCellsHandlerTool::~CaloCellsHandlerTool
virtual ~CaloCellsHandlerTool()
Definition: CaloCellsHandlerTool.cxx:16
PathResolver.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloCell_Base_ID::get_neighbours
int get_neighbours(const IdentifierHash caloHash, const LArNeighbours::neighbourOption &option, std::vector< IdentifierHash > &neighbourList) const
access to hashes for neighbours return == 0 for neighbours found
Definition: CaloCell_Base_ID.cxx:190
pGepCellMap
std::unique_ptr< GepCellMap > pGepCellMap
Definition: CaloCellsHandlerTool.h:23
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CaloCell::ID
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
Definition: CaloCell.h:279
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
CaloCellsHandlerTool::setG
StatusCode setG(int value)
Definition: CaloCellsHandlerTool.h:72
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloDetDescriptor
This is a base class for LAr and Tile Descriptors The primary goal is to speed up loops over all the ...
Definition: CaloDetDescriptor.h:58
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
Gep::GepCaloCell::connection_number
int connection_number
Definition: GepCaloCell.h:58
LArCellBinning.step
step
Definition: LArCellBinning.py:158
CaloCellsHandlerTool::m_GepEnergyEncodingScheme
Gaudi::Property< std::string > m_GepEnergyEncodingScheme
Definition: CaloCellsHandlerTool.h:98
CaloCellsHandlerTool::getNeighbours
std::vector< unsigned int > getNeighbours(const CaloCellContainer &allcells, const CaloCell *acell, const EventContext &) const
Definition: CaloCellsHandlerTool.cxx:293
CaloSampling::getSamplingName
static std::string getSamplingName(CaloSample theSample)
Returns a string (name) for each CaloSampling.
Definition: Calorimeter/CaloGeoHelpers/Root/CaloSampling.cxx:18
AthAlgTool
Definition: AthAlgTool.h:26
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
CaloCellsHandlerTool::m_CaloCell_ID
const CaloCell_ID * m_CaloCell_ID
Definition: CaloCellsHandlerTool.h:117
CaloCellsHandlerTool::m_stepsPerRange
int m_stepsPerRange
Definition: CaloCellsHandlerTool.h:93
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
readCCLHist.float
float
Definition: readCCLHist.py:83
CaloCellsHandlerTool::initialize
StatusCode initialize()
Definition: CaloCellsHandlerTool.cxx:19