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

#include <MUCTPI_AthTool.h>

Inheritance diagram for LVL1MUCTPIPHASE1::MUCTPI_AthTool:
Collaboration diagram for LVL1MUCTPIPHASE1::MUCTPI_AthTool:

Public Member Functions

 MUCTPI_AthTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~MUCTPI_AthTool () override=default
 
virtual StatusCode initialize () override
 
virtual StatusCode start () override
 
StatusCode execute () 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 sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode executeFromDigi () const
 Event loop method for running as part of digitization. More...
 
StatusCode executeFromAOD () const
 Event loop method for running on an AOD file. More...
 
StatusCode executeFromRDO () const
 Event loop method for running on an RDO file. More...
 
StatusCode saveOutput (std::optional< std::reference_wrapper< MUCTPIResults >> results, int bcidOffset=0) const
 Save the outputs of the simulation into StoreGate. More...
 
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

SG::ReadHandleKey< LVL1MUONIF::Lvl1MuCTPIInputPhase1 > m_muctpiPhase1KeyRPC {this, "MuctpiPhase1LocationRPC", "L1MuctpiStoreRPC", "Location of muctpiPhase1 for Rpc"}
 
SG::ReadHandleKey< LVL1MUONIF::Lvl1MuCTPIInputPhase1 > m_muctpiPhase1KeyTGC {this, "MuctpiPhase1LocationTGC", "L1MuctpiStoreTGC", "Location of muctpiPhase1 for Tgc"}
 
SG::WriteHandleKey< LVL1::MuCTPICTP > m_MuCTPICTPWriteKey {this, "MuCTPICTPLocation", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Location of MuCTPICTP"}
 
SG::WriteHandleKeyArray< xAOD::MuonRoIContainer > m_MuCTPI_xAODWriteKeys
 
SG::WriteHandleKeyArray< LVL1::MuCTPIL1Topo > m_MuCTPIL1TopoKeys
 
Gaudi::Property< std::string > m_overlapStrategyName { this, "OverlapStrategyName", "LUT", "Overlap strategy for the MUCTPI. Options: \"LUT\" or \"NULL\" " }
 
Gaudi::Property< std::string > m_lutXMLFile { this, "LUTXMLFile", "TrigConfMuctpi/overlapRun3_20201214.xml", "xml file with the overlap handling for the MUCTPI. Default file for Run3: \"TrigConfMuctpi/overlapRun3_20201214.xml\" " }
 
Gaudi::Property< std::string > m_barrelRoIFile { this, "BarrelRoIFile", m_DEFAULT_barrelRoIFile, "" }
 
Gaudi::Property< std::string > m_ecfRoIFile { this, "EndcapForwardRoIFile", m_DEFAULT_ecfRoIFile, "" }
 
Gaudi::Property< std::string > m_side0LUTFile { this, "Side0LUTFile", m_DEFAULT_side0LUTFile, "" }
 
Gaudi::Property< std::string > m_side1LUTFile { this, "Side1LUTFile", m_DEFAULT_side1LUTFile, "" }
 
Gaudi::Property< std::string > m_inputSource { this, "InputSource", "DIGITIZATION", "" }
 
Gaudi::Property< std::string > m_aodLocId { this, "AODLocID", m_DEFAULT_AODLocID, "" }
 
Gaudi::Property< std::string > m_rdoLocId { this, "RDOLocID", m_DEFAULT_RDOLocID, "" }
 
Gaudi::Property< std::string > m_rdoOutputLocId { this, "RDOOutputLocID", m_DEFAULT_RDOLocID, "" }
 
Gaudi::Property< std::string > m_roiOutputLocId { this, "RoIOutputLocID", m_DEFAULT_locationMuCTPItoRoIB, "" }
 
Gaudi::Property< std::string > m_ctpOutputLocId { this, "CTPOutputLocID", m_DEFAULT_locationMuCTPItoCTP, "" }
 
Gaudi::Property< std::string > m_tgcLocId { this, "TGCLocID", m_DEFAULT_L1MuctpiStoreLocationTGC, "" }
 
Gaudi::Property< std::string > m_rpcLocId { this, "RPCLocID", m_DEFAULT_L1MuctpiStoreLocationRPC, "" }
 
ServiceHandle< StoreGateSvc > m_detStore { this, "DetectorStore", "StoreGateSvc/DetectorStore", "Detector store to get the menu" }
 
SimController m_theMuctpi
 
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}
 
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}
 
