ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
CaloCellsHandlerTool Class Reference

#include <CaloCellsHandlerTool.h>

Inheritance diagram for CaloCellsHandlerTool:
Collaboration diagram for CaloCellsHandlerTool:

Public Member Functions

 CaloCellsHandlerTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~CaloCellsHandlerTool ()
 
StatusCode initialize ()
 
StatusCode getGepCellMap (const CaloCellContainer &cells, pGepCellMap &, const EventContext &ctx) const
 
StatusCode setNumberOfEnergyBits (int value)
 
StatusCode setLeastSignificantBit (int value)
 
StatusCode setG (int value)
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

int getGepEnergy (float offline_et) const
 
std::vector< unsigned int > getNeighbours (const CaloCellContainer &allcells, const CaloCell *acell, const EventContext &) const
 
StatusCode removeCellsFromOverloadedFEB (std::vector< Gep::GepCaloCell > &cells) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

int m_nEnergyBits = -1
 Key of the CaloNoise Conditions data object. More...
 
int m_valLeastSigBit = -1
 
int m_valG = -1
 
int m_readoutRanges [5] = {-1,-1,-1,-1,-1}
 
int m_stepsPerRange = -1
 
unsigned m_maxCellsPerFEB = -1
 
std::map< unsigned int, Gep::GepCaloCellm_gepCellsBase = {}
 
Gaudi::Property< std::string > m_GepEnergyEncodingScheme {this, "GEPEnergyEncodingScheme", "", "String defining the GEP readout scheme according to number of readout bits + '-' + value of LSB in MeV + '-' + gain value"}
 
Gaudi::Property< bool > m_doGepHardwareStyleEnergyEncoding {this, "HardwareStyleEnergyEncoding", false, "Enabling or disabling the hardware-style energy encoding for the GEP"}
 
Gaudi::Property< bool > m_doTruncationOfOverflowingFEBs {this, "TruncationOfOverflowingFEBs", false, "Enabling or disabling the truncation of cells from FEBs with more than the maximum number of cells which can be send"}
 
Gaudi::Property< std::string > m_LArCellMap {this, "LArCellMapFile", "UpgradePerformanceFunctions/LAr_Cell_Map_offlineID_0.csv", "File associating LAr cells with readout FEBs and connection technology"}
 
SG::ReadCondHandleKey< CaloNoisem_electronicNoiseKey
 
SG::ReadCondHandleKey< CaloNoisem_totalNoiseKey
 
const CaloCell_IDm_CaloCell_ID {nullptr}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 26 of file CaloCellsHandlerTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CaloCellsHandlerTool()

CaloCellsHandlerTool::CaloCellsHandlerTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 11 of file CaloCellsHandlerTool.cxx.

14 }

◆ ~CaloCellsHandlerTool()

CaloCellsHandlerTool::~CaloCellsHandlerTool ( )
virtual

Definition at line 16 of file CaloCellsHandlerTool.cxx.

16 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getGepCellMap()

StatusCode CaloCellsHandlerTool::getGepCellMap ( const CaloCellContainer cells,
pGepCellMap gepCellsMap,
const EventContext &  ctx 
) const

Definition at line 117 of file CaloCellsHandlerTool.cxx.

119  {
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 }

◆ getGepEnergy()

int CaloCellsHandlerTool::getGepEnergy ( float  offline_et) const
private

Definition at line 269 of file CaloCellsHandlerTool.cxx.

269  {
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 }

◆ getNeighbours()

std::vector< unsigned int > CaloCellsHandlerTool::getNeighbours ( const CaloCellContainer allcells,
const CaloCell acell,
const EventContext &   
) const
private

Definition at line 293 of file CaloCellsHandlerTool.cxx.

295  {
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 }

◆ initialize()

StatusCode CaloCellsHandlerTool::initialize ( )

Definition at line 19 of file CaloCellsHandlerTool.cxx.

