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

   : AthAlgTool(type, name, parent)
   {
     
     // Init message
     ATH_MSG_INFO( "=======================================" );
     ATH_MSG_INFO( "Constructor for Phase1 MUCTPI_AthTool."  );
     ATH_MSG_INFO( "=======================================" );
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

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

   {
     return PBASE::declareProperty(t);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

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

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

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

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

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

                                                   {
  
     //this functionality still needs converted to the new data format.
     //in particular, Converter.cxx doesn't exist anymore.
  
     // Retrieve the LVL1_ROI object from the AOD:
     // const LVL1_ROI* lvl1RoI = 0;
     // CHECK( evtStore()->retrieve( lvl1RoI, m_aodLocId ) );
     // ATH_MSG_DEBUG( "Retrieved LVL1_ROI object from StoreGate" );
  
     // // Extract the RoIs into a vector:
     // std::vector< unsigned int > convertableRoIs;
     // LVL1_ROI::muons_type::const_iterator muonRoI_itr = lvl1RoI->getMuonROIs().begin();
     // LVL1_ROI::muons_type::const_iterator muonRoI_end = lvl1RoI->getMuonROIs().end();
     // for( ; muonRoI_itr != muonRoI_end; ++muonRoI_itr ) {
     //   convertableRoIs.push_back( muonRoI_itr->getROIWord() );
     // }
  
     // // Create the input to the MuCTPI:
     // LVL1MUONIF::Lvl1MuCTPIInputPhase1 convertedInput;
     // CHECK( Converter::convertRoIs( convertableRoIs, &convertedInput ) );
  
     // // process the input with the MuCTPI simulation
     // m_theMuctpi.processData( &convertedInput );
  
     // store CTP result in interface object and put to StoreGate
     //TEMPORARILY REMOVED UNTIL MUCTPICTP UPDATED TO VECTOR!
     //LVL1::MuCTPICTP* theCTPResult = new LVL1::MuCTPICTP( m_theMuctpi.getCTPData() );
     //CHECK( evtStore()->record( theCTPResult, m_ctpOutputLocId ) );
     // ATH_MSG_DEBUG( "CTP word recorded to StoreGate with key: "
     //         << m_ctpOutputLocId );
  
     // // Save the output of the simulation
     // CHECK( saveOutput() );
  
     return StatusCode::SUCCESS;
   }

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

                                                    {
  
     ATH_MSG_DEBUG( "in executeFromDigi()" );
  
     //
     // Get the RPC MUCTPI-input object from StoreGate.
     //
     bool gotRPCInput( false );
     SG::ReadHandle<LVL1MUONIF::Lvl1MuCTPIInputPhase1> rh_muctpiRpc(m_muctpiPhase1KeyRPC);
     const LVL1MUONIF::Lvl1MuCTPIInputPhase1* dHandleRPC = rh_muctpiRpc.ptr();
     if (!dHandleRPC) {
       ATH_MSG_WARNING( "Cannot retrieve RPC L1Muctpi object from StoreGate!" );
     }
     else {
       ATH_MSG_DEBUG( "Retrieved RPC Lvl1MuCTPIInput object from StoreGate" );
       gotRPCInput = true;
     }
  
     //
     // Get the TGC MUCTPI-input object from StoreGate.
     //
     bool gotTGCInput( false );
     SG::ReadHandle<LVL1MUONIF::Lvl1MuCTPIInputPhase1> rh_muctpiTgc(m_muctpiPhase1KeyTGC);
     const LVL1MUONIF::Lvl1MuCTPIInputPhase1* dHandleTGC = rh_muctpiTgc.ptr();
     if (!dHandleTGC) {
       ATH_MSG_WARNING( "Cannot retrieve TGC L1Muctpi object from StoreGate!" );
     }
     else {
       ATH_MSG_DEBUG( "Retrieved TGC Lvl1MuCTPIInput object from StoreGate" );
       gotTGCInput = true;
     }
  
     // Merge the two inputs:
     LVL1MUONIF::Lvl1MuCTPIInputPhase1 mergedInput;
  
     if( ! ( gotRPCInput && gotTGCInput ) ) {
       ATH_MSG_WARNING( "No input received from the RPC or TGC sector logic simulation" );
       return StatusCode::SUCCESS;
     }
  
     mergedInput.merge( *dHandleRPC );
     mergedInput.merge( *dHandleTGC );
  
  
  
     //always process the central slice, which defaults to bcidOffset = 0
     // process the input in the MUCTPI simulation
     MUCTPIResults resultsBC0;
     std::string ret = m_theMuctpi.processData(&mergedInput, resultsBC0, 0);
     if (ret != "")
     {
       REPORT_ERROR( StatusCode::FAILURE ) << "Error while processing MUCTPI data: " << ret;
       return StatusCode::FAILURE;
     }
     // Save the output of the simulation
     CHECK( saveOutput(resultsBC0) );
       
     // check the other 4 possible BC offset values in case the input objects tells us there are
     // out of time candidates
     if (mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idBarrelSystem()) ||
         mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem()) || 
         mergedInput.hasOutOfTimeCandidates(LVL1MUONIF::Lvl1MuCTPIInputPhase1::idForwardSystem()) ){
       
       for (const int bcidOffset : m_bcidOffsetList) {
         if ( !mergedInput.isEmptyAll(bcidOffset) ) {
           MUCTPIResults results;
           // process the input in the MUCTPI simulation
           m_theMuctpi.processData(&mergedInput, results, bcidOffset);
           // Save the output of the simulation
           CHECK( saveOutput(results, bcidOffset) );
         } else {
           // Record empty outputs
           CHECK( saveOutput(std::nullopt, bcidOffset) );
         }
       }
     } else {
       // Record emtpy outputs
       for (const int bcidOffset : m_bcidOffsetList) {
         CHECK( saveOutput(std::nullopt, bcidOffset) );
       }
     }
  
     return StatusCode::SUCCESS;
   }

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

                                                   {
  
     //this function still needs to be written.
     //in particular, converter doesn't exist anymore.
  
     // ATH_MSG_DEBUG( "in executeFromRDO()" );
  
     // // Retrieve the MuCTPI_RDO object from the digitized file:
     // SG::ReadHandle<MuCTPI_RDO> rh_muctpi_rdo(m_MuCTPI_RDOReadKey);
     // const MuCTPI_RDO* old_RDO = rh_muctpi_rdo.ptr();
     // ATH_MSG_DEBUG( "Retrieved MuCTPI_RDO object from StoreGate" );
  
     // // Get the BCID of the collision:
     // const unsigned int bcid = ( ( old_RDO->candidateMultiplicity() >> 18 ) & 0x7 );
  
     // // Create the input to the MuCTPI:
     // LVL1MUONIF::Lvl1MuCTPIInputPhase1 convertedInput;
     // CHECK( Converter::convertRDO( old_RDO->dataWord(), bcid, &convertedInput ) );
  
     // // process the input with the MuCTPI simulation
     // m_theMuctpi.processData( &convertedInput );
  
     // // Save the output of the simulation
     // CHECK( saveOutput() );
  
     return StatusCode::SUCCESS;
   }

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

   {
     ATH_MSG_INFO( "=======================================" );
     ATH_MSG_INFO( "Initialisation for Phase1 MUCTPI_AthTool"  );
     ATH_MSG_INFO( "=======================================" );
  
     //
     // Set up the input source, and running conditions:
     //
     if( m_inputSource == "DIGITIZATION" ) {
  
       ATH_MSG_INFO( "Setting input source to digitization" );
       m_executeFunction = &MUCTPI_AthTool::executeFromDigi;
  
     } else if( m_inputSource == "AOD" ) {
  
       ATH_MSG_INFO( "Setting input source to AOD" );
       m_executeFunction = &MUCTPI_AthTool::executeFromAOD;
  
     } else if( m_inputSource == "RDO" ) {
  
       ATH_MSG_INFO( "Setting input source to RDO" );
       m_executeFunction = &MUCTPI_AthTool::executeFromRDO;
  
     } else {
  
       REPORT_ERROR( StatusCode::FAILURE )
     << "Wrong input source specified: \"" << m_inputSource
     << "\"";
       return StatusCode::FAILURE;
  
     }
  
     //initialize MSP ROI configuration
  
  
     const std::string barrelFileName = PathResolverFindCalibFile( m_barrelRoIFile );
     const std::string ecfFileName = PathResolverFindCalibFile( m_ecfRoIFile );
     const std::string side0LUTFileName = PathResolverFindCalibFile( m_side0LUTFile );
     const std::string side1LUTFileName = PathResolverFindCalibFile( m_side1LUTFile );
     ATH_MSG_INFO("Initializing L1Topo decoding with the following inputs");
     ATH_MSG_INFO("  Barrel file: " << barrelFileName);
     ATH_MSG_INFO("  EC/Fwd file: " << ecfFileName);
     ATH_MSG_INFO("  Side 0 LUT:  " << side0LUTFileName);
     ATH_MSG_INFO("  Side 1 LUT:  " << side1LUTFileName);
     std::vector<std::string> topo_errors = m_theMuctpi.configureTopo(barrelFileName,
                                       ecfFileName,
                                       side0LUTFileName,
                                       side1LUTFileName);
     if (topo_errors.size())
     {
       std::stringstream err;
       err << "Couldn't initialize L1Topo eta/phi encoding/decoding:\n";
       for (unsigned i=0;i<topo_errors.size();i++) err << topo_errors[i] << "\n";
       REPORT_ERROR( StatusCode::FAILURE ) << err.str();
       return StatusCode::FAILURE;
     }
  
     //                                                                                                                                                                                        
     // Set up the overlap handling of the simulation:                                                                                                                                         
     //     
     
     if( m_overlapStrategyName == "NULL" ) {
  
       ATH_MSG_DEBUG( "Setting overlap strategy: \"NULL\"" );
  
     } else if( m_overlapStrategyName == "LUT" ) {
  
       ATH_MSG_DEBUG( "Setting overlap strategy: \"LUT\"" );
  
       ATH_MSG_INFO( "XML LUT file defined in jobO: " << m_lutXMLFile );
       const std::string fullFileName = PathResolverFindCalibFile( m_lutXMLFile );
       ATH_MSG_DEBUG( "Full path to XML LUT file: " << fullFileName );
  
       for (MuonSectorProcessor& msp : m_theMuctpi.getMuonSectorProcessors())
       {
         msp.configureOverlapRemoval(fullFileName);
       }
  
     } else {
  
       REPORT_ERROR( StatusCode::FAILURE )
         << "Wrong overlap strategy name specified: \""
         << m_overlapStrategyName << "\"";
       return StatusCode::FAILURE;
  
     }
     
  
  
     //Initialize Read/WriteHandleKeys
     ATH_CHECK(m_muctpiPhase1KeyRPC.initialize());
     ATH_CHECK(m_muctpiPhase1KeyTGC.initialize());
     ATH_CHECK(m_MuCTPICTPWriteKey.initialize());
     ATH_CHECK(m_MuCTPI_xAODWriteKeys.initialize());
     ATH_CHECK(m_MuCTPIL1TopoKeys.initialize());
  
     ATH_CHECK( m_rpcTool.retrieve() );
     ATH_CHECK( m_tgcTool.retrieve() );
     ATH_CHECK( m_trigThresholdDecisionTool.retrieve() );
  
     return StatusCode::SUCCESS;
   }

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

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

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

   {
     h.renounce();
     PBASE::renounce (h);
   }

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

                                                           {
     handlesArray.renounce();
   }

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

                                                                                                                       {
  
     // Record an empty MuCTPI xAOD container (filled later below)
     auto xAODRoIsKeyIt = m_MuCTPI_xAODWriteKeys.begin();
     std::advance(xAODRoIsKeyIt, bcidOffset+2);
     auto xAODRoIs = SG::makeHandle(*xAODRoIsKeyIt);
     ATH_CHECK(xAODRoIs.record(std::make_unique<xAOD::MuonRoIContainer>(),
                               std::make_unique<xAOD::MuonRoIAuxContainer>()));
     ATH_MSG_DEBUG("Recorded MuonRoIContainer with key " << xAODRoIs.key());
  
     // Create a WriteHandle for L1Topo output
     auto l1topoKeyIt = m_MuCTPIL1TopoKeys.begin();
     std::advance(l1topoKeyIt, bcidOffset+2);
     SG::WriteHandle<LVL1::MuCTPIL1Topo> l1topo(*l1topoKeyIt);
  
     // If no results for this BCID, record empty outputs and return
     if (!results.has_value()) {
       ATH_CHECK(l1topo.record(std::make_unique<LVL1::MuCTPIL1Topo>()));
       ATH_MSG_DEBUG("L1Topo output recorded to StoreGate with key " << l1topo.key());
       ATH_MSG_DEBUG("No results for BCID offset " << bcidOffset << " - recorded empty outputs");
       return StatusCode::SUCCESS;
     }
  
     // Store CTP result in interface object and put to StoreGate (only for BC=0)
     if (bcidOffset==0) {
       // Check that the multiplicity was filled
       const std::vector<unsigned int>& ctpData = results->get().ctp_words;
       if (ctpData.empty()) {
         ATH_MSG_ERROR("TriggerProcessor didn't provide correct CTP data");
         return StatusCode::FAILURE;
       }
       // Record
       SG::WriteHandle<LVL1::MuCTPICTP> muctpi_ctp(m_MuCTPICTPWriteKey);
       ATH_CHECK(muctpi_ctp.record(std::make_unique<LVL1::MuCTPICTP>(ctpData)));
       ATH_MSG_DEBUG("CTP word recorded to StoreGate with key " << muctpi_ctp.key());
     }
  
     // Create MuCTPI xAOD and fill the container
     for (const DAQData& data : results->get().daq_data) {
       xAODRoIs->push_back(std::make_unique<xAOD::MuonRoI>());
  
       LVL1::TrigT1MuonRecRoiData roiData;
       switch (LVL1::MuCTPIBits::getSubsysID(data.dataWord)) {
         case LVL1::MuCTPIBits::SubsysID::Endcap: // same for Endcap and Forward
         case LVL1::MuCTPIBits::SubsysID::Forward: {
           ATH_CHECK( m_tgcTool->roiData(data.dataWord, roiData) );
           break;
         }
         case LVL1::MuCTPIBits::SubsysID::Barrel: {
           ATH_CHECK( m_rpcTool->roiData(data.dataWord, roiData) );
           break;
         }
         default: {
           ATH_MSG_ERROR("Failed to determine Sector ID from RoI word 0x" << std::hex << data.dataWord << std::dec);
           return StatusCode::FAILURE;
         }
       }
       // despite the name "GetMin" we are actually getting the Max thr value here 
       std::pair<std::string, double> maxThrInfo = m_trigThresholdDecisionTool->getMinThresholdNameAndValue(data.thresholdDecisions, roiData.eta());
       xAODRoIs->back()->initialize(data.dataWord, roiData.eta(), roiData.phi(), maxThrInfo.first, maxThrInfo.second);
     }
  
     // Get outputs for L1Topo and store into Storegate
     ATH_CHECK(l1topo.record(std::make_unique<LVL1::MuCTPIL1Topo>(results->get().l1topoData.getCandidates())));
     if (bcidOffset!=0) {l1topo->setBcidOffset(bcidOffset);}
     ATH_MSG_DEBUG("L1Topo output recorded to StoreGate with key " << l1topo.key());
  
     return StatusCode::SUCCESS;
   }