ToolHandle< LVL1::TrigThresholdDecisionTool > m_trigThresholdDecisionTool {this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool", "Tool to get pass/fail of each trigger threshold"}
 
StatusCode(LVL1MUCTPIPHASE1::MUCTPI_AthTool::* m_executeFunction )(void) const
 Function pointer to the execute function we want to use: More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static constexpr std::array< int, 4 > m_bcidOffsetList {-2,-1,1,2}
 
static const std::string m_DEFAULT_locationMuCTPItoCTP = "/Run/L1MuCTPItoCTPLocation"
 
static const std::string m_DEFAULT_locationMuCTPItoRoIB = "/Run/L1MuCTPItoRoIBLocation"
 
static const std::string m_DEFAULT_L1MuctpiStoreLocationRPC = "/Event/L1MuctpiStoreRPC"
 
static const std::string m_DEFAULT_L1MuctpiStoreLocationTGC = "/Event/L1MuctpiStoreTGC"
 
static const std::string m_DEFAULT_AODLocID = "LVL1_ROI"
 
static const std::string m_DEFAULT_RDOLocID = "MUCTPI_RDO"
 
static const std::string m_DEFAULT_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"
 
static const std::string m_DEFAULT_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"
 
static const std::string m_DEFAULT_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"
 
static const std::string m_DEFAULT_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"
 

Detailed Description

Definition at line 39 of file MUCTPI_AthTool.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

◆ MUCTPI_AthTool()

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

Definition at line 52 of file MUCTPI_AthTool.cxx.

53  : AthAlgTool(type, name, parent)
54  {
55 
56  // Init message
57  ATH_MSG_INFO( "=======================================" );
58  ATH_MSG_INFO( "Constructor for Phase1 MUCTPI_AthTool." );
59  ATH_MSG_INFO( "=======================================" );
60 
61  }

◆ ~MUCTPI_AthTool()

virtual LVL1MUCTPIPHASE1::MUCTPI_AthTool::~MUCTPI_AthTool ( )
overridevirtualdefault

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

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

◆ execute()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::execute ( ) const

Definition at line 195 of file MUCTPI_AthTool.cxx.

195  {
196 
197  // Now this is a tricky part. We have to force the message logging of the
198  // MuCTPI simulation to display messages of the same level as this MsgStream.
199  ATH_MSG_DEBUG( "===============================" );
200  ATH_MSG_DEBUG( "Executing MUCTPI_AthTool" );
201  ATH_MSG_DEBUG( "===============================" );
202 
203  // Now this is a tricky one. I only had to make the decision of which function to call
204  // at execute once in initialize(). Now I can call the right function like this:
205  return ( this->*m_executeFunction )();
206  }

◆ executeFromAOD()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromAOD ( ) const
private

Event loop method for running on an AOD file.

Definition at line 303 of file MUCTPI_AthTool.cxx.

303  {
304 
305  //this functionality still needs converted to the new data format.
306  //in particular, Converter.cxx doesn't exist anymore.
307 
308  // Retrieve the LVL1_ROI object from the AOD:
309  // const LVL1_ROI* lvl1RoI = 0;
310  // CHECK( evtStore()->retrieve( lvl1RoI, m_aodLocId ) );
311  // ATH_MSG_DEBUG( "Retrieved LVL1_ROI object from StoreGate" );
312 
313  // // Extract the RoIs into a vector:
314  // std::vector< unsigned int > convertableRoIs;
315  // LVL1_ROI::muons_type::const_iterator muonRoI_itr = lvl1RoI->getMuonROIs().begin();
316  // LVL1_ROI::muons_type::const_iterator muonRoI_end = lvl1RoI->getMuonROIs().end();
317  // for( ; muonRoI_itr != muonRoI_end; ++muonRoI_itr ) {
318  // convertableRoIs.push_back( muonRoI_itr->getROIWord() );
319  // }
320 
321  // // Create the input to the MuCTPI:
322  // LVL1MUONIF::Lvl1MuCTPIInputPhase1 convertedInput;
323  // CHECK( Converter::convertRoIs( convertableRoIs, &convertedInput ) );
324 
325  // // process the input with the MuCTPI simulation
326  // m_theMuctpi.processData( &convertedInput );
327 
328  // store CTP result in interface object and put to StoreGate
329  //TEMPORARILY REMOVED UNTIL MUCTPICTP UPDATED TO VECTOR!
330  //LVL1::MuCTPICTP* theCTPResult = new LVL1::MuCTPICTP( m_theMuctpi.getCTPData() );
331  //CHECK( evtStore()->record( theCTPResult, m_ctpOutputLocId ) );
332  // ATH_MSG_DEBUG( "CTP word recorded to StoreGate with key: "
333  // << m_ctpOutputLocId );
334 
335  // // Save the output of the simulation
336  // CHECK( saveOutput() );
337 
338  return StatusCode::SUCCESS;
339  }

◆ executeFromDigi()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromDigi ( ) const
private

Event loop method for running as part of digitization.

This is the default execute() function.

It reads inputs from the RPC and TGC sector logics, and runs the MuCTPI simulation with their inputs.

Need to check here if there are several BC slices in the input object, and run the simulation for each one

Definition at line 212 of file MUCTPI_AthTool.cxx.

212  {
213 
214  ATH_MSG_DEBUG( "in executeFromDigi()" );
215 
216  //
217  // Get the RPC MUCTPI-input object from StoreGate.
218  //
219  bool gotRPCInput( false );
220  SG::ReadHandle<LVL1MUONIF::Lvl1MuCTPIInputPhase1> rh_muctpiRpc(m_muctpiPhase1KeyRPC);
221  const LVL1MUONIF::Lvl1MuCTPIInputPhase1* dHandleRPC = rh_muctpiRpc.ptr();
222  if (!dHandleRPC) {
223  ATH_MSG_WARNING( "Cannot retrieve RPC L1Muctpi object from StoreGate!" );
224  }
225  else {
226  ATH_MSG_DEBUG( "Retrieved RPC Lvl1MuCTPIInput object from StoreGate" );
227  gotRPCInput = true;
228  }
229 
230  //
231  // Get the TGC MUCTPI-input object from StoreGate.
232  //
233  bool gotTGCInput( false );
234  SG::ReadHandle<LVL1MUONIF::Lvl1MuCTPIInputPhase1> rh_muctpiTgc(m_muctpiPhase1KeyTGC);
235  const LVL1MUONIF::Lvl1MuCTPIInputPhase1* dHandleTGC = rh_muctpiTgc.ptr();
236  if (!dHandleTGC) {
237  ATH_MSG_WARNING( "Cannot retrieve TGC L1Muctpi object from StoreGate!" );
238  }
239  else {
240  ATH_MSG_DEBUG( "Retrieved TGC Lvl1MuCTPIInput object from StoreGate" );
241  gotTGCInput = true;
242  }
243 
244  // Merge the two inputs:
245  LVL1MUONIF::Lvl1MuCTPIInputPhase1 mergedInput;
246 
247  if( ! ( gotRPCInput && gotTGCInput ) ) {
248  ATH_MSG_WARNING( "No input received from the RPC or TGC sector logic simulation" );
249  return StatusCode::SUCCESS;
250  }
251 
252  mergedInput.merge( *dHandleRPC );
253  mergedInput.merge( *dHandleTGC );
254 
257 
258 
259  //always process the central slice, which defaults to bcidOffset = 0
260  // process the input in the MUCTPI simulation
261  MUCTPIResults resultsBC0;
262  std::string ret = m_theMuctpi.processData(&mergedInput, resultsBC0, 0);
263  if (ret != "")
264  {
265  REPORT_ERROR( StatusCode::FAILURE ) << "Error while processing MUCTPI data: " << ret;
266  return StatusCode::FAILURE;
267  }
268  // Save the output of the simulation
269  CHECK( saveOutput(resultsBC0) );
270 
271  // check the other 4 possible BC offset values in case the input objects tells us there are
272  // out of time candidates
273  if (mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idBarrelSystem()) ||
274  mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem()) ||
275  mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idForwardSystem()) ){
276 
277  for (const int bcidOffset : m_bcidOffsetList) {
278  if ( !mergedInput.isEmptyAll(bcidOffset) ) {
279  MUCTPIResults results;
280  // process the input in the MUCTPI simulation
281  m_theMuctpi.processData(&mergedInput, results, bcidOffset);
282  // Save the output of the simulation
283  CHECK( saveOutput(results, bcidOffset) );
284  } else {
285  // Record empty outputs
286  CHECK( saveOutput(std::nullopt, bcidOffset) );
287  }
288  }
289  } else {
290  // Record emtpy outputs
291  for (const int bcidOffset : m_bcidOffsetList) {
292  CHECK( saveOutput(std::nullopt, bcidOffset) );
293  }
294  }
295 
296  return StatusCode::SUCCESS;
297  }

