ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
LVL1::eFEXegAlgo Class Reference

The eFEXegAlgo class calculates the egamma TOB variables: Reta, Rhad and Wstot. More...

#include <eFEXegAlgo.h>

Inheritance diagram for LVL1::eFEXegAlgo:
Collaboration diagram for LVL1::eFEXegAlgo:

Public Member Functions

 eFEXegAlgo (const std::string &type, const std::string &name, const IInterface *parent)
 Constructors. More...
 
virtual StatusCode initialize () override
 standard Athena-Algorithm method More...
 
virtual ~eFEXegAlgo ()
 Destructor. More...
 
virtual StatusCode safetyTest () const override
 
virtual void setup (int inputTable[3][3], int efex_id, int fpga_id, int central_eta) override
 
virtual void getReta (std::vector< unsigned int > &) override
 
virtual void getRhad (std::vector< unsigned int > &) override
 
virtual void getWstot (std::vector< unsigned int > &) override
 
virtual void getRealPhi (float &phi) override
 
virtual void getRealEta (float &eta) override
 
virtual std::unique_ptr< eFEXegTOB > geteFEXegTOB () override
 
virtual void getClusterCells (std::vector< unsigned int > &cellETs) override
 Return cell ET values used in cluster. More...
 
virtual unsigned int getET () override
 
virtual unsigned int dmCorrection (unsigned int ET, unsigned int layer) override
 
virtual void getWindowET (int layer, int jPhi, int SCID, unsigned int &) override
 
virtual bool hasSeed () const override
 
virtual unsigned int getSeed () const override
 
virtual unsigned int getUnD () const override
 
virtual void getCoreEMTowerET (unsigned int &et) override
 
virtual void getCoreHADTowerET (unsigned int &et) override
 
virtual void getSums (unsigned int seed, bool UnD, std::vector< unsigned int > &RetaSums, std::vector< unsigned int > &RhadSums, std::vector< unsigned int > &WstotSums) override
 
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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

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< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void setSeed ()
 
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

bool m_seed_UnD = false
 
unsigned int m_seedID = 999
 
int m_eFEXegAlgoTowerID [3][3]
 
int m_efexid
 
int m_fpgaid
 
int m_central_eta
 
bool m_hasSeed
 
Gaudi::Property< bool > m_dmCorr {this, "dmCorr", false, "Enable dead material correctionst"}
 
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerKey {this, "MyETowers", "eTowerContainer", "Input container for eTowers"}
 
SG::ReadCondHandleKey< CondAttrListCollection > m_dmCorrectionsKey
 
std::mutex m_dmCorrectionsMutex
 
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
 

Static Private Attributes

static thread_local bool s_dmCorrectionsLoaded = false
 

Detailed Description

The eFEXegAlgo class calculates the egamma TOB variables: Reta, Rhad and Wstot.

Definition at line 30 of file eFEXegAlgo.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

◆ eFEXegAlgo()

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

Constructors.

Definition at line 30 of file eFEXegAlgo.cxx.

30  :
31  AthAlgTool(type, name, parent)
32  {
33  declareInterface<IeFEXegAlgo>(this);
34  }

◆ ~eFEXegAlgo()

LVL1::eFEXegAlgo::~eFEXegAlgo ( )
virtual

Destructor.

Definition at line 37 of file eFEXegAlgo.cxx.

38 {
39 }

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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, 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; }

◆ dmCorrection()

unsigned int LVL1::eFEXegAlgo::dmCorrection ( unsigned int  ET,
unsigned int  layer 
)
overridevirtual

Check corrections are required and layer is valid, otherwise do nothing

Get correction factor Start by calculating RoI |eta| with range 0-24

Retrieve the factor from table (eventually from DB)

Calculate correction Factors are 7 bit words, highest bit corresponding to the most significant term in the correction (ET/2). So we'll work backwards from the top bit (bit 6) to implement it

And this should now be the corrected ET

Implements LVL1::IeFEXegAlgo.