◆ start()

StatusCode LVL1MUCTPIPHASE1::MUCTPI_AthTool::start ( )

overridevirtual

Definition at line 167 of file MUCTPI_AthTool.cxx.

   {
     ATH_MSG_INFO( "=======================================" );
     ATH_MSG_INFO( "Start for Phase1 MUCTPI_AthTool"  );
     ATH_MSG_INFO( "=======================================" );
  
     ATH_MSG_INFO( "initialize(): use L1 trigger menu from detector store" );
     const TrigConf::L1Menu * l1menu = nullptr;
     ATH_CHECK( m_detStore->retrieve(l1menu) ); 
     m_theMuctpi.getTriggerProcessor().setTrigTool(*m_trigThresholdDecisionTool);
     m_theMuctpi.getTriggerProcessor().setMenu(l1menu);
     for (MuonSectorProcessor& msp : m_theMuctpi.getMuonSectorProcessors())
     {
       msp.setMenu(l1menu);
       if (!msp.configurePtEncoding())
       {
         REPORT_ERROR( StatusCode::FAILURE )
           << "Couldn't configure pt encoding in MuonSectorProcessor " << msp.getSide();
         return StatusCode::FAILURE;
       }
     }
  
     return StatusCode::SUCCESS;
   }

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

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

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:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MUCTPI_AthTool()