◆ executeFromRDO()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromRDO ( ) const
private

Event loop method for running on an RDO file.

Definition at line 346 of file MUCTPI_AthTool.cxx.

346  {
347 
348  //this function still needs to be written.
349  //in particular, converter doesn't exist anymore.
350 
351  // ATH_MSG_DEBUG( "in executeFromRDO()" );
352 
353  // // Retrieve the MuCTPI_RDO object from the digitized file:
354  // SG::ReadHandle<MuCTPI_RDO> rh_muctpi_rdo(m_MuCTPI_RDOReadKey);
355  // const MuCTPI_RDO* old_RDO = rh_muctpi_rdo.ptr();
356  // ATH_MSG_DEBUG( "Retrieved MuCTPI_RDO object from StoreGate" );
357 
358  // // Get the BCID of the collision:
359  // const unsigned int bcid = ( ( old_RDO->candidateMultiplicity() >> 18 ) & 0x7 );
360 
361  // // Create the input to the MuCTPI:
362  // LVL1MUONIF::Lvl1MuCTPIInputPhase1 convertedInput;
363  // CHECK( Converter::convertRDO( old_RDO->dataWord(), bcid, &convertedInput ) );
364 
365  // // process the input with the MuCTPI simulation
366  // m_theMuctpi.processData( &convertedInput );
367 
368  // // Save the output of the simulation
369  // CHECK( saveOutput() );
370 
371  return StatusCode::SUCCESS;
372  }

◆ 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

◆ initialize()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::initialize ( )
overridevirtual

Definition at line 63 of file MUCTPI_AthTool.cxx.

