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

RoIBuilder simulation algorithm. More...

#include <RoIBuilder.h>

Inheritance diagram for ROIB::RoIBuilder:
Collaboration diagram for ROIB::RoIBuilder:

Public Member Functions

virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &ctx) 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 DataVector< LVL1CTP::SlinkWordSlinkWordDV
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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

Gaudi::Property< bool > m_doCalo { this, "DoCalo", true, "Use inputs from Calo system" }
 
Gaudi::Property< bool > m_doMuon { this, "DoMuon", true, "Use inputs from Muon system" }
 
SG::ReadHandleKey< LVL1CTP::CTPSLinkm_ctpSLinkLocation
 
SG::ReadHandleKey< xAOD::EventInfom_eventInfoKey { this, "EventInfoKey", "EventInfo", "Event info object "}
 
SG::ReadHandleKeyArray< SlinkWordDVm_caloEMTauLocation
 
SG::ReadHandleKeyArray< SlinkWordDVm_caloJetEnergyLocation
 
SG::ReadHandleKey< L1MUINT::MuCTPIToRoIBSLinkm_muctpiSLinkLocation
 
SG::WriteHandleKey< RoIBResultm_roibRDOLocation { this, "RoIBRDOLocation", ROIB::DEFAULT_RoIBRDOLocation, "StoreGate location of RoIB RDO" }
 
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

RoIBuilder simulation algorithm.

   The RoIBuilder algorithm concatenates the different L1 RODs from
   calo, muon and CTP and fills the L1 RDO.
Author
Thomas Schoerner-Sadenius thoma.nosp@m.s.sc.nosp@m.hoern.nosp@m.er@c.nosp@m.ern.c.nosp@m.h,
Attila Kraznahorkay Jr. Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h
Wolfgang Ehrenfeld Wolfg.nosp@m.ang..nosp@m.Ehren.nosp@m.feld.nosp@m.@desy.nosp@m..de

Definition at line 37 of file RoIBuilder.h.

Member Typedef Documentation

◆ SlinkWordDV

Definition at line 53 of file RoIBuilder.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

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 ROIB::RoIBuilder::execute ( const EventContext &  ctx) const
overridevirtual

Definition at line 72 of file RoIBuilder.cxx.