◆ ~MUCTPI_AthTool()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ executeFromAOD()

◆ executeFromDigi()

◆ executeFromRDO()

◆ extraDeps_update_handler()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ saveOutput()

◆ start()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_aodLocId

◆ m_barrelRoIFile

◆ m_bcidOffsetList

◆ m_ctpOutputLocId

◆ m_DEFAULT_AODLocID

◆ m_DEFAULT_barrelRoIFile

◆ m_DEFAULT_ecfRoIFile

◆ m_DEFAULT_L1MuctpiStoreLocationRPC

◆ m_DEFAULT_L1MuctpiStoreLocationTGC

◆ m_DEFAULT_locationMuCTPItoCTP

◆ m_DEFAULT_locationMuCTPItoRoIB

◆ m_DEFAULT_RDOLocID

◆ m_DEFAULT_side0LUTFile

◆ m_DEFAULT_side1LUTFile

◆ m_detStore

◆ m_ecfRoIFile

◆ m_evtStore

◆ m_executeFunction

◆ m_inputSource

◆ m_lutXMLFile

◆ m_MuCTPI_xAODWriteKeys

◆ m_MuCTPICTPWriteKey

◆ m_MuCTPIL1TopoKeys

◆ m_muctpiPhase1KeyRPC

◆ m_muctpiPhase1KeyTGC

◆ m_overlapStrategyName

◆ m_rdoLocId

◆ m_rdoOutputLocId

◆ m_roiOutputLocId

◆ m_rpcLocId

◆ m_rpcTool

◆ m_side0LUTFile

◆ m_side1LUTFile

◆ m_tgcLocId

◆ m_tgcTool