64  {
65  ATH_MSG_INFO( "=======================================" );
66  ATH_MSG_INFO( "Initialisation for Phase1 MUCTPI_AthTool" );
67  ATH_MSG_INFO( "=======================================" );
68 
69  //
70  // Set up the input source, and running conditions:
71  //
72  if( m_inputSource == "DIGITIZATION" ) {
73 
74  ATH_MSG_INFO( "Setting input source to digitization" );
75  m_executeFunction = &MUCTPI_AthTool::executeFromDigi;
76 
77  } else if( m_inputSource == "AOD" ) {
78 
79  ATH_MSG_INFO( "Setting input source to AOD" );
80  m_executeFunction = &MUCTPI_AthTool::executeFromAOD;
81 
82  } else if( m_inputSource == "RDO" ) {
83 
84  ATH_MSG_INFO( "Setting input source to RDO" );
85  m_executeFunction = &MUCTPI_AthTool::executeFromRDO;
86 
87  } else {
88 
89  REPORT_ERROR( StatusCode::FAILURE )
90  << "Wrong input source specified: \"" << m_inputSource
91  << "\"";
92  return StatusCode::FAILURE;
93 
94  }
95 
96  //initialize MSP ROI configuration
97 
98 
99  const std::string barrelFileName = PathResolverFindCalibFile( m_barrelRoIFile );
100  const std::string ecfFileName = PathResolverFindCalibFile( m_ecfRoIFile );
101  const std::string side0LUTFileName = PathResolverFindCalibFile( m_side0LUTFile );
102  const std::string side1LUTFileName = PathResolverFindCalibFile( m_side1LUTFile );
103  ATH_MSG_INFO("Initializing L1Topo decoding with the following inputs");
104  ATH_MSG_INFO(" Barrel file: " << barrelFileName);
105  ATH_MSG_INFO(" EC/Fwd file: " << ecfFileName);
106  ATH_MSG_INFO(" Side 0 LUT: " << side0LUTFileName);
107  ATH_MSG_INFO(" Side 1 LUT: " << side1LUTFileName);
108  std::vector<std::string> topo_errors = m_theMuctpi.configureTopo(barrelFileName,
109  ecfFileName,
110  side0LUTFileName,
111  side1LUTFileName);
112  if (topo_errors.size())
113  {
114  std::stringstream err;
115  err << "Couldn't initialize L1Topo eta/phi encoding/decoding:\n";
116  for (unsigned i=0;i<topo_errors.size();i++) err << topo_errors[i] << "\n";
117  REPORT_ERROR( StatusCode::FAILURE ) << err.str();
118  return StatusCode::FAILURE;
119  }
120 
121  //
122  // Set up the overlap handling of the simulation:
123  //
124 
125  if( m_overlapStrategyName == "NULL" ) {
126 
127  ATH_MSG_DEBUG( "Setting overlap strategy: \"NULL\"" );
128 
129  } else if( m_overlapStrategyName == "LUT" ) {
130 
131  ATH_MSG_DEBUG( "Setting overlap strategy: \"LUT\"" );
132 
133  ATH_MSG_INFO( "XML LUT file defined in jobO: " << m_lutXMLFile );
134  const std::string fullFileName = PathResolverFindCalibFile( m_lutXMLFile );
135  ATH_MSG_DEBUG( "Full path to XML LUT file: " << fullFileName );
136 
137  for (MuonSectorProcessor& msp : m_theMuctpi.getMuonSectorProcessors())
138  {
139  msp.configureOverlapRemoval(fullFileName);
140  }
141 
142  } else {
143 
144  REPORT_ERROR( StatusCode::FAILURE )
145  << "Wrong overlap strategy name specified: \""
146  << m_overlapStrategyName << "\"";
147  return StatusCode::FAILURE;
148 
149  }
150 
151 
152 
153  //Initialize Read/WriteHandleKeys
154  ATH_CHECK(m_muctpiPhase1KeyRPC.initialize());
155  ATH_CHECK(m_muctpiPhase1KeyTGC.initialize());
156  ATH_CHECK(m_MuCTPICTPWriteKey.initialize());
157  ATH_CHECK(m_MuCTPI_xAODWriteKeys.initialize());
158  ATH_CHECK(m_MuCTPIL1TopoKeys.initialize());
159 
160  ATH_CHECK( m_rpcTool.retrieve() );
161  ATH_CHECK( m_tgcTool.retrieve() );
162  ATH_CHECK( m_trigThresholdDecisionTool.retrieve() );
163 
164  return StatusCode::SUCCESS;
165  }

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

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

◆ saveOutput()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::saveOutput ( std::optional< std::reference_wrapper< MUCTPIResults >>  results,
int  bcidOffset = 0 
) const
private

Save the outputs of the simulation into StoreGate.

Definition at line 377 of file MUCTPI_AthTool.cxx.

