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

#include <GepCellsHandlerAlg.h>

Inheritance diagram for GepCellsHandlerAlg:
Collaboration diagram for GepCellsHandlerAlg:

Public Member Functions

 GepCellsHandlerAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &) const override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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 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, V, H > &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

StatusCode setNumberOfEnergyBits (int value)
 
StatusCode setLeastSignificantBit (int value)
 
StatusCode setG (int value)
 
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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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
 
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
 
Gaudi::Property< bool > m_doGepHardwareStyleEnergyEncoding
 
Gaudi::Property< bool > m_doTruncationOfOverflowingFEBs
 
Gaudi::Property< bool > m_writeAllCells
 
Gaudi::Property< std::string > m_LArCellMap
 
SG::ReadCondHandleKey< CaloNoisem_electronicNoiseKey {this, "electronicNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}
 Key of the CaloNoise Conditions data object. More...
 
SG::ReadCondHandleKey< CaloNoisem_totalNoiseKey {this, "totalNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}
 
SG::WriteHandleKey< Gep::GepCellMapm_outputGepCellsKey {this, "outputGepCellsKey", "", "Key for GepCell map"}
 
SG::ReadHandleKey< CaloCellContainerm_caloCellsKey {this, "caloCells", "AllCalo", "key to read in a CaloCell constainer"}
 
const CaloCell_IDm_CaloCell_ID {nullptr}
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
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 22 of file GepCellsHandlerAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ GepCellsHandlerAlg()

GepCellsHandlerAlg::GepCellsHandlerAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 14 of file GepCellsHandlerAlg.cxx.

14  :
15 AthReentrantAlgorithm( name, pSvcLocator ){
16  }

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

◆ execute()

StatusCode GepCellsHandlerAlg::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 125 of file GepCellsHandlerAlg.cxx.

125  {
126 
127  // PS this function creates and stores a map which has Gep::GepCaloCells as its values
128  // The cells are made up of data which is invariant for all events, and dynamic
129  // data which varies with event.
130  // The invariant data should be setup in initialize(), and the dynamic
131  // data should be updated here in a way which is compatible with the const-ness of this
132  // function.
133  // This will be attended to in the future.
134 
135  ATH_MSG_DEBUG ("Executing " << name() << "...");
136 
137  // Read in a container containing (all) CaloCells
138  auto h_caloCells = SG::makeHandle(m_caloCellsKey, ctx);
139  CHECK(h_caloCells.isValid());
140  const auto & cells = *h_caloCells;
141 
142  ATH_MSG_DEBUG("Read in " + std::to_string(h_caloCells->size()) + " cells");
143 
144  SG::ReadCondHandle<CaloNoise> electronicNoiseHdl{m_electronicNoiseKey, ctx};
145  if (!electronicNoiseHdl.isValid()) {return StatusCode::FAILURE;}
146  const CaloNoise* electronicNoiseCDO = *electronicNoiseHdl;
147 
149  if (!totalNoiseHdl.isValid()) {return StatusCode::FAILURE;}
150  const CaloNoise* totalNoiseCDO = *totalNoiseHdl;
151 
152  int idx = -1;
153  std::map<std::string,std::vector<Gep::GepCaloCell>> gepCellsPerFEB;
154 
155  for(const auto *cell: cells){
156 
157  Gep::GepCaloCell caloCell;
158  ++idx;
159 
160  caloCell.id = (cell->ID().get_identifier32()).get_compact();
161  auto base_cell_itr = m_gepCellsBase.find(caloCell.id);
162  if (base_cell_itr != m_gepCellsBase.end()) caloCell = base_cell_itr->second;
163  else {
164  // Tile cells are not included in the cell base map
165  // In the future this might change, for now just setting FEB value to a dummy
166  caloCell.FEB = "Tile";
167  }
168 
169  float electronicNoise = electronicNoiseCDO->getNoise(cell->ID(), cell->gain());
170  float totalNoise = totalNoiseCDO->getNoise(cell->ID(), cell->gain());
171 
172  // Only send positive-energy 2sigma cells to the GEP
173  if (((cell->energy() / totalNoise) < 2.0) && !m_writeAllCells) continue;
174 
175  // GEP will only have ET available for LAr cells, so convert to energy from ET
176  caloCell.offline_et = cell->energy() / TMath::CosH(cell->eta());
178  caloCell.et = getGepEnergy(cell->energy() / TMath::CosH(cell->eta()));
179  caloCell.e = caloCell.et * TMath::CosH(cell->eta());
180  }
181  else {
182  caloCell.e = cell->energy();
183  caloCell.et = caloCell.offline_et;
184  }
185  caloCell.time = cell->time();
186  caloCell.quality = cell->quality();
187  caloCell.provenance = cell->provenance();
188 
189  caloCell.totalNoise = totalNoise;
190  caloCell.electronicNoise = electronicNoise;
191  caloCell.sigma = cell->energy() / totalNoise;
192 
193  caloCell.isBad = cell->badcell();
194  caloCell.eta = cell->eta();
195  caloCell.phi = cell->phi();
196  caloCell.sinTh = cell->sinTh();
197  caloCell.cosTh = cell->cosTh();
198  caloCell.sinPhi = cell->sinPhi();
199  caloCell.cosPhi = cell->cosPhi();
200  caloCell.cotTh = cell->cotTh();
201  caloCell.x = cell->x();
202  caloCell.y = cell->y();
203  caloCell.z = cell->z();
204 
205  unsigned int samplingEnum = m_CaloCell_ID->calo_sample(cell->ID());
206 
207  bool IsEM = m_CaloCell_ID->is_em(cell->ID());
208  bool IsEM_Barrel=false;
209  bool IsEM_EndCap=false;
210  bool IsEM_BarrelPos=false;
211  bool IsEM_BarrelNeg=false;
212  if(IsEM){
213  IsEM_Barrel=m_CaloCell_ID->is_em_barrel(cell->ID());
214  if(IsEM_Barrel){
215  if(m_CaloCell_ID->pos_neg(cell->ID())>0) IsEM_BarrelPos=true;
216  }
217  IsEM_EndCap=m_CaloCell_ID->is_em_endcap(cell->ID());
218  }
219 
220  caloCell.isEM = IsEM;
221  caloCell.isEM_barrel = IsEM_Barrel;
222  caloCell.isEM_endCap = IsEM_EndCap;
223  caloCell.isEM_barrelPos = IsEM_BarrelPos;
224  caloCell.isEM_barrelNeg = IsEM_BarrelNeg; //always false?
225  caloCell.isFCAL = m_CaloCell_ID->is_fcal(cell->ID());
226  caloCell.isHEC = m_CaloCell_ID->is_hec(cell->ID());
227  caloCell.isTile = m_CaloCell_ID->is_tile(cell->ID());
228 
229  caloCell.sampling = samplingEnum;
230  caloCell.detName = CaloSampling::getSamplingName(samplingEnum);
231 
232  caloCell.neighbours = getNeighbours(cells, cell, ctx);
233  caloCell.id = (cell->ID().get_identifier32()).get_compact();
234 
235  const CaloDetDescriptor *elt = cell->caloDDE()->descriptor();
236  caloCell.layer = cell->caloDDE()->getLayer();
237 
238  float deta = elt->deta();
239  float dphi = elt->dphi();
240 
241  float etamin = caloCell.eta - (0.5*deta);
242  float etamax = caloCell.eta + (0.5*deta);
243 
244  float phimin = caloCell.phi - (0.5*dphi);
245  float phimax = caloCell.phi + (0.5*dphi);
246 
247  caloCell.etaMin = etamin;
248  caloCell.etaMax = etamax;
249  caloCell.phiMin = phimin;
250  caloCell.phiMax = phimax;
251  caloCell.etaGranularity = deta;
252  caloCell.phiGranularity = dphi;
253 
254  caloCell.index = idx;
255 
256  // Fill cells into map according to FEB
257  auto feb_itr = gepCellsPerFEB.find(caloCell.FEB);
258  if (feb_itr != gepCellsPerFEB.end()) feb_itr->second.push_back(caloCell);
259  else {
260  std::vector<Gep::GepCaloCell> cellsThisFEB;
261  cellsThisFEB.push_back(caloCell);
262  gepCellsPerFEB.insert(std::pair<std::string,std::vector<Gep::GepCaloCell>>(caloCell.FEB,cellsThisFEB));
263  }
264  }
265 
266  Gep::GepCellMap gepCellMap;
267 
268  // do truncation
269  auto itr = gepCellsPerFEB.begin();
270  for ( ;itr != gepCellsPerFEB.end(); ++itr) {
271 
272  // LAr FEBs might overflow, so they will get truncated
273  if (m_doTruncationOfOverflowingFEBs && itr->second.size() > m_maxCellsPerFEB && itr->first != "Tile" && !m_writeAllCells) {
274  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.");
275  CHECK(removeCellsFromOverloadedFEB(itr->second));
276  }
277  for (const Gep::GepCaloCell& cell : itr->second)
278  gepCellMap.insert(cell.id, cell);
279  }
280  ATH_MSG_DEBUG("GEP is receiving a total of " << gepCellMap.size() << " cells in this event");
281 
283  ATH_CHECK( h_gepCellMap.record( std::make_unique<Gep::GepCellMap>(gepCellMap) ) );
284 
285  return StatusCode::SUCCESS;
286 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ getGepEnergy()

int GepCellsHandlerAlg::getGepEnergy ( float  offline_et) const
private

Definition at line 290 of file GepCellsHandlerAlg.cxx.

290  {
291 
292  // If cell saturates readout range, largest possible value is send
293  if (offline_et > m_readoutRanges[4])
295 
296  int readoutRange = 0;
297  for (int i = 1; i <= 3; ++i) {
298  if (offline_et > m_readoutRanges[i]) readoutRange = i;
299  }
300 
301  float step = (static_cast<float>(m_readoutRanges[readoutRange+1]) - static_cast<float>(m_readoutRanges[readoutRange])) / m_stepsPerRange;
302  int gep_energy = -1;
303  for (int i = 0; i < m_stepsPerRange; ++i) {
304  gep_energy = m_readoutRanges[readoutRange]+(step*i);
305  if (offline_et < (m_readoutRanges[readoutRange]+(step*(i+1)))) break;
306  }
307 
308  return gep_energy;
309 }

◆ getNeighbours()

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

Definition at line 314 of file GepCellsHandlerAlg.cxx.

316  {
317 
318  // get all neighboring cells
319  std::vector<IdentifierHash> cellNeighbours;
320 
321  IdentifierHash cellHashID = m_CaloCell_ID->calo_cell_hash(acell->ID());
322  m_CaloCell_ID->get_neighbours(cellHashID,LArNeighbours::super3D,cellNeighbours);
323 
324  std::vector<unsigned int> neighbour_ids;
325  for (unsigned int iNeighbour = 0;
326  iNeighbour < cellNeighbours.size();
327  ++iNeighbour) {
328 
329  const CaloCell* neighbour = allcells.findCell(cellNeighbours[iNeighbour]);
330  if (neighbour) {
331  neighbour_ids.push_back((neighbour->ID().get_identifier32()).get_compact());
332  } else {
333  ATH_MSG_ERROR("Couldn't access neighbour #" << iNeighbour
334  << " for cell ID "
335  << (acell->ID().get_identifier32()).get_compact());
336  }
337  }
338  return neighbour_ids;
339 }

◆ initialize()

StatusCode GepCellsHandlerAlg::initialize ( )
overridevirtual

Definition at line 19 of file GepCellsHandlerAlg.cxx.

19  {
20  ATH_MSG_INFO ("Initializing " << name() << "...");
21  ATH_MSG_INFO ("Target GepCell container name " << m_outputGepCellsKey);
22 
23  // Retrieve AlgTools
26 
29 
30  // CaloIndentifier
31  CHECK( detStore()->retrieve (m_CaloCell_ID, "CaloCell_ID") );
32 
33  ATH_MSG_INFO("Hardware-style energy encoding for GEP cells has been set to " << m_doGepHardwareStyleEnergyEncoding.value());
34  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");
35 
36  ATH_MSG_INFO("Truncation of Gep cells from FEBs which are overflowing has been set to " << m_doTruncationOfOverflowingFEBs.value());
37  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");
38 
39  ATH_MSG_INFO("Flag to enabling the writting of all cells has been set to " << m_writeAllCells.value());
40  if (!m_writeAllCells) ATH_MSG_WARNING("Will write all cells even if they would get truncated for GEP and/or are below the 2sigma threshold. This might lead to large output Ntuples and is not a realistic representation of GEP cells");
41 
42  // Setting up GEP energy encoding scheme
44 
45  // Read values of Gep readout scheme from argument
46  int GepScheme[3];
47  for (int i = 0; i < 3; ++i) {
48  GepScheme[i] = std::stoi(m_GepEnergyEncodingScheme.value().substr(0,m_GepEnergyEncodingScheme.value().find("-")));
49  m_GepEnergyEncodingScheme.value().erase(0, m_GepEnergyEncodingScheme.value().find("-")+1);
50  }
51 
52  CHECK(setNumberOfEnergyBits(GepScheme[0]));
53  CHECK(setLeastSignificantBit(GepScheme[1]));
54  CHECK(setG(GepScheme[2]));
55 
57 
58  m_readoutRanges[0] = 0;
63 
64  ATH_MSG_DEBUG("Readout scheme with " << m_nEnergyBits << "-bits provides the following four energy thresholds (with " << m_stepsPerRange << " discrete steps on each threshold)");
65  ATH_MSG_DEBUG("GEP cell energy range 0: min = " << m_readoutRanges[0] << " MeV -> max = " << m_readoutRanges[1] << " MeV");
66  ATH_MSG_DEBUG("GEP cell energy range 1: min = " << m_readoutRanges[1] + m_valLeastSigBit << " MeV -> max = " << m_readoutRanges[2] << " MeV");
67  ATH_MSG_DEBUG("GEP cell energy range 2: min = " << m_readoutRanges[2]+(m_valG*m_valLeastSigBit) << " MeV -> max = " << m_readoutRanges[3] << " MeV");
68  ATH_MSG_DEBUG("GEP cell energy range 3: min = " << m_readoutRanges[3]+(m_valG*m_valG*m_valLeastSigBit) << " MeV -> max = " << m_readoutRanges[4] << " MeV");
69  }
70 
72  // Loading the invariant cell data and storing in m_gepCellsBase for later use on event-by-event basis
73  m_gepCellsBase.clear();
74 
75  ATH_MSG_DEBUG("Loading cell map associating cells to FEBs");
76 
77  std::string cellMapPath = PathResolverFindCalibFile(m_LArCellMap);
78  if(cellMapPath.empty()) ATH_MSG_ERROR("Could not find file with cell map data: " << m_LArCellMap.value());
79 
80  std::ifstream file(cellMapPath.c_str());
81 
82  unsigned n_cells = 0;
83 
84  // Read input file
85  if (file.is_open()) {
86 
87  int online_id, offline_id, ch, con_num, fbr;
88  std::string feb, con_type;
89 
90  // Skipping header of file
91  std::getline(file, feb);
92 
93  // start reading data
94  while (true) {
95 
96  file >> offline_id >> online_id >> feb >> ch >> con_type >> con_num >> fbr;
97 
98  if (file.eof()) break;
99 
100  Gep::GepCaloCell caloCell;
101  caloCell.id = offline_id;
102  caloCell.FEB = feb;
103  caloCell.channel = ch;
104  caloCell.fiber = fbr;
105  caloCell.connection_type = con_type;
106  caloCell.connection_number = con_num;
107 
108  m_gepCellsBase.insert(std::pair<unsigned int, Gep::GepCaloCell>(caloCell.id, caloCell));
109 
110  ++n_cells;
111  }
112  }
113  else {
114  ATH_MSG_ERROR("Could not open file containing the cell to FEB association");
115  return StatusCode::FAILURE;
116  }
117 
118  ATH_MSG_DEBUG("Loaded FEB information for " << n_cells << " cells");
119  }
120 
121  return StatusCode::SUCCESS;
122 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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 GepCellsHandlerAlg::removeCellsFromOverloadedFEB ( std::vector< Gep::GepCaloCell > &  cells) const
private

Definition at line 343 of file GepCellsHandlerAlg.cxx.

343  {
344 
345  std::map<int,Gep::GepCaloCell> orderedCells;
346  for (const Gep::GepCaloCell& cell : cells)
347  orderedCells.insert(std::pair<int,Gep::GepCaloCell>(cell.channel,cell));
348 
349  cells.clear();
350 
351  std::map<int,Gep::GepCaloCell>::iterator cell_itr = orderedCells.begin();
352  for ( ;cell_itr != orderedCells.end(); ++cell_itr) {
353  cells.push_back(cell_itr->second);
354  if (cells.size() == m_maxCellsPerFEB) break;
355  }
356 
357  return StatusCode::SUCCESS;
358 }

◆ 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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ setG()

StatusCode GepCellsHandlerAlg::setG ( int  value)
inlineprivate

Definition at line 63 of file GepCellsHandlerAlg.h.

63  {
64  if (value < 1) {
65  ATH_MSG_FATAL("The value of G in the GEP energy encoding cannot be set to " << value);
66  return StatusCode::FAILURE;
67  }
68  ATH_MSG_INFO("Setting the value for G in the GEP energy encoding to " << value);
69  m_valG = value;
70 
71  return StatusCode::SUCCESS;
72  }

◆ setLeastSignificantBit()

StatusCode GepCellsHandlerAlg::setLeastSignificantBit ( int  value)
inlineprivate

Definition at line 52 of file GepCellsHandlerAlg.h.

52  {
53  if (value < 1) {
54  ATH_MSG_FATAL("The value of the least significant bit in the GEP energy encoding cannot be set to " << value);
55  return StatusCode::FAILURE;
56  }
57  ATH_MSG_INFO("Setting the value for the least significant bit in the GEP energy encoding to " << value << " MeV");
59 
60  return StatusCode::SUCCESS;
61  }

◆ setNumberOfEnergyBits()

StatusCode GepCellsHandlerAlg::setNumberOfEnergyBits ( int  value)
inlineprivate

Definition at line 33 of file GepCellsHandlerAlg.h.

33  {
34 
35  // At the moment only have a detailed scheme for 6-10 bit readouts, thus rejecting any other value
36  switch(value) {
37  case 6: m_maxCellsPerFEB = 62; break;
38  case 7: m_maxCellsPerFEB = 54; break;
39  case 8: m_maxCellsPerFEB = 48; break;
40  case 9: m_maxCellsPerFEB = 43; break;
41  case 10: m_maxCellsPerFEB = 39; break;
42  default: ATH_MSG_FATAL("A GEP energy encoding scheme with " << value << " energy bits is currently not defined");
43  return StatusCode::FAILURE;
44  }
45 
46  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");
48 
49  return StatusCode::SUCCESS;
50  }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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* GepCellsHandlerAlg::m_CaloCell_ID {nullptr}
private

Definition at line 110 of file GepCellsHandlerAlg.h.

◆ m_caloCellsKey

SG::ReadHandleKey<CaloCellContainer> GepCellsHandlerAlg::m_caloCellsKey {this, "caloCells", "AllCalo", "key to read in a CaloCell constainer"}
private

Definition at line 108 of file GepCellsHandlerAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doGepHardwareStyleEnergyEncoding

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

Definition at line 87 of file GepCellsHandlerAlg.h.

◆ m_doTruncationOfOverflowingFEBs

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

Definition at line 90 of file GepCellsHandlerAlg.h.

◆ m_electronicNoiseKey

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

Key of the CaloNoise Conditions data object.

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

Definition at line 102 of file GepCellsHandlerAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_gepCellsBase

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

Definition at line 82 of file GepCellsHandlerAlg.h.

◆ m_GepEnergyEncodingScheme

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

Definition at line 84 of file GepCellsHandlerAlg.h.

◆ m_LArCellMap

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

Definition at line 96 of file GepCellsHandlerAlg.h.

◆ m_maxCellsPerFEB

unsigned GepCellsHandlerAlg::m_maxCellsPerFEB = -1
private

Definition at line 80 of file GepCellsHandlerAlg.h.

◆ m_nEnergyBits

int GepCellsHandlerAlg::m_nEnergyBits = -1
private

Definition at line 75 of file GepCellsHandlerAlg.h.

◆ m_outputGepCellsKey

SG::WriteHandleKey<Gep::GepCellMap> GepCellsHandlerAlg::m_outputGepCellsKey {this, "outputGepCellsKey", "", "Key for GepCell map"}
private

Definition at line 106 of file GepCellsHandlerAlg.h.

◆ m_readoutRanges

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

Definition at line 78 of file GepCellsHandlerAlg.h.

◆ m_stepsPerRange

int GepCellsHandlerAlg::m_stepsPerRange = -1
private

Definition at line 79 of file GepCellsHandlerAlg.h.

◆ m_totalNoiseKey

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

Definition at line 104 of file GepCellsHandlerAlg.h.

◆ m_valG

int GepCellsHandlerAlg::m_valG = -1
private

Definition at line 77 of file GepCellsHandlerAlg.h.

◆ m_valLeastSigBit

int GepCellsHandlerAlg::m_valLeastSigBit = -1
private

Definition at line 76 of file GepCellsHandlerAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeAllCells

Gaudi::Property<bool> GepCellsHandlerAlg::m_writeAllCells
private
Initial value:
{this, "WriteAllCells", false,
"If true, all cells are considered regardless whether they are truncated or below the 2sigma threshold"}

Definition at line 93 of file GepCellsHandlerAlg.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:22
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:281
Gep::GepCaloCell::time
float time
Definition: GepCaloCell.h:17
Gep::GepCaloCell::fiber
int fiber
Definition: GepCaloCell.h:54
egammaPIDObs::IsEM
@ IsEM
cut-based identification for egamma objects (cluster and track-based)
Definition: egammaPIDdefsObs.h:55
Gep::GepCaloCell::offline_et
float offline_et
Definition: GepCaloCell.h:16
Gep::GepCellMap
Definition: GepCellMap.h:17
Gep::GepCaloCell::neighbours
std::vector< unsigned int > neighbours
Definition: GepCaloCell.h:57
Gep::GepCellMap::insert
void insert(unsigned int id, const Gep::GepCaloCell &cell)
Definition: GepCellMap.h:21
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Gep::GepCaloCell::electronicNoise
float electronicNoise
Definition: GepCaloCell.h:21
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
Gep::GepCellMap::size
unsigned int size()
Definition: GepCellMap.h:25
GepCellsHandlerAlg::setLeastSignificantBit
StatusCode setLeastSignificantBit(int value)
Definition: GepCellsHandlerAlg.h:52
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
GepCellsHandlerAlg::m_stepsPerRange
int m_stepsPerRange
Definition: GepCellsHandlerAlg.h:79
Gep::GepCaloCell::phi
float phi
Definition: GepCaloCell.h:25
Gep::GepCaloCell::phiMax
float phiMax
Definition: GepCaloCell.h:29
Gep::GepCaloCell::x
float x
Definition: GepCaloCell.h:37
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:47
GepCellsHandlerAlg::m_gepCellsBase
std::map< unsigned int, Gep::GepCaloCell > m_gepCellsBase
Definition: GepCellsHandlerAlg.h:82
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:18
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
GepCellsHandlerAlg::m_outputGepCellsKey
SG::WriteHandleKey< Gep::GepCellMap > m_outputGepCellsKey
Definition: GepCellsHandlerAlg.h:106
CaloDetDescriptor::dphi
double dphi() const
delta phi
Definition: CaloDetDescriptor.h:593
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
GepCellsHandlerAlg::m_electronicNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_electronicNoiseKey
Key of the CaloNoise Conditions data object.
Definition: GepCellsHandlerAlg.h:102
Gep::GepCaloCell::e
float e
Definition: GepCaloCell.h:14
GepCellsHandlerAlg::m_caloCellsKey
SG::ReadHandleKey< CaloCellContainer > m_caloCellsKey
Definition: GepCellsHandlerAlg.h:108
Gep::GepCaloCell::sampling
unsigned int sampling
Definition: GepCaloCell.h:49
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
athena.value
value
Definition: athena.py:124
GepCellsHandlerAlg::getNeighbours
std::vector< unsigned int > getNeighbours(const CaloCellContainer &allcells, const CaloCell *acell, const EventContext &) const
Definition: GepCellsHandlerAlg.cxx:314
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
GepCellsHandlerAlg::m_nEnergyBits
int m_nEnergyBits
Definition: GepCellsHandlerAlg.h:75
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:15
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
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:23
Gep::GepCaloCell::cosTh
float cosTh
Definition: GepCaloCell.h:33
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
Gep::GepCaloCell::phiMin
float phiMin
Definition: GepCaloCell.h:28
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Gep::GepCaloCell::channel
int channel
Definition: GepCaloCell.h:53
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
Gep::GepCaloCell::provenance
unsigned int provenance
Definition: GepCaloCell.h:19
Gep::GepCaloCell::y
float y
Definition: GepCaloCell.h:38
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
GepCellsHandlerAlg::m_doGepHardwareStyleEnergyEncoding
Gaudi::Property< bool > m_doGepHardwareStyleEnergyEncoding
Definition: GepCellsHandlerAlg.h:87
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
Gep::GepCaloCell::cotTh
float cotTh
Definition: GepCaloCell.h:36
GepCellsHandlerAlg::m_readoutRanges
int m_readoutRanges[5]
Definition: GepCellsHandlerAlg.h:78
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:209
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:42
Gep::GepCaloCell::totalNoise
float totalNoise
Definition: GepCaloCell.h:20
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
Gep::GepCaloCell::isTile
bool isTile
Definition: GepCaloCell.h:48
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:50
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
Gep::GepCaloCell::isEM_endCap
bool isEM_endCap
Definition: GepCaloCell.h:43
Gep::GepCaloCell::connection_type
std::string connection_type
Definition: GepCaloCell.h:55
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
GepCellsHandlerAlg::m_GepEnergyEncodingScheme
Gaudi::Property< std::string > m_GepEnergyEncodingScheme
Definition: GepCellsHandlerAlg.h:84
file
TFile * file
Definition: tile_monitor.h:29
GepCellsHandlerAlg::m_totalNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_totalNoiseKey
Definition: GepCellsHandlerAlg.h:104
Gep::GepCaloCell::layer
int layer
Definition: GepCaloCell.h:40
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
GepCellsHandlerAlg::m_maxCellsPerFEB
unsigned m_maxCellsPerFEB
Definition: GepCellsHandlerAlg.h:80
Gep::GepCaloCell
Definition: GepCaloCell.h:13
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
Gep::GepCaloCell::etaMin
float etaMin
Definition: GepCaloCell.h:26
Gep::GepCaloCell::etaGranularity
float etaGranularity
Definition: GepCaloCell.h:30
CaloDetDescriptor::deta
double deta() const
delta eta
Definition: CaloDetDescriptor.h:588
Gep::GepCaloCell::etaMax
float etaMax
Definition: GepCaloCell.h:27
LArNeighbours::super3D
@ super3D
Definition: LArNeighbours.h:29
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
GepCellsHandlerAlg::m_LArCellMap
Gaudi::Property< std::string > m_LArCellMap
Definition: GepCellsHandlerAlg.h:96
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:31
Gep::GepCaloCell::isEM
bool isEM
Definition: GepCaloCell.h:41
Gep::GepCaloCell::FEB
std::string FEB
Definition: GepCaloCell.h:52
GepCellsHandlerAlg::removeCellsFromOverloadedFEB
StatusCode removeCellsFromOverloadedFEB(std::vector< Gep::GepCaloCell > &cells) const
Definition: GepCellsHandlerAlg.cxx:343
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
GepCellsHandlerAlg::m_writeAllCells
Gaudi::Property< bool > m_writeAllCells
Definition: GepCellsHandlerAlg.h:93
Gep::GepCaloCell::cosPhi
float cosPhi
Definition: GepCaloCell.h:35
Gep::GepCaloCell::index
int index
Definition: GepCaloCell.h:63
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:289
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
GepCellsHandlerAlg::setNumberOfEnergyBits
StatusCode setNumberOfEnergyBits(int value)
Definition: GepCellsHandlerAlg.h:33
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
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
GepCellsHandlerAlg::m_valLeastSigBit
int m_valLeastSigBit
Definition: GepCellsHandlerAlg.h:76
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
GepCellsHandlerAlg::m_CaloCell_ID
const CaloCell_ID * m_CaloCell_ID
Definition: GepCellsHandlerAlg.h:110
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
Gep::GepCaloCell::connection_number
int connection_number
Definition: GepCaloCell.h:56
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
GepCellsHandlerAlg::getGepEnergy
int getGepEnergy(float offline_et) const
Definition: GepCellsHandlerAlg.cxx:290
LArCellBinning.step
step
Definition: LArCellBinning.py:158
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
Gep::GepCaloCell::isEM_barrelPos
bool isEM_barrelPos
Definition: GepCaloCell.h:44
CaloSampling::getSamplingName
static std::string getSamplingName(CaloSample theSample)
Returns a string (name) for each CaloSampling.
Definition: Calorimeter/CaloGeoHelpers/Root/CaloSampling.cxx:18
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Gep::GepCaloCell::detName
std::string detName
Definition: GepCaloCell.h:51
GepCellsHandlerAlg::setG
StatusCode setG(int value)
Definition: GepCellsHandlerAlg.h:63
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:24
GepCellsHandlerAlg::m_doTruncationOfOverflowingFEBs
Gaudi::Property< bool > m_doTruncationOfOverflowingFEBs
Definition: GepCellsHandlerAlg.h:90
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
Gep::GepCaloCell::isEM_barrelNeg
bool isEM_barrelNeg
Definition: GepCaloCell.h:45
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Gep::GepCaloCell::z
float z
Definition: GepCaloCell.h:39
Gep::GepCaloCell::sinTh
float sinTh
Definition: GepCaloCell.h:32
Gep::GepCaloCell::sinPhi
float sinPhi
Definition: GepCaloCell.h:34
Gep::GepCaloCell::isFCAL
bool isFCAL
Definition: GepCaloCell.h:46
fitman.k
k
Definition: fitman.py:528
GepCellsHandlerAlg::m_valG
int m_valG
Definition: GepCellsHandlerAlg.h:77
ServiceHandle< ICondSvc >