Definition at line 303 of file eFEXegAlgo.cxx.

303  {
305  if ( !m_dmCorr || layer > 2 ) return ET;
306 
309  int efexEta = m_efexid%3;
310  int ieta = 0;
311  if (efexEta == 2) { // Rightmost eFEX
312  // m_central_eta has range 1-4 or 1-5
313  ieta = 8 + m_fpgaid*4 + m_central_eta - 1;
314  }
315  else if (efexEta == 1 && m_fpgaid > 1) { // central eFEX, eta > 0
316  // m_central_eta has range 1-4
317  ieta = (m_fpgaid-2)*4 + m_central_eta - 1;
318  }
319  else if (efexEta == 1) { // central eFEX, eta < 0
320  // m_central_eta had range 1-4
321  ieta = (1-m_fpgaid)*4 + (4-m_central_eta);
322  }
323  else { // Leftmost eFEX
324  // m_central_eta has range 0-4 or 1-4
325  ieta = 8 + 4*(3-m_fpgaid) + (4-m_central_eta);
326  }
327 
328  if (!s_dmCorrectionsLoaded) {
329  std::lock_guard<std::mutex> lk(m_dmCorrectionsMutex); // ensure only one thread tries to load corrections
330  if (!m_dmCorrectionsKey.empty()) {
331  // replace s_corrections values with values from database ... only try this once
332  SG::ReadCondHandle <CondAttrListCollection> dmCorrections{m_dmCorrectionsKey/*, ctx*/ };
333  if (dmCorrections.isValid()) {
334  if(dmCorrections->size()==0 && Gaudi::Hive::currentContext().eventID().time_stamp()>1672527600) { // not an error for data before 2023 (will include MC21 and MC23a)
335  ATH_MSG_ERROR("No dead material corrections found in conditions database for this event in folder " << m_dmCorrectionsKey.key());
336  throw std::runtime_error("No dead material corrections found in database for this event");
337  }
338  for (auto itr = dmCorrections->begin(); itr != dmCorrections->end(); ++itr) {
339  if (itr->first < 25 || itr->first >= 50) continue;
340  s_corrections[0][itr->first - 25] = itr->second["EmPS"].data<int>();
341  s_corrections[1][itr->first - 25] = itr->second["EmFR"].data<int>();
342  s_corrections[2][itr->first - 25] = itr->second["EmMD"].data<int>();
343  ATH_MSG_DEBUG("DM Correction for etaIdx=" << (itr->first - 25) << " : [" << s_corrections[0][itr->first - 25] << ","
344  << s_corrections[1][itr->first - 25] << "," << s_corrections[2][itr->first - 25] << "]" );
345  }
346  }
347  ATH_MSG_INFO("Loaded DM Corrections from database");
348  }
349  s_dmCorrectionsLoaded = true;
350  }
351 
353  unsigned int factor = s_corrections[layer][ieta];
354 
360  unsigned int correction = ET;
361  for (int bit = 6; bit >= 0; bit--) {
362  correction /= 2;
363  if (factor & (1<<bit))
364  ET += correction;
365  }
367  return ET;
368 }

◆ 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

◆ getClusterCells()

void LVL1::eFEXegAlgo::getClusterCells ( std::vector< unsigned int > &  cellETs)
overridevirtual

Return cell ET values used in cluster.

Placed in its own function to allow other classes to access these

Implements LVL1::IeFEXegAlgo.

Definition at line 235 of file eFEXegAlgo.cxx.