377  {
378 
379  // Record an empty MuCTPI xAOD container (filled later below)
380  auto xAODRoIsKeyIt = m_MuCTPI_xAODWriteKeys.begin();
381  std::advance(xAODRoIsKeyIt, bcidOffset+2);
382  auto xAODRoIs = SG::makeHandle(*xAODRoIsKeyIt);
383  ATH_CHECK(xAODRoIs.record(std::make_unique<xAOD::MuonRoIContainer>(),
384  std::make_unique<xAOD::MuonRoIAuxContainer>()));
385  ATH_MSG_DEBUG("Recorded MuonRoIContainer with key " << xAODRoIs.key());
386 
387  // Create a WriteHandle for L1Topo output
388  auto l1topoKeyIt = m_MuCTPIL1TopoKeys.begin();
389  std::advance(l1topoKeyIt, bcidOffset+2);
390  SG::WriteHandle<LVL1::MuCTPIL1Topo> l1topo(*l1topoKeyIt);
391 
392  // If no results for this BCID, record empty outputs and return
393  if (!results.has_value()) {
394  ATH_CHECK(l1topo.record(std::make_unique<LVL1::MuCTPIL1Topo>()));
395  ATH_MSG_DEBUG("L1Topo output recorded to StoreGate with key " << l1topo.key());
396  ATH_MSG_DEBUG("No results for BCID offset " << bcidOffset << " - recorded empty outputs");
397  return StatusCode::SUCCESS;
398  }
399 
400  // Store CTP result in interface object and put to StoreGate (only for BC=0)
401  if (bcidOffset==0) {
402  // Check that the multiplicity was filled
403  const std::vector<unsigned int>& ctpData = results->get().ctp_words;
404  if (ctpData.empty()) {
405  ATH_MSG_ERROR("TriggerProcessor didn't provide correct CTP data");
406  return StatusCode::FAILURE;
407  }
408  // Record
409  SG::WriteHandle<LVL1::MuCTPICTP> muctpi_ctp(m_MuCTPICTPWriteKey);
410  ATH_CHECK(muctpi_ctp.record(std::make_unique<LVL1::MuCTPICTP>(ctpData)));
411  ATH_MSG_DEBUG("CTP word recorded to StoreGate with key " << muctpi_ctp.key());
412  }
413 
414  // Create MuCTPI xAOD and fill the container
415  for (const DAQData& data : results->get().daq_data) {
416  xAODRoIs->push_back(std::make_unique<xAOD::MuonRoI>());
417 
418  LVL1::TrigT1MuonRecRoiData roiData;
419  switch (LVL1::MuCTPIBits::getSubsysID(data.dataWord)) {
420  case LVL1::MuCTPIBits::SubsysID::Endcap: // same for Endcap and Forward
421  case LVL1::MuCTPIBits::SubsysID::Forward: {
422  ATH_CHECK( m_tgcTool->roiData(data.dataWord, roiData) );
423  break;
424  }
425  case LVL1::MuCTPIBits::SubsysID::Barrel: {
426  ATH_CHECK( m_rpcTool->roiData(data.dataWord, roiData) );
427  break;
428  }
429  default: {
430  ATH_MSG_ERROR("Failed to determine Sector ID from RoI word 0x" << std::hex << data.dataWord << std::dec);
431  return StatusCode::FAILURE;
432  }
433  }
434  // despite the name "GetMin" we are actually getting the Max thr value here
435  std::pair<std::string, double> maxThrInfo = m_trigThresholdDecisionTool->getMinThresholdNameAndValue(data.thresholdDecisions, roiData.eta());
436  xAODRoIs->back()->initialize(data.dataWord, roiData.eta(), roiData.phi(), maxThrInfo.first, maxThrInfo.second, 0); // Note: last 0 is the extraRoI word for phase-II RoI
437  }
438 
439  // Get outputs for L1Topo and store into Storegate
440  ATH_CHECK(l1topo.record(std::make_unique<LVL1::MuCTPIL1Topo>(results->get().l1topoData.getCandidates())));
441  if (bcidOffset!=0) {l1topo->setBcidOffset(bcidOffset);}
442  ATH_MSG_DEBUG("L1Topo output recorded to StoreGate with key " << l1topo.key());
443 
444  return StatusCode::SUCCESS;
445  }

◆ start()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::start ( )
overridevirtual

Definition at line 167 of file MUCTPI_AthTool.cxx.

168  {
169  ATH_MSG_INFO( "=======================================" );
170  ATH_MSG_INFO( "Start for Phase1 MUCTPI_AthTool" );
171  ATH_MSG_INFO( "=======================================" );
172 
173  ATH_MSG_INFO( "initialize(): use L1 trigger menu from detector store" );
174  const TrigConf::L1Menu * l1menu = nullptr;
175  ATH_CHECK( m_detStore->retrieve(l1menu) );
176  m_theMuctpi.getTriggerProcessor().setTrigTool(*m_trigThresholdDecisionTool);
177  m_theMuctpi.getTriggerProcessor().setMenu(l1menu);
178  for (MuonSectorProcessor& msp : m_theMuctpi.getMuonSectorProcessors())
179  {
180  msp.setMenu(l1menu);
181  if (!msp.configurePtEncoding())
182  {
183  REPORT_ERROR( StatusCode::FAILURE )
184  << "Couldn't configure pt encoding in MuonSectorProcessor " << msp.getSide();
185  return StatusCode::FAILURE;
186  }
187  }
188 
189  return StatusCode::SUCCESS;
190  }

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

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_aodLocId { this, "AODLocID", m_DEFAULT_AODLocID, "" }
private

Definition at line 117 of file MUCTPI_AthTool.h.

◆ m_barrelRoIFile

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_barrelRoIFile { this, "BarrelRoIFile", m_DEFAULT_barrelRoIFile, "" }
private

Definition at line 110 of file MUCTPI_AthTool.h.

◆ m_bcidOffsetList