19  {
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 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ removeCellsFromOverloadedFEB()

StatusCode CaloCellsHandlerTool::removeCellsFromOverloadedFEB ( std::vector< Gep::GepCaloCell > &  cells) const
private

Definition at line 322 of file CaloCellsHandlerTool.cxx.

322  {
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 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setG()

StatusCode CaloCellsHandlerTool::setG ( int  value)
inline

Definition at line 72 of file CaloCellsHandlerTool.h.

72  {
73  if (value < 1) {
74  ATH_MSG_FATAL("The value of G in the GEP energy encoding cannot be set to " << value);
75  return StatusCode::FAILURE;
76  }
77  ATH_MSG_INFO("Setting the value for G in the GEP energy encoding to " << value);
78  m_valG = value;
79 
80  return StatusCode::SUCCESS;
81  }

◆ setLeastSignificantBit()

StatusCode CaloCellsHandlerTool::setLeastSignificantBit ( int  value)
inline

Definition at line 61 of file CaloCellsHandlerTool.h.

61  {
62  if (value < 1) {
63  ATH_MSG_FATAL("The value of the least significant bit in the GEP energy encoding cannot be set to " << value);
64  return StatusCode::FAILURE;
65  }
66  ATH_MSG_INFO("Setting the value for the least significant bit in the GEP energy encoding to " << value << " MeV");
68 
69  return StatusCode::SUCCESS;
70  }

◆ setNumberOfEnergyBits()

StatusCode CaloCellsHandlerTool::setNumberOfEnergyBits ( int  value)
inline

Definition at line 42 of file CaloCellsHandlerTool.h.

42  {
43 
44  // At the moment only have a detailed scheme for 6-10 bit readouts, thus rejecting any other value
45  switch(value) {
46  case 6: m_maxCellsPerFEB = 53; break;
47  case 7: m_maxCellsPerFEB = 46; break;
48  case 8: m_maxCellsPerFEB = 41; break;
49  case 9: m_maxCellsPerFEB = 37; break;
50  case 10: m_maxCellsPerFEB = 34; break;
51  default: ATH_MSG_FATAL("A GEP energy encoding scheme with " << value << " energy bits is currently not defined");
52  return StatusCode::FAILURE;
53  }
54 
55  ATH_MSG_INFO("Setting GEP energy encoding to a " << value << "-bit scheme which allows for the sending of " << m_maxCellsPerFEB << " cells to GEP per FEB");
57 
58  return StatusCode::SUCCESS;
59  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_CaloCell_ID

const CaloCell_ID* CaloCellsHandlerTool::m_CaloCell_ID {nullptr}
private

Definition at line 117 of file CaloCellsHandlerTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doGepHardwareStyleEnergyEncoding

Gaudi::Property<bool> CaloCellsHandlerTool::m_doGepHardwareStyleEnergyEncoding {this, "HardwareStyleEnergyEncoding", false, "Enabling or disabling the hardware-style energy encoding for the GEP"}
private

Definition at line 99 of file CaloCellsHandlerTool.h.

◆ m_doTruncationOfOverflowingFEBs

Gaudi::Property<bool> CaloCellsHandlerTool::m_doTruncationOfOverflowingFEBs {this, "TruncationOfOverflowingFEBs", false, "Enabling or disabling the truncation of cells from FEBs with more than the maximum number of cells which can be send"}
private

Definition at line 100 of file CaloCellsHandlerTool.h.

◆ m_electronicNoiseKey

SG::ReadCondHandleKey<CaloNoise> CaloCellsHandlerTool::m_electronicNoiseKey
private
Initial value:
{this,
"electronicNoiseKey",
"totalNoise",
"SG Key of CaloNoise data object"}

Definition at line 104 of file CaloCellsHandlerTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_gepCellsBase

std::map<unsigned int,Gep::GepCaloCell> CaloCellsHandlerTool::m_gepCellsBase = {}
private

Definition at line 96 of file CaloCellsHandlerTool.h.

◆ m_GepEnergyEncodingScheme

Gaudi::Property<std::string> CaloCellsHandlerTool::m_GepEnergyEncodingScheme {this, "GEPEnergyEncodingScheme", "", "String defining the GEP readout scheme according to number of readout bits + '-' + value of LSB in MeV + '-' + gain value"}
private

Definition at line 98 of file CaloCellsHandlerTool.h.

◆ m_LArCellMap

Gaudi::Property<std::string> CaloCellsHandlerTool::m_LArCellMap {this, "LArCellMapFile", "UpgradePerformanceFunctions/LAr_Cell_Map_offlineID_0.csv", "File associating LAr cells with readout FEBs and connection technology"}
private

Definition at line 101 of file CaloCellsHandlerTool.h.

◆ m_maxCellsPerFEB

unsigned CaloCellsHandlerTool::m_maxCellsPerFEB = -1
private

Definition at line 94 of file CaloCellsHandlerTool.h.

◆ m_nEnergyBits

int CaloCellsHandlerTool::m_nEnergyBits = -1
private

Key of the CaloNoise Conditions data object.

Typical values are '"electronicNoise', 'pileupNoise', or '"totalNoise' (default)

Definition at line 89 of file CaloCellsHandlerTool.h.

◆ m_readoutRanges

int CaloCellsHandlerTool::m_readoutRanges[5] = {-1,-1,-1,-1,-1}
private

Definition at line 92 of file CaloCellsHandlerTool.h.

◆ m_stepsPerRange

int CaloCellsHandlerTool::m_stepsPerRange = -1
private

Definition at line 93 of file CaloCellsHandlerTool.h.

◆ m_totalNoiseKey

SG::ReadCondHandleKey<CaloNoise> CaloCellsHandlerTool::m_totalNoiseKey
private
Initial value:
{this,
"totalNoiseKey",
"totalNoise",
"SG Key of CaloNoise data object"}

Definition at line 111 of file CaloCellsHandlerTool.h.

◆ m_valG

int CaloCellsHandlerTool::m_valG = -1
private

Definition at line 91 of file CaloCellsHandlerTool.h.

◆ m_valLeastSigBit

int CaloCellsHandlerTool::m_valLeastSigBit = -1
private

Definition at line 90 of file CaloCellsHandlerTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Gep::GepCaloCell::sigma
float sigma
Definition: GepCaloCell.h:24
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:271
Gep::GepCaloCell::time
float time
Definition: GepCaloCell.h:19
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
Gep::GepCaloCell::neighbours
std::vector< unsigned int > neighbours
Definition: GepCaloCell.h:59
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Gep::GepCaloCell::electronicNoise
float electronicNoise
Definition: GepCaloCell.h:23
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
Gep::GepCaloCell::phi
float phi
Definition: GepCaloCell.h:27
Gep::GepCaloCell::phiMax
float phiMax
Definition: GepCaloCell.h:31
CaloCellsHandlerTool::m_valG
int m_valG
Definition: CaloCellsHandlerTool.h:91
Gep::GepCaloCell::x
float x
Definition: GepCaloCell.h:39
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Gep::GepCaloCell::isHEC
bool isHEC
Definition: GepCaloCell.h:49
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloCell_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
Gep::GepCaloCell::quality
unsigned int quality
Definition: GepCaloCell.h:20
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
Gep::GepCaloCell::e
float e
Definition: GepCaloCell.h:17
Gep::GepCaloCell::sampling
unsigned int sampling
Definition: GepCaloCell.h:51
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
athena.value
value
Definition: athena.py:124
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CaloCell_Base_ID::is_tile
bool is_tile(const Identifier id) const
test if the id belongs to the Tiles
Gep::GepCaloCell::et
float et
Definition: GepCaloCell.h:18
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
Gep::GepCaloCell::isBad
bool isBad
Definition: GepCaloCell.h:25
Gep::GepCaloCell::cosTh
float cosTh
Definition: GepCaloCell.h:35
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::phiMin
float phiMin
Definition: GepCaloCell.h:30
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Gep::GepCaloCell::channel
int channel
Definition: GepCaloCell.h:55
CaloCellsHandlerTool::m_totalNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_totalNoiseKey
Definition: CaloCellsHandlerTool.h:111
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
Gep::GepCaloCell::provenance
unsigned int provenance
Definition: GepCaloCell.h:21
Gep::GepCaloCell::y
float y
Definition: GepCaloCell.h:40
Gep::GepCaloCell::cotTh
float cotTh
Definition: GepCaloCell.h:38
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Gep::GepCaloCell::isEM_barrel
bool isEM_barrel
Definition: GepCaloCell.h:44
Gep::GepCaloCell::totalNoise
float totalNoise
Definition: GepCaloCell.h:22
Gep::GepCaloCell::isTile
bool isTile
Definition: GepCaloCell.h:50
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
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Gep::GepCaloCell::isEM_endCap
bool isEM_endCap
Definition: GepCaloCell.h:45
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
Gep::GepCaloCell::layer
int layer
Definition: GepCaloCell.h:42
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
Gep::GepCaloCell
Definition: GepCaloCell.h:13
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Gep::GepCaloCell::etaMin
float etaMin
Definition: GepCaloCell.h:28
Gep::GepCaloCell::etaGranularity
float etaGranularity
Definition: GepCaloCell.h:32
CaloDetDescriptor::deta
double deta() const
delta eta
Definition: CaloDetDescriptor.h:588
Gep::GepCaloCell::etaMax
float etaMax
Definition: GepCaloCell.h:29
LArNeighbours::super3D
@ super3D
Definition: LArNeighbours.h:29
CaloCellsHandlerTool::m_doGepHardwareStyleEnergyEncoding
Gaudi::Property< bool > m_doGepHardwareStyleEnergyEncoding
Definition: CaloCellsHandlerTool.h:99
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
CaloCellsHandlerTool::m_LArCellMap
Gaudi::Property< std::string > m_LArCellMap
Definition: CaloCellsHandlerTool.h:101
CaloCellsHandlerTool::setNumberOfEnergyBits
StatusCode setNumberOfEnergyBits(int value)
Definition: CaloCellsHandlerTool.h:42
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
CaloCellContainer::findCell
const CaloCell * findCell(const IdentifierHash theHash) const
fast find method given identifier hash.
Definition: CaloCellContainer.cxx:345
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloNoise
Definition: CaloNoise.h:16
CaloCell_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
Gep::GepCaloCell::phiGranularity
float phiGranularity
Definition: GepCaloCell.h:33
Gep::GepCaloCell::isEM
bool isEM
Definition: GepCaloCell.h:43
CaloCellsHandlerTool::m_readoutRanges
int m_readoutRanges[5]
Definition: CaloCellsHandlerTool.h:92
Gep::GepCaloCell::FEB
std::string FEB
Definition: GepCaloCell.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
Gep::GepCaloCell::cosPhi
float cosPhi
Definition: GepCaloCell.h:37
Gep::GepCaloCell::index
int index
Definition: GepCaloCell.h:65
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
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
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
CaloCellsHandlerTool::setG
StatusCode setG(int value)
Definition: CaloCellsHandlerTool.h:72
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LArCellBinning.step
step
Definition: LArCellBinning.py:158
CaloCellsHandlerTool::m_GepEnergyEncodingScheme
Gaudi::Property< std::string > m_GepEnergyEncodingScheme
Definition: CaloCellsHandlerTool.h:98
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
CaloCellsHandlerTool::getNeighbours
std::vector< unsigned int > getNeighbours(const CaloCellContainer &allcells, const CaloCell *acell, const EventContext &) const
Definition: CaloCellsHandlerTool.cxx:293
Gep::GepCaloCell::isEM_barrelPos
bool isEM_barrelPos
Definition: GepCaloCell.h:46
CaloSampling::getSamplingName
static std::string getSamplingName(CaloSample theSample)
Returns a string (name) for each CaloSampling.
Definition: Calorimeter/CaloGeoHelpers/Root/CaloSampling.cxx:18
Gep::GepCaloCell::detName
std::string detName
Definition: GepCaloCell.h:53
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
Gep::GepCaloCell::eta
float eta
Definition: GepCaloCell.h:26
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
CaloCellsHandlerTool::m_CaloCell_ID
const CaloCell_ID * m_CaloCell_ID
Definition: CaloCellsHandlerTool.h:117
Gep::GepCaloCell::isEM_barrelNeg
bool isEM_barrelNeg
Definition: GepCaloCell.h:47
CaloCellsHandlerTool::m_stepsPerRange
int m_stepsPerRange
Definition: CaloCellsHandlerTool.h:93
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Gep::GepCaloCell::z
float z
Definition: GepCaloCell.h:41
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
Gep::GepCaloCell::sinTh
float sinTh
Definition: GepCaloCell.h:34
readCCLHist.float
float
Definition: readCCLHist.py:83
Gep::GepCaloCell::sinPhi
float sinPhi
Definition: GepCaloCell.h:36
Gep::GepCaloCell::isFCAL
bool isFCAL
Definition: GepCaloCell.h:48
fitman.k
k
Definition: fitman.py:528