235  {
236 
237  int phiUpDownID = 0;
238  if (m_seed_UnD) phiUpDownID = 2;
239 
240  // Initialise results vector
241  cellETs.resize(16,0);
242  // Fill vector with 2 PS cells, 6 L1, 6 L2, 2 L3
243  // Presampler
244  getWindowET(0, 1, 0, cellETs[0]);
245  getWindowET(0, phiUpDownID, 0, cellETs[1]);
246  // central phi Layer 1
247  getWindowET(1, 1, m_seedID, cellETs[2]);
248  getWindowET(1, 1, m_seedID - 1, cellETs[3]);
249  getWindowET(1, 1, m_seedID + 1, cellETs[4]);
250  // top/bottom phi Layer 1
251  getWindowET(1, phiUpDownID, m_seedID, cellETs[5]);
252  getWindowET(1, phiUpDownID, m_seedID - 1, cellETs[6]);
253  getWindowET(1, phiUpDownID, m_seedID + 1, cellETs[7]);
254  // central phi Layer 2
255  getWindowET(2, 1, m_seedID, cellETs[8]);
256  getWindowET(2, 1, m_seedID - 1, cellETs[9]);
257  getWindowET(2, 1, m_seedID + 1, cellETs[10]);
258  // top/bottom phi Layer 2
259  getWindowET(2, phiUpDownID, m_seedID, cellETs[11]);
260  getWindowET(2, phiUpDownID, m_seedID - 1, cellETs[12]);
261  getWindowET(2, phiUpDownID, m_seedID + 1, cellETs[13]);
262  // Layer 3
263  getWindowET(3, 1, 0, cellETs[14]);
264  getWindowET(3, phiUpDownID, 0, cellETs[15]);
265 
266  return;
267 
268 }

◆ getCoreEMTowerET()

void LVL1::eFEXegAlgo::getCoreEMTowerET ( unsigned int &  et)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 73 of file eFEXegAlgo.cxx.

73  {
74 
75  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
76 
77  const LVL1::eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1]);
78  et = tmpTower->getLayerTotalET(0) + tmpTower->getLayerTotalET(1) + tmpTower->getLayerTotalET(2) + tmpTower->getLayerTotalET(3);
79 }

◆ getCoreHADTowerET()

void LVL1::eFEXegAlgo::getCoreHADTowerET ( unsigned int &  et)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 81 of file eFEXegAlgo.cxx.

81  {
82 
83  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
84 
85  const LVL1::eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1]);
86  et = tmpTower->getLayerTotalET(4);
87 }

◆ geteFEXegTOB()

std::unique_ptr< eFEXegTOB > LVL1::eFEXegAlgo::geteFEXegTOB ( )
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 371 of file eFEXegAlgo.cxx.

371  {
372 
373  std::unique_ptr<eFEXegTOB> out = std::make_unique<eFEXegTOB>();
374  out->setET(getET());
375 
376  std::vector<unsigned int> temvector;
377  getWstot(temvector);
378  // For wstot, num and den seem switched around, but this is because the 'numerator' and 'denominator'
379  // mean different things at different points in the processing chain
380  // When the threshold comparison is done in the SetIsoWP function, we actually check Den/Num
381  out->setWstotNum(temvector[1]);
382  out->setWstotDen(temvector[0]);
383  getRhad(temvector);
384  out->setRhadEM(temvector[0]);
385  out->setRhadHad(temvector[1]);
386  getReta(temvector);
387  out->setRetaCore(temvector[0]);
388  out->setRetaEnv(temvector[1]);
389  out->setSeedUnD(m_seed_UnD);
390  out->setSeed(m_seedID);
391  return out;
392 }

◆ getET()

unsigned int LVL1::eFEXegAlgo::getET ( )
overridevirtual

Get cells used in cluster

Layer sums including dead material corrections

Final ET sum

Implements LVL1::IeFEXegAlgo.

Definition at line 270 of file eFEXegAlgo.cxx.