72  {
73 
74  // Exec message
75  ATH_MSG_DEBUG( "============================" );
76  ATH_MSG_DEBUG( "Execution of RoIB algorithm." );
77  ATH_MSG_DEBUG( "============================" );
78 
79  //
80  // Get the official event ID:
81  //
82 
83  auto eventInfoHandle = SG::makeHandle( m_eventInfoKey, ctx );
84  CHECK( eventInfoHandle.isValid() );
85  const xAOD::EventInfo* thisEvent = eventInfoHandle.cptr();
86  // Note we are loosing precision here as we cast from 64 to 32 bits integer
87  // but this is constraint imposed by: Trigger/TrigT1/TrigT1Result/TrigT1Result/Header.h
88  const int evtNum = static_cast<int>(thisEvent->eventNumber());
89  ATH_MSG_VERBOSE( "Event number is: " << evtNum );
90 
91 
93  // //
94  // CTP RoI //
95  // //
97 
98  // create the header
99  Header ctp_rdo_header( eformat::helper::SourceIdentifier( eformat::TDAQ_CTP,
100  0 ).code() );
101 
102  // create zero data trailer
103  Trailer ctp_rdo_trailer( 0 );
104 
105  // create data element
106  std::vector< unsigned int > ctp_rdo_data;
107 
108  bool ctp_simulation_error = false;
109  auto ctpSlinkHandle = SG::makeHandle( m_ctpSLinkLocation, ctx );
110  CHECK( ctpSlinkHandle.isValid() );
111  const LVL1CTP::CTPSLink* ctp_slink = ctpSlinkHandle.cptr();
112 
113  // test for consistency
114  if ( ctp_slink->getCTPToRoIBWords().empty() ) {
115  ctp_simulation_error = true;
116  REPORT_MESSAGE( MSG::WARNING ) << "CTP size is zero. No header, trailer, data element";
117  } else if( ctp_slink->getDataElements().size() != ctp_slink->getNumWordsPerCTPSLink() ) {
118  ctp_simulation_error = true;
119  REPORT_MESSAGE( MSG::WARNING )
120  << "Found CTP size inconsistency: "
121  << ctp_slink->getDataElements().size() << "/"
122  //<< LVL1CTP::CTPSLink::wordsPerCTPSLink
123  << ctp_slink->getNumWordsPerCTPSLink()
124  << " (found/expected)";
125 
126  // get the data elements
127  if( msgLvl( MSG::DEBUG ) ) {
128  const std::vector< unsigned int > ctp_rdo_data_inc = ctp_slink->getDataElements();
129  for( size_t i(0); i < ctp_rdo_data_inc.size(); ++i ) {
130  ATH_MSG_DEBUG( "broken CTP RoI = " << std::setw( 2 ) << i << ' '
131  << MSG::hex << std::setfill('0') << std::setw( 8 )
132  << ctp_rdo_data_inc[i]
133  << MSG::dec << std::setfill(' ') );
134  }
135  }
136  } else {
137  ATH_MSG_VERBOSE( "Retrieved CTP result from TES with key: "
138  << m_ctpSLinkLocation );
139  }
140 
141  if( ctp_simulation_error ) {
142 
143  REPORT_MESSAGE( MSG::WARNING )
144  << "Creating empty CTP RDO with error code!";
145  ctp_rdo_trailer.setSimulationError();
146 
147  } else {
148 
149  // prepare header
150  ctp_rdo_header = Header(std::vector<uint32_t>(ctp_slink->getHeader()));
151 
152  // get the data elements
153  ctp_rdo_data = ctp_slink->getDataElements();
154  if( msgLvl( MSG::DEBUG ) ) {
155  for (size_t i(0); i < ctp_rdo_data.size(); ++i) {
156  ATH_MSG_DEBUG( "CTP RoI = " << MSG::dec << std::setw( 2 ) << i
157  << " 0x" << MSG::hex << std::setfill('0') << std::setw( 8 )
158  << ctp_rdo_data[i]
159  << MSG::dec << std::setfill(' ') );
160  }
161  }
162 
163  // prepare trailer
164  ctp_rdo_trailer = Trailer(std::vector<uint32_t>(ctp_slink->getTrailer()));
165  }
166 
167  // build result
168  CTPResult ctp_rdo_result( ctp_slink->getCTPVersionNumber(), std::move(ctp_rdo_header),
169  std::move(ctp_rdo_trailer), ctp_rdo_data ); //ctp_rdo_data is not moved because it needs to be converted
170  ATH_MSG_VERBOSE( "Dump CTPResult object:\n" + ctp_rdo_result.dump() );
171 
172  //
173  // Check whether the event was accepted or not:
174  //
175  bool accept = ctp_slink->getAccept();
176  ATH_MSG_DEBUG( "L1 Accept = " << accept );
177 
179  // //
180  // egamma RoI //
181  // //
183 
184  std::vector< EMTauResult > emtau_rdo_result_vector;
185 
186 
187  for( unsigned int slink = 0; slink < numEMTauSlinks; ++slink ) {
188 
189  eformat::helper::SourceIdentifier
190  emtau_source_id( eformat::TDAQ_CALO_CLUSTER_PROC_ROI, slink );
191  Header emtau_rdo_header( emtau_source_id.code(), evtNum );
192  std::vector< EMTauRoI > emtau_rdo_data;
193 
194  bool emtau_simulation_error = false;
195  const DataVector< LVL1CTP::SlinkWord >* emtau_slink = 0;
196 
197  if( m_doCalo ) {
198  ATH_MSG_VERBOSE("Reading " << m_caloEMTauLocation[slink].key() );
199  auto handle = SG::makeHandle( m_caloEMTauLocation[slink], ctx );
200  CHECK( handle.isValid() );
201  emtau_slink = handle.cptr();
202 
203  unsigned int icnt = 0;
205  emtau_slink->begin();
207  emtau_slink->end();
208  for( ; itr != end; ++itr ) {
209  ++icnt;
210  if( ( icnt > ( wordsPerHeader + 1 ) ) &&
211  ( icnt <= ( emtau_slink->size() - wordsPerTrailer - 1 ) ) ) {
212 
213  EMTauRoI emtau_roi( ( *itr )->word() );
214  emtau_rdo_data.push_back( emtau_roi );
215  ATH_MSG_DEBUG( "EmTau RoI = " << MSG::hex << std::setw( 8 )
216  << emtau_roi.roIWord() );
217  }
218  }
219 
220  } else {
221  emtau_simulation_error = true;
222  ATH_MSG_VERBOSE( "Retrieved EMTau Slink from TES with key: " << m_caloEMTauLocation[slink] );
223  }
224 
225 
226 
227  Trailer emtau_rdo_trailer( 0, 0 );
228  if( ! emtau_simulation_error ) {
229  emtau_rdo_trailer.setNumDataWords( emtau_rdo_data.size() );
230  } else {
231  emtau_rdo_trailer.setSimulationError();
232  }
233 
234  EMTauResult emtau_rdo_result( std::move(emtau_rdo_header), std::move(emtau_rdo_trailer),
235  std::move(emtau_rdo_data) );
236 
237  emtau_rdo_result_vector.push_back( std::move(emtau_rdo_result) );
238  }
239 
241  // //
242  // jet/energy RoI //
243  // //
245 
246  std::vector< JetEnergyResult > jetenergy_rdo_result_vector;
247 
248  for( unsigned int slink = 0; slink < numJetEnergySlinks; ++slink ) {
249 
250  eformat::helper::SourceIdentifier
251  jetenergy_source_id( eformat::TDAQ_CALO_JET_PROC_ROI, slink );
252  Header jetenergy_rdo_header( jetenergy_source_id.code(), evtNum );
253  std::vector< JetEnergyRoI > jetenergy_rdo_data;
254 
255  bool jetenergy_simulation_error = false;
256  const DataVector< LVL1CTP::SlinkWord >* jetenergy_slink = 0;
257 
258  if( m_doCalo ) {
259  auto handle = SG::makeHandle( m_caloJetEnergyLocation[slink], ctx );
260  CHECK( handle.isValid() );
261  jetenergy_slink = handle.cptr();
262 
263  ATH_MSG_VERBOSE( "Retrieved JetEnergy Slink from TES with key: "
264  << m_caloJetEnergyLocation[slink] );
265 
266  unsigned int icnt = 0;
268  jetenergy_slink->begin();
270  jetenergy_slink->end();
271  for( ; itr != end; ++itr ) {
272 
273  ++icnt;
274  if( ( icnt > ( wordsPerHeader + 1 ) ) &&
275  ( icnt <= ( jetenergy_slink->size() - wordsPerTrailer - 1 ) ) ) {
276 
277  JetEnergyRoI jetenergy_roi( ( *itr )->word() );
278  jetenergy_rdo_data.push_back( jetenergy_roi );
279  ATH_MSG_DEBUG( "Jet/Energy RoI = " << MSG::hex << std::setw( 8 )
280  << jetenergy_roi.roIWord() );
281  }
282  }
283  } else {
284  jetenergy_simulation_error = true;
285  }
286 
287 
288 
289  // Now wrap up the jet energy triggers:
290  Trailer jetenergy_rdo_trailer( 0, 0 );
291  if( !jetenergy_simulation_error ) {
292  jetenergy_rdo_trailer.setNumDataWords( jetenergy_rdo_data.size() );
293  } else {
294  jetenergy_rdo_trailer.setSimulationError();
295  }
296 
297  JetEnergyResult jetenergy_rdo_result( std::move(jetenergy_rdo_header),
298  std::move(jetenergy_rdo_trailer),
299  std::move(jetenergy_rdo_data) );
300 
301  jetenergy_rdo_result_vector.push_back( std::move(jetenergy_rdo_result) );
302  }
303 
305  // //
306  // muon RoI //
307  // //
309 
310  eformat::helper::SourceIdentifier
311  muon_source_id( eformat::TDAQ_MUON_CTP_INTERFACE, 0 );
312  Header muctpi_rdo_header( muon_source_id.code(), evtNum );
313  std::vector< MuCTPIRoI > muctpi_rdo_data;
314 
315  bool muctpi_simulation_error = false;
316  const L1MUINT::MuCTPIToRoIBSLink* muctpi_slink = 0;
317 
318  if( m_doMuon ) {
319  auto handle = SG::makeHandle( m_muctpiSLinkLocation, ctx );
320  CHECK( handle.isValid() );
321  muctpi_slink = handle.cptr();
322  ATH_MSG_VERBOSE( "Retrieved MuCTPI result from TES with key: "
324 
325  unsigned int icnt = 0;
326  std::vector< unsigned int >::const_iterator itr =
327  muctpi_slink->getMuCTPIToRoIBWords().begin();
328  std::vector< unsigned int >::const_iterator end =
329  muctpi_slink->getMuCTPIToRoIBWords().end();
330  for( ; itr != end; ++itr ) {
331 
332  ++icnt;
333  if( ( icnt > ( wordsPerHeader + 1 ) ) &&
334  ( icnt <= ( muctpi_slink->getMuCTPIToRoIBWords().size() -
335  wordsPerTrailer ) ) ) {
336 
337  MuCTPIRoI muctpi_roi( *itr );
338  muctpi_rdo_data.push_back( muctpi_roi );
339  ATH_MSG_DEBUG( "MuCTPI RoI = " << MSG::hex << std::setw( 8 )
340  << muctpi_roi.roIWord() );
341  }
342  }
343  } else {
344  muctpi_simulation_error = true;
345  }
346 
347 
348 
349  Trailer muctpi_rdo_trailer( 0, 0 );
350  if( ! muctpi_simulation_error ) {
351  muctpi_rdo_trailer.setNumDataWords( muctpi_rdo_data.size() );
352  } else {
353  muctpi_rdo_trailer.setSimulationError();
354  }
355 
356  MuCTPIResult muctpi_rdo_result( std::move(muctpi_rdo_header), std::move(muctpi_rdo_trailer),
357  std::move(muctpi_rdo_data) );
358 
359  //
360  // Finally create RoIB RDO object:
361  //
362  std::unique_ptr<RoIBResult> roib_rdo_result = std::make_unique< RoIBResult>(
363  std::move(muctpi_rdo_result),
364  std::move(ctp_rdo_result),
365  std::move(jetenergy_rdo_result_vector),
366  std::move(emtau_rdo_result_vector) );
367  if( msgLvl( MSG::DEBUG ) ) {
368  ATH_MSG_DEBUG( "RoIB Results:" );
369  roib_rdo_result->muCTPIResult().dumpData( msg( MSG::DEBUG ) );
370  // roib_rdo_result->eMTauResult();
371  // roib_rdo_result->jetEnergyResult();
372  ATH_MSG_DEBUG( roib_rdo_result->cTPResult().dump() );
373  }
374 
375  //
376  // Put RoIB RDO object into SG:
377  //
378  auto roibHandle = SG::makeHandle( m_roibRDOLocation, ctx );
379  CHECK( roibHandle.record( std::move( roib_rdo_result ) ) );
380  // no owerwrite possible with DataHandles
381 
382  return StatusCode::SUCCESS;
383  }

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

◆ initialize()

StatusCode ROIB::RoIBuilder::initialize ( )
overridevirtual

Definition at line 30 of file RoIBuilder.cxx.

30  {
31 
32  ATH_MSG_INFO( "========================================" );
33  ATH_MSG_INFO( "Initialisation for RoIBuilder algorithm." );
34  ATH_MSG_INFO( "========================================" );
35  // Print system info
36  if( ! m_doCalo ) {
37  ATH_MSG_WARNING( "Inputs from LVL1 Calo systems switched off" );
38  }
39  if( ! m_doMuon ) {
40  ATH_MSG_WARNING("Inputs from LVL1 Muon systems switched off" );
41  }
42 
44 
45  if ( m_doCalo ) {
46  CHECK( not m_caloEMTauLocation.empty() );
47  CHECK( not m_caloJetEnergyLocation.empty() );
48  } else {
51  }
52  CHECK( m_caloEMTauLocation.initialize() );
53  CHECK( m_caloJetEnergyLocation.initialize() );
54 
55 
56  if ( m_doMuon ) {
57  CHECK( not m_muctpiSLinkLocation.key().empty() );
58  } else {
60  }
62 
64  CHECK( m_roibRDOLocation.initialize() );
65 
66  return StatusCode::SUCCESS;
67  }

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

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

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

SG::ReadHandleKeyArray< SlinkWordDV > ROIB::RoIBuilder::m_caloEMTauLocation
private
Initial value:

Definition at line 57 of file RoIBuilder.h.

◆ m_caloJetEnergyLocation

SG::ReadHandleKeyArray< SlinkWordDV > ROIB::RoIBuilder::m_caloJetEnergyLocation
private
Initial value:
{ this, "CaloJetEnergyLocation",
"StoreGate location of JetEnergy inputs" }

Definition at line 64 of file RoIBuilder.h.

◆ m_ctpSLinkLocation

SG::ReadHandleKey<LVL1CTP::CTPSLink> ROIB::RoIBuilder::m_ctpSLinkLocation
private
Initial value:
{ this, "CTPSLinkLocation",
LVL1CTP::DEFAULT_CTPSLinkLocation, "StoreGate location of CTP RoI"}

Definition at line 50 of file RoIBuilder.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_doCalo

Gaudi::Property<bool> ROIB::RoIBuilder::m_doCalo { this, "DoCalo", true, "Use inputs from Calo system" }
private

Definition at line 46 of file RoIBuilder.h.

◆ m_doMuon

Gaudi::Property<bool> ROIB::RoIBuilder::m_doMuon { this, "DoMuon", true, "Use inputs from Muon system" }
private

Definition at line 47 of file RoIBuilder.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> ROIB::RoIBuilder::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "Event info object "}
private