constexpr std::array<int,4> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_bcidOffsetList {-2,-1,1,2}
staticconstexprprivate

Definition at line 65 of file MUCTPI_AthTool.h.

◆ m_ctpOutputLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_ctpOutputLocId { this, "CTPOutputLocID", m_DEFAULT_locationMuCTPItoCTP, "" }
private

Definition at line 121 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_AODLocID

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_AODLocID = "LVL1_ROI"
staticprivate

Definition at line 94 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_barrelRoIFile

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"
staticprivate

Definition at line 96 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_ecfRoIFile

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"
staticprivate

Definition at line 97 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_L1MuctpiStoreLocationRPC

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_L1MuctpiStoreLocationRPC = "/Event/L1MuctpiStoreRPC"
staticprivate

Definition at line 92 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_L1MuctpiStoreLocationTGC

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_L1MuctpiStoreLocationTGC = "/Event/L1MuctpiStoreTGC"
staticprivate

Definition at line 93 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_locationMuCTPItoCTP

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_locationMuCTPItoCTP = "/Run/L1MuCTPItoCTPLocation"
staticprivate

Definition at line 90 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_locationMuCTPItoRoIB

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_locationMuCTPItoRoIB = "/Run/L1MuCTPItoRoIBLocation"
staticprivate

Definition at line 91 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_RDOLocID

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_RDOLocID = "MUCTPI_RDO"
staticprivate

Definition at line 95 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_side0LUTFile

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"
staticprivate

Definition at line 98 of file MUCTPI_AthTool.h.

◆ m_DEFAULT_side1LUTFile

const std::string LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"
staticprivate

Definition at line 99 of file MUCTPI_AthTool.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_detStore { this, "DetectorStore", "StoreGateSvc/DetectorStore", "Detector store to get the menu" }
private

Definition at line 127 of file MUCTPI_AthTool.h.

◆ m_ecfRoIFile

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_ecfRoIFile { this, "EndcapForwardRoIFile", m_DEFAULT_ecfRoIFile, "" }
private

Definition at line 111 of file MUCTPI_AthTool.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_executeFunction

StatusCode( LVL1MUCTPIPHASE1::MUCTPI_AthTool::* LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_executeFunction) (void) const
inlineprivate

Function pointer to the execute function we want to use:

Definition at line 135 of file MUCTPI_AthTool.h.

135 {};

◆ m_inputSource

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_inputSource { this, "InputSource", "DIGITIZATION", "" }
private

Definition at line 116 of file MUCTPI_AthTool.h.

◆ m_lutXMLFile

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_lutXMLFile { this, "LUTXMLFile", "TrigConfMuctpi/overlapRun3_20201214.xml", "xml file with the overlap handling for the MUCTPI. Default file for Run3: \"TrigConfMuctpi/overlapRun3_20201214.xml\" " }
private

Definition at line 107 of file MUCTPI_AthTool.h.

◆ m_MuCTPI_xAODWriteKeys

SG::WriteHandleKeyArray<xAOD::MuonRoIContainer> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPI_xAODWriteKeys
private
Initial value:
{
this, "MUCTPI_xAODLocation", {
"LVL1MuonRoIsBCm2", "LVL1MuonRoIsBCm1",
"LVL1MuonRoIs",
"LVL1MuonRoIsBCp1", "LVL1MuonRoIsBCp2"
},
"Output keys for xAOD::MuonRoIContainer, one per time slice"
}

Definition at line 71 of file MUCTPI_AthTool.h.

◆ m_MuCTPICTPWriteKey

SG::WriteHandleKey<LVL1::MuCTPICTP> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPICTPWriteKey {this, "MuCTPICTPLocation", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Location of MuCTPICTP"}
private

Definition at line 70 of file MUCTPI_AthTool.h.

◆ m_MuCTPIL1TopoKeys

SG::WriteHandleKeyArray<LVL1::MuCTPIL1Topo> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPIL1TopoKeys
private
Initial value:
{
this, "L1TopoOutputLocID", {
LVL1MUCTPI::DEFAULT_MuonL1TopoLocation+"-2", LVL1MUCTPI::DEFAULT_MuonL1TopoLocation+"-1",
LVL1MUCTPI::DEFAULT_MuonL1TopoLocation,
LVL1MUCTPI::DEFAULT_MuonL1TopoLocation+"1", LVL1MUCTPI::DEFAULT_MuonL1TopoLocation+"2"
},
"Output keys for MuCTPItoL1Topo, one per time slice"
}

Definition at line 79 of file MUCTPI_AthTool.h.

◆ m_muctpiPhase1KeyRPC

SG::ReadHandleKey<LVL1MUONIF::Lvl1MuCTPIInputPhase1> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_muctpiPhase1KeyRPC {this, "MuctpiPhase1LocationRPC", "L1MuctpiStoreRPC", "Location of muctpiPhase1 for Rpc"}
private

Definition at line 68 of file MUCTPI_AthTool.h.

◆ m_muctpiPhase1KeyTGC

SG::ReadHandleKey<LVL1MUONIF::Lvl1MuCTPIInputPhase1> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_muctpiPhase1KeyTGC {this, "MuctpiPhase1LocationTGC", "L1MuctpiStoreTGC", "Location of muctpiPhase1 for Tgc"}
private

Definition at line 69 of file MUCTPI_AthTool.h.

◆ m_overlapStrategyName

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_overlapStrategyName { this, "OverlapStrategyName", "LUT", "Overlap strategy for the MUCTPI. Options: \"LUT\" or \"NULL\" " }
private

Definition at line 106 of file MUCTPI_AthTool.h.

◆ m_rdoLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_rdoLocId { this, "RDOLocID", m_DEFAULT_RDOLocID, "" }
private

Definition at line 118 of file MUCTPI_AthTool.h.

◆ m_rdoOutputLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_rdoOutputLocId { this, "RDOOutputLocID", m_DEFAULT_RDOLocID, "" }
private

Definition at line 119 of file MUCTPI_AthTool.h.

◆ m_roiOutputLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_roiOutputLocId { this, "RoIOutputLocID", m_DEFAULT_locationMuCTPItoRoIB, "" }
private

Definition at line 120 of file MUCTPI_AthTool.h.

◆ m_rpcLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_rpcLocId { this, "RPCLocID", m_DEFAULT_L1MuctpiStoreLocationRPC, "" }
private

Definition at line 125 of file MUCTPI_AthTool.h.

◆ m_rpcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}
private