270  {
271 
273  std::vector<unsigned int> clusterCells;
274  getClusterCells(clusterCells);
275 
277  unsigned int PS_ET = dmCorrection(clusterCells[0], 0)
278  + dmCorrection(clusterCells[1], 0);
279  unsigned int L1_ET = dmCorrection(clusterCells[2], 1)
280  + dmCorrection(clusterCells[3], 1)
281  + dmCorrection(clusterCells[4], 1)
282  + dmCorrection(clusterCells[5], 1)
283  + dmCorrection(clusterCells[6], 1)
284  + dmCorrection(clusterCells[7], 1);
285  unsigned int L2_ET = dmCorrection(clusterCells[8], 2)
286  + dmCorrection(clusterCells[9], 2)
287  + dmCorrection(clusterCells[10], 2)
288  + dmCorrection(clusterCells[11], 2)
289  + dmCorrection(clusterCells[12], 2)
290  + dmCorrection(clusterCells[13], 2);
291  unsigned int L3_ET = clusterCells[14] + clusterCells[15];
292 
294  unsigned int totET = PS_ET + L1_ET + L2_ET + L3_ET;
295 
296  // overflow handling
297  if (totET > 0xffff) totET = 0xffff;
298 
299  return totET;
300 
301 }

◆ getRealEta()

void LVL1::eFEXegAlgo::getRealEta ( float &  eta)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 96 of file eFEXegAlgo.cxx.

96  {
97 
98  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
99 
100  eta = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->eta() * eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->getPosNeg();
101 
102 }

◆ getRealPhi()

void LVL1::eFEXegAlgo::getRealPhi ( float &  phi)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 89 of file eFEXegAlgo.cxx.

89  {
90 
91  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
92  phi = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->phi();
93 
94 }

◆ getReta()

void LVL1::eFEXegAlgo::getReta ( std::vector< unsigned int > &  retavec)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 104 of file eFEXegAlgo.cxx.

104  {
105 
106  unsigned int coresum = 0; // 3x2 L2 sum : core
107  unsigned int totalsum = 0; // 7x3 L2 sum : total
108  unsigned int envsum = 0; // total - core : env
109 
110  retavec.clear(); // clear the output vector before starting
111 
112  // window limits
113  int iTotalStart = m_seedID-3;
114  int iTotalEnd = m_seedID+3;
115  int iCoreStart = m_seedID-1;
116  int iCoreEnd = m_seedID+1;
117  int phiStart = -999;
118  int phiEnd = -99;
119  if (m_seed_UnD) {
120  phiStart = 1;
121  phiEnd = 2;
122  } else {
123  phiStart = 0;
124  phiEnd = 1;
125  }
126 
127  // 3x2 and 7x3 L2 sum
128  for (int i=iTotalStart; i<=iTotalEnd; ++i) { // eta
129  for(int j=0; j<=2; ++j) { // phi
130  if (i>=iCoreStart && i <= iCoreEnd && j>=phiStart && j<=phiEnd) {
131  unsigned int tmp_et; getWindowET(2,j,i,tmp_et);
132  coresum += tmp_et;
133  }
134 
135  unsigned int tmptot_et; getWindowET(2,j,i,tmptot_et);
136  totalsum += tmptot_et;
137  }
138  }
139 
140  // get environment
141  envsum = totalsum - coresum;
142 
143  // Overflow handling
144  if (coresum > 0xffff) coresum = 0xffff;
145  if (envsum > 0xffff) envsum = 0xffff;
146 
147  // Return results
148  retavec.push_back(coresum);
149  retavec.push_back(envsum);
150 
151 }

◆ getRhad()

void LVL1::eFEXegAlgo::getRhad ( std::vector< unsigned int > &  rhadvec)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 153 of file eFEXegAlgo.cxx.

