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

Simulates the trigger logic in the Tile standalone board. More...

#include <TileCosmicsTrigger.h>

Inheritance diagram for TileCosmicsTrigger:
Collaboration diagram for TileCosmicsTrigger:

Public Member Functions

 TileCosmicsTrigger (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TileCosmicsTrigger ()
 
StatusCode initialize ()
 
StatusCode execute ()
 
StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
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 > &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< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

std::vector< std::string > m_connectedDrawers [8]
 
std::vector< std::string > m_connectedDrawers1
 
std::vector< std::string > m_connectedDrawers2
 
std::vector< std::string > m_connectedDrawers3
 
std::vector< std::string > m_connectedDrawers4
 
std::vector< std::string > m_connectedDrawers5
 
std::vector< std::string > m_connectedDrawers6
 
std::vector< std::string > m_connectedDrawers7
 
std::vector< std::string > m_connectedDrawers8
 
float m_TThreshold
 
int m_NBOARDS
 
int m_NDRAWERSPERBOARD
 
bool m_connectedTowers [NMAXTOWERS]
 
bool m_firedTowers [NMAXTOWERS]
 
float m_towerSum [NMAXTOWERS]
 
int m_boardOfTower [NMAXTOWERS]
 
const CaloLVL1_ID * m_TT_ID
 
TileTTL1Hash * m_TTHash
 
SG::ReadHandleKey< TileTTL1Container > m_ttl1ContainerKey {this, "TileTTL1Container", "TileTTL1Cnt", "Input TileTTL1Container name"}
 
SG::WriteHandleKey< TileTriggerContainer > m_triggerContainerKey {this, "TileTriggerContainer","TileTriggerCnt", "Output TileTriggerContainer name"}
 
DataObjIDColl m_extendedExtraObjects
 
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 const int m_NMaxTowers = NMAXTOWERS
 

Detailed Description

Simulates the trigger logic in the Tile standalone board.

This class simulates the response of the Tile standalone cosmics trigger board. It reads the TileTTL1 objects created at digitization level and applies the board coincidence logic. The output is not just a flag, but a set of energies per board, so that the trigger logic can be applied for different thresholds at the analysis level.

Definition at line 57 of file TileCosmicsTrigger.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TileCosmicsTrigger()

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

Definition at line 41 of file TileCosmicsTrigger.cxx.

42  : AthAlgorithm(name, pSvcLocator)
43  , m_TThreshold(5.0)
44  , m_NBOARDS(8)
45  , m_NDRAWERSPERBOARD(12)
46  //, m_NTOWERSPERDRAWER(8)
47  , m_TT_ID(0)
48  , m_TTHash(0)
49 {
50  for (int iboard = 0; iboard < m_NBOARDS; iboard++) {
51  m_connectedDrawers[iboard].resize(m_NDRAWERSPERBOARD);
52  m_connectedDrawers1.resize(m_NDRAWERSPERBOARD);
53  m_connectedDrawers2.resize(m_NDRAWERSPERBOARD);
54  m_connectedDrawers3.resize(m_NDRAWERSPERBOARD);
55  m_connectedDrawers4.resize(m_NDRAWERSPERBOARD);
56  m_connectedDrawers5.resize(m_NDRAWERSPERBOARD);
57  m_connectedDrawers6.resize(m_NDRAWERSPERBOARD);
58  m_connectedDrawers7.resize(m_NDRAWERSPERBOARD);
59  m_connectedDrawers8.resize(m_NDRAWERSPERBOARD);
60  }
61 
62 //------------------------------------------------------------------
63 // Setting default configuration
64 // See talk by Christophe Clement March 1, 2007
65 // -----------------------------------------------------------------
66 // Board Connected to
67 // 1 bottom LBA
68 // 2 bottom EBA
69 // 3 top LBA
70 // 4 top EBA
71 // 5 bottom LBC
72 // 6 bottom EBC
73 // 7 top LBC
74 // 8 top EBC
75 //-------------------------------------------------------------------
76 
77  m_connectedDrawers1[0] = "LBA43";
78  m_connectedDrawers1[1] = "LBA44";
79  m_connectedDrawers1[2] = "LBA45";
80  m_connectedDrawers1[3] = "LBA46";
81  m_connectedDrawers1[4] = "LBA47";
82  m_connectedDrawers1[5] = "LBA48";
83  m_connectedDrawers1[6] = "LBA49";
84  m_connectedDrawers1[7] = "LBA50";
85  m_connectedDrawers1[8] = "LBA51";
86  m_connectedDrawers1[9] = "LBA52";
87  m_connectedDrawers1[10] = "LBA53";
88  m_connectedDrawers1[11] = "LBA54";
89 
90  m_connectedDrawers2[0] = "EBA43";
91  m_connectedDrawers2[1] = "EBA44";
92  m_connectedDrawers2[2] = "EBA45";
93  m_connectedDrawers2[3] = "EBA46";
94  m_connectedDrawers2[4] = "EBA47";
95  m_connectedDrawers2[5] = "EBA48";
96  m_connectedDrawers2[6] = "EBA49";
97  m_connectedDrawers2[7] = "EBA50";
98  m_connectedDrawers2[8] = "EBA51";
99  m_connectedDrawers2[9] = "EBA52";
100  m_connectedDrawers2[10] = "EBA53";
101  m_connectedDrawers2[11] = "EBA54";
102 
103  m_connectedDrawers3[0] = "LBA11";
104  m_connectedDrawers3[1] = "LBA12";
105  m_connectedDrawers3[2] = "LBA13";
106  m_connectedDrawers3[3] = "LBA14";
107  m_connectedDrawers3[4] = "LBA15";
108  m_connectedDrawers3[5] = "LBA16";
109  m_connectedDrawers3[6] = "LBA17";
110  m_connectedDrawers3[7] = "LBA18";
111  m_connectedDrawers3[8] = "LBA19";
112  m_connectedDrawers3[9] = "LBA20";
113  m_connectedDrawers3[10] = "LBA21";
114  m_connectedDrawers3[11] = "LBA22";
115 
116  m_connectedDrawers4[0] = "EBA11";
117  m_connectedDrawers4[1] = "EBA12";
118  m_connectedDrawers4[2] = "EBA13";
119  m_connectedDrawers4[3] = "EBA14";
120  m_connectedDrawers4[4] = "EBA15";
121  m_connectedDrawers4[5] = "EBA16";
122  m_connectedDrawers4[6] = "EBA17";
123  m_connectedDrawers4[7] = "EBA18";
124  m_connectedDrawers4[8] = "EBA19";
125  m_connectedDrawers4[9] = "EBA20";
126  m_connectedDrawers4[10] = "EBA21";
127  m_connectedDrawers4[11] = "EBA22";
128 
129  m_connectedDrawers5[0] = "LBC43";
130  m_connectedDrawers5[1] = "LBC44";
131  m_connectedDrawers5[2] = "LBC45";
132  m_connectedDrawers5[3] = "LBC46";
133  m_connectedDrawers5[4] = "LBC47";
134  m_connectedDrawers5[5] = "LBC48";
135  m_connectedDrawers5[6] = "LBC49";
136  m_connectedDrawers5[7] = "LBC50";
137  m_connectedDrawers5[8] = "LBC51";
138  m_connectedDrawers5[9] = "LBC52";
139  m_connectedDrawers5[10] = "LBC53";
140  m_connectedDrawers5[11] = "LBC54";
141 
142  m_connectedDrawers6[0] = "EBC43";
143  m_connectedDrawers6[1] = "EBC44";
144  m_connectedDrawers6[2] = "EBC45";
145  m_connectedDrawers6[3] = "EBC46";
146  m_connectedDrawers6[4] = "EBC47";
147  m_connectedDrawers6[5] = "EBC48";
148  m_connectedDrawers6[6] = "EBC49";
149  m_connectedDrawers6[7] = "EBC50";
150  m_connectedDrawers6[8] = "EBC51";
151  m_connectedDrawers6[9] = "EBC52";
152  m_connectedDrawers6[10] = "EBC53";
153  m_connectedDrawers6[11] = "EBC54";
154 
155  m_connectedDrawers7[0] = "LBC11";
156  m_connectedDrawers7[1] = "LBC12";
157  m_connectedDrawers7[2] = "LBC13";
158  m_connectedDrawers7[3] = "LBC14";
159  m_connectedDrawers7[4] = "LBC15";
160  m_connectedDrawers7[5] = "LBC16";
161  m_connectedDrawers7[6] = "LBC17";
162  m_connectedDrawers7[7] = "LBC18";
163  m_connectedDrawers7[8] = "LBC19";
164  m_connectedDrawers7[9] = "LBC20";
165  m_connectedDrawers7[10] = "LBC21";
166  m_connectedDrawers7[11] = "LBC22";
167 
168  m_connectedDrawers8[0] = "EBC11";
169  m_connectedDrawers8[1] = "EBC12";
170  m_connectedDrawers8[2] = "EBC13";
171  m_connectedDrawers8[3] = "EBC14";
172  m_connectedDrawers8[4] = "EBC15";
173  m_connectedDrawers8[5] = "EBC16";
174  m_connectedDrawers8[6] = "EBC17";
175  m_connectedDrawers8[7] = "EBC18";
176  m_connectedDrawers8[8] = "EBC19";
177  m_connectedDrawers8[9] = "EBC20";
178  m_connectedDrawers8[10] = "EBC21";
179  m_connectedDrawers8[11] = "EBC22";
180 
181  declareProperty("ConnectedDrawers1", m_connectedDrawers1);
182  declareProperty("ConnectedDrawers2", m_connectedDrawers2);
183  declareProperty("ConnectedDrawers3", m_connectedDrawers3);
184  declareProperty("ConnectedDrawers4", m_connectedDrawers4);
185  declareProperty("ConnectedDrawers5", m_connectedDrawers5);
186  declareProperty("ConnectedDrawers6", m_connectedDrawers6);
187  declareProperty("ConnectedDrawers7", m_connectedDrawers7);
188  declareProperty("ConnectedDrawers8", m_connectedDrawers8);
189  declareProperty("Threshold", m_TThreshold);
190 
191  // fix coverity complaints about these not being initialized in constructor
192  for (int i = 0; i < m_NMaxTowers; i++) {
193  m_connectedTowers[i] = 0;
194  m_firedTowers[i] = 0;
195  m_towerSum[i] = 0.0;
196  m_boardOfTower[i] = 0;
197  }
198 }

◆ ~TileCosmicsTrigger()

TileCosmicsTrigger::~TileCosmicsTrigger ( )
virtual

Definition at line 200 of file TileCosmicsTrigger.cxx.

200  {
201 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< 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< 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< 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< 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< 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< Algorithm > >::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< 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< 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< 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 TileCosmicsTrigger::execute ( )

Definition at line 308 of file TileCosmicsTrigger.cxx.

308  {
309 
310  // step1: read TileTTL1s from TDS
311  SG::ReadHandle<TileTTL1Container> ttl1Container;
312  ATH_CHECK( ttl1Container.isValid() );
313  ATH_MSG_DEBUG( "Loaded TileTTL1Container: " << ttl1Container.key() );
314 
315  SG::WriteHandle<TileTriggerContainer> triggerContainer (m_triggerContainerKey);
316  ATH_CHECK( triggerContainer.record(std::make_unique<TileTriggerContainer>()) );
317 
318  // step2: reset towers
319  for (int i = 0; i < m_NMaxTowers; i++) {
320  m_firedTowers[i] = 0;
321  m_towerSum[i] = 0.;
322  }
323 
324  int nbacktowers = 0;
325  int nchan = 0;
326 
327  Identifier p_maxTowerID;
328  double p_maxTowerSum = 0;
329  std::vector<Identifier> p_boardTowerID;
330  std::vector<double> p_boardTowerSum;
331  std::vector<Identifier> p_backTowerID;
332  std::vector<double> p_backTowerSum;
333  p_boardTowerID.resize(m_NBOARDS);
334  p_boardTowerSum.resize(m_NBOARDS);
335  p_backTowerID.resize(NMAXTOWERS);
336  p_backTowerSum.resize(NMAXTOWERS);
337 
338  // step3: check which towers fired the discriminator
339  TileTTL1Container::const_iterator it = ttl1Container->begin();
340  TileTTL1Container::const_iterator end = ttl1Container->end();
341 
342  for (; it != end; ++it) {
343  const TileTTL1 * cinp = (*it);
344  Identifier id = cinp->TTL1_ID();
345 
346  std::vector<float> samples = cinp->fsamples();
347  samples.resize(1);
348 
349  ATH_MSG_VERBOSE( " ichan=" << nchan
350  << " " << m_TT_ID->pos_neg_z(id)
351  << " /"<< m_TT_ID->eta(id)
352  << " /" << m_TT_ID->phi(id)
353  << " peak =" << samples[0] );
354 
355 
356  if (samples[0] > m_TThreshold) {
357  int index = m_TTHash->operator()(m_TT_ID->tower_hash(id));
358  if (m_connectedTowers[index]) {
359  m_firedTowers[index] = 1;
360  m_towerSum[index] = samples[0];
361  if (samples[0] > p_maxTowerSum) {
362  p_maxTowerSum = samples[0];
363  p_maxTowerID = id;
364  }
365  }
366  }
367 
368  nchan++;
369  if (nchan >= m_NMaxTowers) {
370  ATH_MSG_DEBUG( "Number of ttl1s exceeds maximum (" << m_NMaxTowers << "), ignore all the rest" );
371  break;
372  }
373  }
374 
375  // step4: compute tower coincidence logic
376  int phi1, phi2;
377  phi1 = phi2 = 0;
378 
379  Identifier id1;
380  Identifier id2;
381  // register maximum tower in each board
382  for (int i = 0; i < m_NMaxTowers; i++) {
383  if (m_firedTowers[i] == 0) continue;
384  id1 = m_TT_ID->tower_id(m_TTHash->identifier(i));
385  if (m_towerSum[i] > p_boardTowerSum[m_boardOfTower[i]]) {
386  id1 = m_TT_ID->tower_id(m_TTHash->identifier(i));
387  p_boardTowerID[m_boardOfTower[i]] = id1;
388  p_boardTowerSum[m_boardOfTower[i]] = m_towerSum[i];
389  }
390  }
391 
392  // loop through all tower pairs for back-to-back coincidence
393  for (int i = 0; i < m_NMaxTowers - 1; i++) {
394  if (m_firedTowers[i] == 0) continue;
395  id1 = m_TT_ID->tower_id(m_TTHash->identifier(i));
396  for (int j = i + 1; j < m_NMaxTowers; j++) {
397  // check back-to-back trigger
398  if (m_firedTowers[j] == 0) continue;
399  id2 = m_TT_ID->tower_id(m_TTHash->identifier(j));
400  phi1 = m_TT_ID->phi(id1);
401  phi2 = m_TT_ID->phi(id2);
402  if ((std::max(phi1, phi2) - std::min(phi1, phi2)) != 32) continue;
403  if (m_TT_ID->pos_neg_z(id1) == m_TT_ID->pos_neg_z(id2)) continue;
404  p_backTowerID[nbacktowers] = id1;
405  p_backTowerSum[nbacktowers] = m_towerSum[i];
406  nbacktowers++;
407  p_backTowerID[nbacktowers] = id2;
408  p_backTowerSum[nbacktowers] = m_towerSum[j];
409  nbacktowers++;
410  }
411  }
412 
413  p_backTowerID.resize(nbacktowers);
414  p_backTowerSum.resize(nbacktowers);
415 
416  triggerContainer->push_back(std::make_unique<TileTrigger>(p_maxTowerID, p_maxTowerSum,
417  p_boardTowerID, p_boardTowerSum,
418  p_backTowerID, p_backTowerSum));
419 
420  ATH_MSG_DEBUG( "TileTriggerContainer registered successfully (" << triggerContainer.key() << ")" );
421  // Execution completed.
422  ATH_MSG_DEBUG( "execute() completed successfully" );
423 
424  return StatusCode::SUCCESS;
425 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode TileCosmicsTrigger::finalize ( )

Definition at line 431 of file TileCosmicsTrigger.cxx.

431  {
432 
433  ATH_MSG_INFO( "finalize() completed successfully" );
434 
435  return StatusCode::SUCCESS;
436 }

◆ initialize()

StatusCode TileCosmicsTrigger::initialize ( )

Definition at line 207 of file TileCosmicsTrigger.cxx.

207  {
208 
209 
210 // retrieve TileID helper from det store
211 
212  CHECK( detStore()->retrieve(m_TT_ID) );
213 
214 
215 // convert string input into vector
216 
217  m_TTHash = new TileTTL1Hash();
218  m_TTHash->initialize(m_TT_ID);
219  for (int i = 0; i < m_NMaxTowers; i++)
220  m_connectedTowers[i] = 0;
221 
222  for (int idrawer = 0; idrawer < m_NDRAWERSPERBOARD; idrawer++) {
223  m_connectedDrawers[0][idrawer] = m_connectedDrawers1[idrawer];
224  m_connectedDrawers[1][idrawer] = m_connectedDrawers2[idrawer];
225  m_connectedDrawers[2][idrawer] = m_connectedDrawers3[idrawer];
226  m_connectedDrawers[3][idrawer] = m_connectedDrawers4[idrawer];
227  m_connectedDrawers[4][idrawer] = m_connectedDrawers5[idrawer];
228  m_connectedDrawers[5][idrawer] = m_connectedDrawers6[idrawer];
229  m_connectedDrawers[6][idrawer] = m_connectedDrawers7[idrawer];
230  m_connectedDrawers[7][idrawer] = m_connectedDrawers8[idrawer];
231  }
232  for (int iboard = 0; iboard < m_NBOARDS; iboard++) {
233  for (int idrawer = 0; idrawer < m_NDRAWERSPERBOARD; idrawer++) {
234  if (m_connectedDrawers[iboard][idrawer] == "") continue;
235  bool failure = 0;
236  int section = 0;
237  int side = 0;
238  // get section (long or extended barrel)
239  if (m_connectedDrawers[iboard][idrawer][0] == 'L'
240  || m_connectedDrawers[iboard][idrawer][0] == 'l') {
241  section = 1;
242  } else if (m_connectedDrawers[iboard][idrawer][0] == 'E'
243  || m_connectedDrawers[iboard][idrawer][0] == 'e') {
244  section = 2;
245  } else {
246  failure = 1;
247  }
248  // get side (positive or negative)
249  if (m_connectedDrawers[iboard][idrawer][2] == 'A'
250  || m_connectedDrawers[iboard][idrawer][2] == 'a') {
251  side = 1;
252  } else if (m_connectedDrawers[iboard][idrawer][2] == 'C'
253  || m_connectedDrawers[iboard][idrawer][2] == 'c') {
254  side = -1;
255  } else {
256  failure = 1;
257  }
258  int phi = -1 + atoi(m_connectedDrawers[iboard][idrawer].substr(3, m_connectedDrawers[iboard][idrawer].length() - 3).c_str());
259 
260  if (phi < 0 || phi > 63) failure = 1;
261 
262  if (failure) {
263  ATH_MSG_ERROR( "Invalid Tile Drawer " << m_connectedDrawers[iboard][idrawer] );
264  return StatusCode::FAILURE;
265  }
266  int mineta, maxeta;
267  if (section == 1) {
268  mineta = 0;
269  maxeta = 7;
270  } else {
271  mineta = 9;
272  maxeta = 14;
273  }
274  ATH_MSG_DEBUG( "Board " << iboard
275  << " Drawer " << idrawer
276  << " " << m_connectedDrawers[iboard][idrawer]
277  << " Section " << section
278  << " Side " << side
279  << " Phi " << phi );
280 
281  for (int ieta = mineta; ieta <= maxeta; ieta++) {
282  Identifier ttid = m_TT_ID->tower_id(side, 1, 0, ieta, phi);
283  int index = m_TTHash->operator()(m_TT_ID->tower_hash(ttid));
284  m_connectedTowers[index] = 1;
285  m_boardOfTower[index] = iboard;
286  }
287  }
288  }
289 
290  int nt = 0;
291  for (int i = 0; i < m_NMaxTowers; i++) {
292  ATH_MSG_DEBUG( "tower " << i << " connected " << m_connectedTowers[i] );
293  if (m_connectedTowers[i] == 1) nt++;
294  }
295 
296  ATH_CHECK( m_ttl1ContainerKey.initialize() );
297  ATH_CHECK( m_triggerContainerKey.initialize() );
298 
299  ATH_MSG_INFO( "Initialization completed, number of towers " << nt );
300 
301  return StatusCode::SUCCESS;
302 }

◆ inputHandles()

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< 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< 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< 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.

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

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< 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< 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_boardOfTower

int TileCosmicsTrigger::m_boardOfTower[NMAXTOWERS]
private

Definition at line 95 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers[8]
private

Definition at line 74 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers1

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers1
private

Definition at line 75 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers2

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers2
private

Definition at line 76 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers3

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers3
private

Definition at line 77 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers4

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers4
private

Definition at line 78 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers5

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers5
private

Definition at line 79 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers6

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers6
private

Definition at line 80 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers7

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers7
private

Definition at line 81 of file TileCosmicsTrigger.h.

◆ m_connectedDrawers8

std::vector<std::string> TileCosmicsTrigger::m_connectedDrawers8
private

Definition at line 82 of file TileCosmicsTrigger.h.

◆ m_connectedTowers

bool TileCosmicsTrigger::m_connectedTowers[NMAXTOWERS]
private

Definition at line 92 of file TileCosmicsTrigger.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_firedTowers

bool TileCosmicsTrigger::m_firedTowers[NMAXTOWERS]
private

Definition at line 93 of file TileCosmicsTrigger.h.

◆ m_NBOARDS

int TileCosmicsTrigger::m_NBOARDS
private

Definition at line 88 of file TileCosmicsTrigger.h.

◆ m_NDRAWERSPERBOARD

int TileCosmicsTrigger::m_NDRAWERSPERBOARD
private

Definition at line 89 of file TileCosmicsTrigger.h.

◆ m_NMaxTowers

const int TileCosmicsTrigger::m_NMaxTowers = NMAXTOWERS
staticprivate

Definition at line 87 of file TileCosmicsTrigger.h.

◆ m_towerSum

float TileCosmicsTrigger::m_towerSum[NMAXTOWERS]
private

Definition at line 94 of file TileCosmicsTrigger.h.

◆ m_triggerContainerKey

SG::WriteHandleKey<TileTriggerContainer> TileCosmicsTrigger::m_triggerContainerKey {this, "TileTriggerContainer","TileTriggerCnt", "Output TileTriggerContainer name"}
private

Definition at line 104 of file TileCosmicsTrigger.h.

◆ m_TT_ID

const CaloLVL1_ID* TileCosmicsTrigger::m_TT_ID
private

Definition at line 100 of file TileCosmicsTrigger.h.

◆ m_TTHash

TileTTL1Hash* TileCosmicsTrigger::m_TTHash
private

Definition at line 101 of file TileCosmicsTrigger.h.

◆ m_TThreshold

float TileCosmicsTrigger::m_TThreshold
private

Definition at line 83 of file TileCosmicsTrigger.h.

◆ m_ttl1ContainerKey

SG::ReadHandleKey<TileTTL1Container> TileCosmicsTrigger::m_ttl1ContainerKey {this, "TileTTL1Container", "TileTTL1Cnt", "Input TileTTL1Container name"}
private

Definition at line 103 of file TileCosmicsTrigger.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileCosmicsTrigger::m_boardOfTower
int m_boardOfTower[NMAXTOWERS]
Definition: TileCosmicsTrigger.h:95
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileTTL1::TTL1_ID
const Identifier & TTL1_ID() const
Definition: TileTTL1.cxx:66
TileCosmicsTrigger::m_towerSum
float m_towerSum[NMAXTOWERS]
Definition: TileCosmicsTrigger.h:94
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
TileTTL1::fsamples
const std::vector< float > & fsamples() const
Definition: TileTTL1.cxx:77
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
skel.it
it
Definition: skel.GENtoEVGEN.py:396
TileTTL1Hash::identifier
ID identifier(int i) const
reverse conversion
Definition: TileTTL1Hash.cxx:64
TileTTL1
Definition: TileTTL1.h:26
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TileCosmicsTrigger::m_connectedDrawers6
std::vector< std::string > m_connectedDrawers6
Definition: TileCosmicsTrigger.h:80
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
TileCosmicsTrigger::m_NBOARDS
int m_NBOARDS
Definition: TileCosmicsTrigger.h:88
TileCosmicsTrigger::m_NMaxTowers
static const int m_NMaxTowers
Definition: TileCosmicsTrigger.h:87
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileCosmicsTrigger::m_connectedDrawers
std::vector< std::string > m_connectedDrawers[8]
Definition: TileCosmicsTrigger.h:74
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
CaloLVL1_ID::phi
int phi(const Identifier id) const
return phi according to :
Definition: CaloLVL1_ID.h:659
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileTTL1Hash::initialize
void initialize(const CaloLVL1_ID *caloLVL1_ID)
Definition: TileTTL1Hash.cxx:37
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:562
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
TileCosmicsTrigger::m_connectedDrawers1
std::vector< std::string > m_connectedDrawers1
Definition: TileCosmicsTrigger.h:75
TileCosmicsTrigger::m_connectedDrawers2
std::vector< std::string > m_connectedDrawers2
Definition: TileCosmicsTrigger.h:76
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileCosmicsTrigger::m_triggerContainerKey
SG::WriteHandleKey< TileTriggerContainer > m_triggerContainerKey
Definition: TileCosmicsTrigger.h:104
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileCosmicsTrigger::m_connectedDrawers7
std::vector< std::string > m_connectedDrawers7
Definition: TileCosmicsTrigger.h:81
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
TileCosmicsTrigger::m_connectedTowers
bool m_connectedTowers[NMAXTOWERS]
Definition: TileCosmicsTrigger.h:92
TileCosmicsTrigger::m_firedTowers
bool m_firedTowers[NMAXTOWERS]
Definition: TileCosmicsTrigger.h:93
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloLVL1_ID::eta
int eta(const Identifier id) const
return eta according to :
Definition: CaloLVL1_ID.h:653
TileCosmicsTrigger::m_TT_ID
const CaloLVL1_ID * m_TT_ID
Definition: TileCosmicsTrigger.h:100
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
CaloLVL1_ID::pos_neg_z
int pos_neg_z(const Identifier id) const
return pos_neg_z according to :
Definition: CaloLVL1_ID.h:635
TileCosmicsTrigger::m_connectedDrawers8
std::vector< std::string > m_connectedDrawers8
Definition: TileCosmicsTrigger.h:82
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
DeMoScan.index
string index
Definition: DeMoScan.py:364
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TileCosmicsTrigger::m_connectedDrawers4
std::vector< std::string > m_connectedDrawers4
Definition: TileCosmicsTrigger.h:78
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileTTL1Hash
Hash table for TileTTL1 identifiers
Definition: TileTTL1Hash.h:38
TileCosmicsTrigger::m_TThreshold
float m_TThreshold
Definition: TileCosmicsTrigger.h:83
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
CaloLVL1_ID::tower_hash
IdentifierHash tower_hash(Identifier towerId) const
create hash id from tower id
Definition: CaloLVL1_ID.h:728
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1063
TileCosmicsTrigger::m_connectedDrawers3
std::vector< std::string > m_connectedDrawers3
Definition: TileCosmicsTrigger.h:77
section
void section(const std::string &sec)
Definition: TestTriggerMenuAccess.cxx:22
TileCosmicsTrigger::m_ttl1ContainerKey
SG::ReadHandleKey< TileTTL1Container > m_ttl1ContainerKey
Definition: TileCosmicsTrigger.h:103
CaloLVL1_ID::tower_id
Identifier tower_id(int pos_neg_z, int sampling, int region, int eta, int phi) const
build a tower identifier
Definition: CaloLVL1_ID.h:429
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
NMAXTOWERS
#define NMAXTOWERS
Definition: TileCosmicsTrigger.h:43
TileCosmicsTrigger::m_TTHash
TileTTL1Hash * m_TTHash
Definition: TileCosmicsTrigger.h:101
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
TileCosmicsTrigger::m_NDRAWERSPERBOARD
int m_NDRAWERSPERBOARD
Definition: TileCosmicsTrigger.h:89
TileCosmicsTrigger::m_connectedDrawers5
std::vector< std::string > m_connectedDrawers5
Definition: TileCosmicsTrigger.h:79
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:47:48 for ATLAS Offline Software by   doxygen 1.8.18