Definition at line 130 of file MUCTPI_AthTool.h.

◆ m_side0LUTFile

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_side0LUTFile { this, "Side0LUTFile", m_DEFAULT_side0LUTFile, "" }
private

Definition at line 112 of file MUCTPI_AthTool.h.

◆ m_side1LUTFile

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_side1LUTFile { this, "Side1LUTFile", m_DEFAULT_side1LUTFile, "" }
private

Definition at line 113 of file MUCTPI_AthTool.h.

◆ m_tgcLocId

Gaudi::Property<std::string> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_tgcLocId { this, "TGCLocID", m_DEFAULT_L1MuctpiStoreLocationTGC, "" }
private

Definition at line 124 of file MUCTPI_AthTool.h.

◆ m_tgcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}
private

Definition at line 131 of file MUCTPI_AthTool.h.

◆ m_theMuctpi

SimController LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_theMuctpi
private

Definition at line 129 of file MUCTPI_AthTool.h.

◆ m_trigThresholdDecisionTool

ToolHandle<LVL1::TrigThresholdDecisionTool> LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_trigThresholdDecisionTool {this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool", "Tool to get pass/fail of each trigger threshold"}
private

Definition at line 132 of file MUCTPI_AthTool.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_barrelRoIFile
Gaudi::Property< std::string > m_barrelRoIFile
Definition: MUCTPI_AthTool.h:110
LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromRDO
StatusCode executeFromRDO() const
Event loop method for running on an RDO file.
Definition: MUCTPI_AthTool.cxx:346
LVL1::TrigT1MuonRecRoiData
Definition: TrigT1MuonRecRoiData.h:10
LVL1MUONIF::Lvl1MuCTPIInputPhase1::isEmptyAll
bool isEmptyAll(int bcid=0) const
Return "true" if data of all systems for this bcid is empty.
Definition: Lvl1MuCTPIInputPhase1.cxx:174
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_side1LUTFile
Gaudi::Property< std::string > m_side1LUTFile
Definition: MUCTPI_AthTool.h:113
verify_menu_config.results
results
Definition: verify_menu_config.py:67
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idForwardSystem
static size_t idForwardSystem()
Definition: Lvl1MuCTPIInputPhase1.h:139
REPORT_ERROR
#define REPORT_ERROR(SC)
Report an error.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:355
LVL1MUONIF::Lvl1MuCTPIInputPhase1::merge
void merge(const Lvl1MuCTPIInputPhase1 &another)
Merge SectorLogic data of another object into this data of a system (Barrel, Endcap or Forward) is no...
Definition: Lvl1MuCTPIInputPhase1.cxx:114
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_executeFunction
StatusCode(LVL1MUCTPIPHASE1::MUCTPI_AthTool::* m_executeFunction)(void) const
Function pointer to the execute function we want to use:
Definition: MUCTPI_AthTool.h:135
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_ecfRoIFile
Gaudi::Property< std::string > m_ecfRoIFile
Definition: MUCTPI_AthTool.h:111
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1MUONIF::Lvl1MuCTPIInputPhase1
Class representing (part of) the input data to the MuCTPI for Phase 1.
Definition: Lvl1MuCTPIInputPhase1.h:34
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
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_side0LUTFile
Gaudi::Property< std::string > m_side0LUTFile
Definition: MUCTPI_AthTool.h:112
LVL1::TrigT1MuonRecRoiData::eta
double eta(void) const
Definition: TrigT1MuonRecRoiData.h:22
TrigConf::L1Menu
L1 menu configuration.
Definition: L1Menu.h:28
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
LVL1MUCTPIPHASE1::SimController::processData
std::string processData(LVL1MUONIF::Lvl1MuCTPIInputPhase1 *input, MUCTPIResults &results, int bcid) const
Definition: SimController.cxx:55
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_muctpiPhase1KeyTGC
SG::ReadHandleKey< LVL1MUONIF::Lvl1MuCTPIInputPhase1 > m_muctpiPhase1KeyTGC
Definition: MUCTPI_AthTool.h:69
LVL1MUCTPIPHASE1::TriggerProcessor::setMenu
void setMenu(const TrigConf::L1Menu *l1menu)
Definition: TriggerProcessor.cxx:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LVL1::MuCTPIBits::SubsysID::Endcap
@ Endcap
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:270
LVL1MUCTPIPHASE1::MUCTPI_AthTool::saveOutput
StatusCode saveOutput(std::optional< std::reference_wrapper< MUCTPIResults >> results, int bcidOffset=0) const
Save the outputs of the simulation into StoreGate.
Definition: MUCTPI_AthTool.cxx:377
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
lumiFormat.i
int i
Definition: lumiFormat.py:85
LVL1::MuCTPIBits::SubsysID::Forward
@ Forward
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_trigThresholdDecisionTool
ToolHandle< LVL1::TrigThresholdDecisionTool > m_trigThresholdDecisionTool
Definition: MUCTPI_AthTool.h:132
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_bcidOffsetList
static constexpr std::array< int, 4 > m_bcidOffsetList
Definition: MUCTPI_AthTool.h:65
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromAOD
StatusCode executeFromAOD() const
Event loop method for running on an AOD file.
Definition: MUCTPI_AthTool.cxx:303
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
LVL1MUONIF::Lvl1MuCTPIInputPhase1::hasOutOfTimeCandidates
bool hasOutOfTimeCandidates(size_t systemAddress) const
Return "true" if data of specified system is filled for bunches other than 'current' bunch
Definition: Lvl1MuCTPIInputPhase1.h:151
LVL1MUCTPIPHASE1::SimController::getTriggerProcessor
TriggerProcessor & getTriggerProcessor()
Definition: SimController.h:45
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
LVL1::TrigT1MuonRecRoiData::phi
double phi(void) const
Definition: TrigT1MuonRecRoiData.h:23
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: MUCTPI_AthTool.h:127
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_tgcTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_tgcTool
Definition: MUCTPI_AthTool.h:131
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
LVL1::MuCTPIBits::getSubsysID
constexpr SubsysID getSubsysID(uint32_t word)
Decode the subsys ID from RoI candidate word.
Definition: HelpersPhase1.h:174
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_inputSource
Gaudi::Property< std::string > m_inputSource
Definition: MUCTPI_AthTool.h:116
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_lutXMLFile
Gaudi::Property< std::string > m_lutXMLFile
Definition: MUCTPI_AthTool.h:107
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPI_xAODWriteKeys
SG::WriteHandleKeyArray< xAOD::MuonRoIContainer > m_MuCTPI_xAODWriteKeys
Definition: MUCTPI_AthTool.h:71
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_overlapStrategyName
Gaudi::Property< std::string > m_overlapStrategyName
Definition: MUCTPI_AthTool.h:106
LVL1MUCTPIPHASE1::SimController::configureTopo
std::vector< std::string > configureTopo(const std::string &barrelFileName, const std::string &ecfFileName, const std::string &side0LUTFileName, const std::string &side1LUTFileName)
Definition: SimController.cxx:22
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem
static size_t idEndcapSystem()
Definition: Lvl1MuCTPIInputPhase1.h:137
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
LVL1MUCTPIPHASE1::MUCTPI_AthTool::executeFromDigi
StatusCode executeFromDigi() const
Event loop method for running as part of digitization.
Definition: MUCTPI_AthTool.cxx:212
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
python.XMLReader.l1menu
l1menu
Definition: XMLReader.py:73
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idBarrelSystem
static size_t idBarrelSystem()
Definition: Lvl1MuCTPIInputPhase1.h:135
LVL1MUCTPIPHASE1::TriggerProcessor::setTrigTool
void setTrigTool(LVL1::TrigThresholdDecisionTool &tool)
Definition: TriggerProcessor.h:36
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_rpcTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_rpcTool
Definition: MUCTPI_AthTool.h:130
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_theMuctpi
SimController m_theMuctpi
Definition: MUCTPI_AthTool.h:129
LVL1MUCTPIPHASE1::SimController::getMuonSectorProcessors
MuonSectorProcessors & getMuonSectorProcessors()
Definition: SimController.h:46
LVL1::MuCTPIBits::SubsysID::Barrel
@ Barrel
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPIL1TopoKeys
SG::WriteHandleKeyArray< LVL1::MuCTPIL1Topo > m_MuCTPIL1TopoKeys
Definition: MUCTPI_AthTool.h:79
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_muctpiPhase1KeyRPC
SG::ReadHandleKey< LVL1MUONIF::Lvl1MuCTPIInputPhase1 > m_muctpiPhase1KeyRPC
Definition: MUCTPI_AthTool.h:68
fitman.k
k
Definition: fitman.py:528
LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_MuCTPICTPWriteKey
SG::WriteHandleKey< LVL1::MuCTPICTP > m_MuCTPICTPWriteKey
Definition: MUCTPI_AthTool.h:70
Generated on Mon Dec 23 2024 22:03:16 for ATLAS Offline Software by   doxygen 1.8.18