153  {
154 
155  unsigned int hadsum = 0; // 3x3 Towers Had
156  unsigned int emsum = 0; // (1x3 + 3x3 + 3x3 + 1x3) SCs EM
157 
158  rhadvec.clear(); // clear the output vector before starting
159 
160  int iCoreStart = m_seedID-1;
161  int iCoreEnd = m_seedID+1;
162 
163  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
164 
165  // 3x3 Towers Had ; 1x3 L0 + 1x3 L3 EM
166  for (int i=0; i<3; ++i) { // phi
167  for (int j=0; j<=2; ++j) { // eta
168  if (((m_efexid%3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0) && (j == 0)) || ((m_efexid%3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5) && (j == 2))) {
169  continue;
170  } else {
171  const eTower * tTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[i][j]);
172  hadsum += tTower->getLayerTotalET(4);
173  if (j==1) {
174  emsum += ( tTower->getLayerTotalET(0) + tTower->getLayerTotalET(3) );
175  }
176  }
177  }
178  }
179 
180  // 3x3 SCs L1 and L2 sum
181  for (int i=iCoreStart; i<=iCoreEnd; ++i) { // eta
182  for(int j=0; j<=2; ++j) { // phi
183  unsigned int tmp_et_a, tmp_et_b;
184  getWindowET(1,j,i,tmp_et_a);
185  getWindowET(2,j,i,tmp_et_b);
186  emsum += ( tmp_et_a + tmp_et_b );
187  }
188  }
189 
190  // Overflow handling
191  if (emsum > 0xffff) emsum = 0xffff;
192  if (hadsum > 0xffff) hadsum = 0xffff;
193 
194  // Return results
195  rhadvec.push_back(emsum);
196  rhadvec.push_back(hadsum);
197 
198 }

◆ getSeed()

virtual unsigned int LVL1::eFEXegAlgo::getSeed ( ) const
inlineoverridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 56 of file eFEXegAlgo.h.

56 {return m_seedID;};

◆ getSums()

void LVL1::eFEXegAlgo::getSums ( unsigned int  seed,
bool  UnD,
std::vector< unsigned int > &  RetaSums,
std::vector< unsigned int > &  RhadSums,
std::vector< unsigned int > &  WstotSums 
)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 439 of file eFEXegAlgo.cxx.

443 {
444  // Set seed parameters to supplied values
445  m_seed_UnD = UnD;
446  m_seedID = seed;
447  m_hasSeed = true;
448 
449  // Now just call the 3 discriminant calculation methods
450  getReta(RetaSums);
451  getRhad(RhadSums);
452  getWstot(WstotSums);
453 
454 }

◆ getUnD()

virtual unsigned int LVL1::eFEXegAlgo::getUnD ( ) const
inlineoverridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 57 of file eFEXegAlgo.h.

57 {return m_seed_UnD;};

◆ getWindowET()

void LVL1::eFEXegAlgo::getWindowET ( int  layer,
int  jPhi,
int  SCID,
unsigned int &  outET 
)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 394 of file eFEXegAlgo.cxx.

394  {
395 
396  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
397 
398  if (SCID<0) { // left towers in eta
399  if ((m_efexid%3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0)) {
400  outET = 0;
401  } else {
402  int etaID = 4+SCID;
403  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][0]);
404  if (layer==1 || layer==2) {
405  outET = tmpTower->getET(layer,etaID);
406  } else if (layer==0 || layer==3 || layer==4) {
407  outET = tmpTower->getLayerTotalET(layer);
408  }
409  }
410  } else if (SCID>=0 && SCID<4) { // central towers in eta
411  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][1]);
412  if (layer==1 || layer==2) {
413  outET = tmpTower->getET(layer,SCID);
414  } else if (layer==0 || layer==3 || layer==4) {
415  outET = tmpTower->getLayerTotalET(layer);
416  }
417  } else if (SCID>=4){ // right towers in eta
418  if ((m_efexid%3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5)) {
419  outET = 0;
420  } else {
421  int etaID = SCID-4;
422  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][2]);
423  if (layer==1 || layer==2) {
424  outET = tmpTower->getET(layer,etaID);
425  } else if (layer==0 || layer==3 || layer==4) {
426  outET = tmpTower->getLayerTotalET(layer);
427  }
428  }
429  }
430 
431  // overflow handling
432  if (outET > 0xffff) outET = 0xffff;
433 
434 }

◆ getWstot()

void LVL1::eFEXegAlgo::getWstot ( std::vector< unsigned int > &  output)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 200 of file eFEXegAlgo.cxx.