Definition at line 55 of file RoIBuilder.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_muctpiSLinkLocation

SG::ReadHandleKey<L1MUINT::MuCTPIToRoIBSLink> ROIB::RoIBuilder::m_muctpiSLinkLocation
private
Initial value:
{ this, "MuCTPISLinkLocation",
LVL1MUCTPI::DEFAULT_MuonRoIBLocation,
"StoreGate location of MuCTPI inputs" }

Definition at line 69 of file RoIBuilder.h.

◆ m_roibRDOLocation

SG::WriteHandleKey<RoIBResult> ROIB::RoIBuilder::m_roibRDOLocation { this, "RoIBRDOLocation", ROIB::DEFAULT_RoIBRDOLocation, "StoreGate location of RoIB RDO" }
private

Definition at line 73 of file RoIBuilder.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.


The documentation for this class was generated from the following files:
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ROIB::RoIBuilder::m_caloJetEnergyLocation
SG::ReadHandleKeyArray< SlinkWordDV > m_caloJetEnergyLocation
Definition: RoIBuilder.h:64
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
ROIB::RoIBuilder::m_ctpSLinkLocation
SG::ReadHandleKey< LVL1CTP::CTPSLink > m_ctpSLinkLocation
Definition: RoIBuilder.h:50
ROIB::RoIBuilder::m_doMuon
Gaudi::Property< bool > m_doMuon
Definition: RoIBuilder.h:47
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray
void renounceArray(SG::VarHandleKeyArray &handlesArray)
remove all handles from I/O resolution
Definition: AthCommonDataStore.h:364
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ROIB::RoIBuilder::m_caloEMTauLocation
SG::ReadHandleKeyArray< SlinkWordDV > m_caloEMTauLocation
Definition: RoIBuilder.h:57
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
ROIB::RoIBuilder::m_roibRDOLocation
SG::WriteHandleKey< RoIBResult > m_roibRDOLocation
Definition: RoIBuilder.h:73
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
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
histSizes.code
code
Definition: histSizes.py:129
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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
LVL1::TrigT1CaloDefs::EmTauSlinkLocation
static const std::string EmTauSlinkLocation
Definition: TrigT1CaloDefs.h:82
lumiFormat.i
int i
Definition: lumiFormat.py:85
LVL1::TrigT1CaloDefs::jepSlinkLocation
static const std::string jepSlinkLocation
Definition: TrigT1CaloDefs.h:83
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
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
xAOD::CTPResult
CTPResult_v1 CTPResult
Define the latest version of the CTPResult class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/CTPResult.h:14
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
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
ROIB::RoIBuilder::m_muctpiSLinkLocation
SG::ReadHandleKey< L1MUINT::MuCTPIToRoIBSLink > m_muctpiSLinkLocation
Definition: RoIBuilder.h:69
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
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_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ROIB::RoIBuilder::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: RoIBuilder.h:55
REPORT_MESSAGE
#define REPORT_MESSAGE(LVL)
Report a message.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:365
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
ROIB::RoIBuilder::m_doCalo
Gaudi::Property< bool > m_doCalo
Definition: RoIBuilder.h:46
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
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
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
PixelByteStreamErrors::Trailer
@ Trailer
Definition: PixelByteStreamErrors.h:13
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 >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37