200  {
201  unsigned int numer = 0;
202  unsigned int den = 0;
203 
204  output.clear(); // clear the output vector before starting
205 
206  int iStart = m_seedID - 2;
207  int iEnd = m_seedID + 2;
208 
209  for (int i = iStart; i <= iEnd; ++i) { // eta
210  int diff = i - m_seedID;
211  unsigned int weight = diff*diff;
212  for (int j = 0; j <= 2; ++j) { // phi
213  unsigned int eT;
214  getWindowET(1, j, i, eT);
215  // NB need to be careful as numer and den are defined such that wstot=numer/den,
216  // but in the firmware (and therefore this bitwise code) we actually
217  // check that den/numer < Threshold
218  numer += eT*weight;
219  den += eT;
220  }
221  }
222 
223  // Overflow handling
224  //if (den > 0xffff) den = 0xffff; - commented out so that denom can overflow, will then automatically pass all thresholds (see eFEXFPGA::SetIsoWP)
225  if (numer > 0xffff) numer = 0xffff;
226 
227  // Return results
228  output.push_back(den);
229  output.push_back(numer);
230 
231 }

◆ hasSeed()

virtual bool LVL1::eFEXegAlgo::hasSeed ( ) const
inlineoverridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 55 of file eFEXegAlgo.h.

55 {return m_hasSeed;};

◆ initialize()

StatusCode LVL1::eFEXegAlgo::initialize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 41 of file eFEXegAlgo.cxx.

41  {
42 
43  ATH_CHECK(m_eTowerContainerKey.initialize());
44  ATH_CHECK( m_dmCorrectionsKey.initialize(SG::AllowEmpty) );
45 
46  return StatusCode::SUCCESS;
47 }

◆ 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.

◆ interfaceID()

const InterfaceID & LVL1::IeFEXegAlgo::interfaceID ( )
inlinestaticinherited

Definition at line 53 of file IeFEXegAlgo.h.

54  {
55  return IID_IeFEXegAlgo;
56  }

◆ 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.

◆ 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  }

◆ safetyTest()

StatusCode LVL1::eFEXegAlgo::safetyTest ( ) const
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 50 of file eFEXegAlgo.cxx.

50  {
51 
52  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
53  if(!eTowerContainer.isValid()){
54  ATH_MSG_FATAL("Could not retrieve container " << m_eTowerContainerKey.key() );
55  return StatusCode::FAILURE;
56  }
57 
58  return StatusCode::SUCCESS;
59 }

◆ setSeed()

void LVL1::eFEXegAlgo::setSeed ( )
private

Definition at line 458 of file eFEXegAlgo.cxx.

458  {
459 
460  m_hasSeed = false;
461  m_seed_UnD = false;
462  unsigned int tmpID = 999;
463  unsigned int maxET = 0;
464 
465  for (int i=0; i<4 ; ++i) {
466  int iSeedL = i-1;
467  int iSeedR = i+1;
468 
469  // eta ID of candidate seed
470  unsigned int cETUp;
471  getWindowET(2,2,i,cETUp);
472  unsigned int iSeedET;
473  getWindowET(2,1,i, iSeedET);
474  unsigned int cETDown;
475  getWindowET(2,0,i, cETDown);
476 
477  // left of candidate seed
478  unsigned int lETUp;
479  getWindowET(2,2,iSeedL,lETUp);
480  unsigned int lET;
481  getWindowET(2,1,iSeedL,lET);
482  unsigned int lETDown;
483  getWindowET(2,0,iSeedL,lETDown);
484 
485  // right of candidate seed
486  unsigned int rETUp;
487  getWindowET(2,2,iSeedR,rETUp);
488  unsigned int rET;
489  getWindowET(2,1,iSeedR,rET);
490  unsigned int rETDown;
491  getWindowET(2,0,iSeedR,rETDown);
492 
493  // greater or equal than for left and down cells, greater than for right and up ones
494  if (iSeedET>=lET && iSeedET>rET
495  && iSeedET>=lETUp && iSeedET>cETUp && iSeedET>rETUp
496  && iSeedET>=lETDown && iSeedET>=cETDown && iSeedET>rETDown) {
497  if (iSeedET>=maxET) { // if two maxima exist and have the same ET, keep the one to the right
498  maxET = iSeedET;
499  tmpID = i;
500  }
501  }
502  }
503 
504  if(tmpID!=999) {
505  m_seedID = tmpID;
506  m_hasSeed = true;
507  unsigned int tmp_et_up, tmp_et_down;
508  getWindowET(2,2,m_seedID,tmp_et_up);
509  getWindowET(2,0,m_seedID,tmp_et_down);
510  if (tmp_et_up >= tmp_et_down) {
511  m_seed_UnD = true; // go up if energy greater or equal to bottom
512  }
513  }
514 }

◆ setup()

void LVL1::eFEXegAlgo::setup ( int  inputTable[3][3],
int  efex_id,
int  fpga_id,
int  central_eta 
)
overridevirtual

Implements LVL1::IeFEXegAlgo.

Definition at line 61 of file eFEXegAlgo.cxx.

61  {
62 
63  std::copy(&inputTable[0][0], &inputTable[0][0] + 9, &m_eFEXegAlgoTowerID[0][0]);
64 
65  m_efexid = efex_id;
66  m_fpgaid = fpga_id;
67  m_central_eta = central_eta;
68 
69  setSeed();
70 
71 }

◆ 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_central_eta

int LVL1::eFEXegAlgo::m_central_eta
private

Definition at line 71 of file eFEXegAlgo.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_dmCorr

Gaudi::Property<bool> LVL1::eFEXegAlgo::m_dmCorr {this, "dmCorr", false, "Enable dead material correctionst"}
private

Definition at line 75 of file eFEXegAlgo.h.

◆ m_dmCorrectionsKey

SG::ReadCondHandleKey<CondAttrListCollection> LVL1::eFEXegAlgo::m_dmCorrectionsKey
private
Initial value:
{this,"DMCorrectionsKey","",
"Key to dead material corrections (AttrListCollection)"}

Definition at line 81 of file eFEXegAlgo.h.

◆ m_dmCorrectionsMutex

std::mutex LVL1::eFEXegAlgo::m_dmCorrectionsMutex
private

Definition at line 84 of file eFEXegAlgo.h.

◆ m_eFEXegAlgoTowerID

int LVL1::eFEXegAlgo::m_eFEXegAlgoTowerID[3][3]
private

Definition at line 68 of file eFEXegAlgo.h.

◆ m_efexid

int LVL1::eFEXegAlgo::m_efexid
private

Definition at line 69 of file eFEXegAlgo.h.

◆ m_eTowerContainerKey

SG::ReadHandleKey<LVL1::eTowerContainer> LVL1::eFEXegAlgo::m_eTowerContainerKey {this, "MyETowers", "eTowerContainer", "Input container for eTowers"}
private

Definition at line 78 of file eFEXegAlgo.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_fpgaid

int LVL1::eFEXegAlgo::m_fpgaid
private

Definition at line 70 of file eFEXegAlgo.h.

◆ m_hasSeed

bool LVL1::eFEXegAlgo::m_hasSeed
private

Definition at line 72 of file eFEXegAlgo.h.

◆ m_seed_UnD

bool LVL1::eFEXegAlgo::m_seed_UnD = false
private

Definition at line 66 of file eFEXegAlgo.h.

◆ m_seedID

unsigned int LVL1::eFEXegAlgo::m_seedID = 999
private

Definition at line 67 of file eFEXegAlgo.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.

◆ s_dmCorrectionsLoaded

bool thread_local LVL1::eFEXegAlgo::s_dmCorrectionsLoaded = false
staticprivate

Definition at line 83 of file eFEXegAlgo.h.

The documentation for this class was generated from the following files:
LVL1::eFEXegAlgo::m_hasSeed
bool m_hasSeed
Definition: eFEXegAlgo.h:72
eTowerContainer
Container class for eTower.
LVL1::eFEXegAlgo::dmCorrection
virtual unsigned int dmCorrection(unsigned int ET, unsigned int layer) override
Definition: eFEXegAlgo.cxx:303
et
Extra patterns decribing particle interation process.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LVL1::eFEXegAlgo::m_efexid
int m_efexid
Definition: eFEXegAlgo.h:69
LVL1::eFEXegAlgo::m_seed_UnD
bool m_seed_UnD
Definition: eFEXegAlgo.h:66
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
LVL1::eFEXegAlgo::getRhad
virtual void getRhad(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:153
LVL1::eTower
The eTower class is an interface object for eFEX trigger algorithms The purposes are twofold:
Definition: eTower.h:38
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LVL1::eFEXegAlgo::m_eTowerContainerKey
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerKey
Definition: eFEXegAlgo.h:78
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1::eFEXegAlgo::m_dmCorrectionsMutex
std::mutex m_dmCorrectionsMutex
Definition: eFEXegAlgo.h:84
LVL1::eFEXegAlgo::m_central_eta
int m_central_eta
Definition: eFEXegAlgo.h:71
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
LVL1::eFEXegAlgo::m_seedID
unsigned int m_seedID
Definition: eFEXegAlgo.h:67
LVL1::eFEXegAlgo::getReta
virtual void getReta(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:104
LVL1::eFEXegAlgo::getET
virtual unsigned int getET() override
Definition: eFEXegAlgo.cxx:270
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
tools.zlumi_mc_cf.correction
def correction(mu, runmode, campaign, run=None)
Definition: zlumi_mc_cf.py:4
LVL1::eFEXegAlgo::setSeed
void setSeed()
Definition: eFEXegAlgo.cxx:458
LVL1::eFEXegAlgo::getClusterCells
virtual void getClusterCells(std::vector< unsigned int > &cellETs) override
Return cell ET values used in cluster.
Definition: eFEXegAlgo.cxx:235
LVL1::eFEXegAlgo::m_dmCorr
Gaudi::Property< bool > m_dmCorr
Definition: eFEXegAlgo.h:75
LVL1::eFEXegAlgo::getWindowET
virtual void getWindowET(int layer, int jPhi, int SCID, unsigned int &) override
Definition: eFEXegAlgo.cxx:394
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDTPM::eT
float eT(const U &p)
Accessor utility function for getting the value of Tranverse energy.
Definition: TrackParametersHelper.h:130
lumiFormat.i
int i
Definition: lumiFormat.py:92
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::eFEXegAlgo::m_eFEXegAlgoTowerID
int m_eFEXegAlgoTowerID[3][3]
Definition: eFEXegAlgo.h:68
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LVL1::eFEXegAlgo::getWstot
virtual void getWstot(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:200
AthCommonDataStore< AthCommonMsg< AlgTool > >::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
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
LVL1::eTower::getLayerTotalET
int getLayerTotalET(unsigned int layer) const
Get total ET sum of all cells in a given layer in MeV.
Definition: eTower.cxx:249
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge.output
output
Definition: merge.py:17
LVL1::eFEXegAlgo::m_dmCorrectionsKey
SG::ReadCondHandleKey< CondAttrListCollection > m_dmCorrectionsKey
Definition: eFEXegAlgo.h:81
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LVL1::eFEXegAlgo::s_dmCorrectionsLoaded
static thread_local bool s_dmCorrectionsLoaded
Definition: eFEXegAlgo.h:83
a
TList * a
Definition: liststreamerinfos.cxx:10
h
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
calibdata.copy
bool copy
Definition: calibdata.py:27
LVL1::eFEXegAlgo::m_fpgaid
int m_fpgaid
Definition: eFEXegAlgo.h:70
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
fitman.k
k
Definition: fitman.py:528
Generated on Fri Jun 28 2024 22:20:04 for ATLAS Offline Software by   doxygen 1.8.18