#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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	executeFromDigi () const
	Event loop method for running as part of digitization.
StatusCode	executeFromAOD () const
	Event loop method for running on an AOD file.
StatusCode	executeFromRDO () const
	Event loop method for running on an RDO file.
StatusCode	saveOutput (std::optional< std::reference_wrapper< MUCTPIResults > > results, int bcidOffset=0) const
	Save the outputs of the simulation into StoreGate.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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:
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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, 0);   // Note: last 0 is the extraRoI word for phase-II RoI
    }
 
    // 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

117{ this, "AODLocID", m_DEFAULT_AODLocID, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_AODLocID

static const std::string m_DEFAULT_AODLocID

Definition MUCTPI_AthTool.h:94

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

110{ this, "BarrelRoIFile", m_DEFAULT_barrelRoIFile, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_barrelRoIFile

static const std::string m_DEFAULT_barrelRoIFile

Definition MUCTPI_AthTool.h:96

◆ m_bcidOffsetList

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

staticconstexprprivate

Definition at line 65 of file MUCTPI_AthTool.h.

65{-2,-1,1,2};

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

121{ this, "CTPOutputLocID", m_DEFAULT_locationMuCTPItoCTP, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_locationMuCTPItoCTP

static const std::string m_DEFAULT_locationMuCTPItoCTP

Definition MUCTPI_AthTool.h:90

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

127{ this, "DetectorStore", "StoreGateSvc/DetectorStore", "Detector store to get the menu" };

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

111{ this, "EndcapForwardRoIFile", m_DEFAULT_ecfRoIFile, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_ecfRoIFile

static const std::string m_DEFAULT_ecfRoIFile

Definition MUCTPI_AthTool.h:97

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

116{ this, "InputSource", "DIGITIZATION", "" };

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

107{ this, "LUTXMLFile", "TrigConfMuctpi/overlapRun3_20201214.xml", "xml file with the overlap handling for the MUCTPI. Default file for Run3: \"TrigConfMuctpi/overlapRun3_20201214.xml\" " };

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

                                                                       {
      this, "MUCTPI_xAODLocation", {
        "LVL1MuonRoIsBCm2", "LVL1MuonRoIsBCm1",
        "LVL1MuonRoIs",
        "LVL1MuonRoIsBCp1", "LVL1MuonRoIsBCp2"
      },
      "Output keys for xAOD::MuonRoIContainer, one per time slice"
    };

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

70{this, "MuCTPICTPLocation", LVL1MUCTPI::DEFAULT_MuonCTPLocation, "Location of MuCTPICTP"};

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

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

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

68{this, "MuctpiPhase1LocationRPC", "L1MuctpiStoreRPC", "Location of muctpiPhase1 for Rpc"};

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

69{this, "MuctpiPhase1LocationTGC", "L1MuctpiStoreTGC", "Location of muctpiPhase1 for Tgc"};

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

106{ this, "OverlapStrategyName", "LUT", "Overlap strategy for the MUCTPI. Options: \"LUT\" or \"NULL\" " };

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

118{ this, "RDOLocID", m_DEFAULT_RDOLocID, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_RDOLocID

static const std::string m_DEFAULT_RDOLocID

Definition MUCTPI_AthTool.h:95

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

119{ this, "RDOOutputLocID", m_DEFAULT_RDOLocID, "" };

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

120{ this, "RoIOutputLocID", m_DEFAULT_locationMuCTPItoRoIB, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_locationMuCTPItoRoIB

static const std::string m_DEFAULT_locationMuCTPItoRoIB

Definition MUCTPI_AthTool.h:91

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

125{ this, "RPCLocID", m_DEFAULT_L1MuctpiStoreLocationRPC, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_L1MuctpiStoreLocationRPC

static const std::string m_DEFAULT_L1MuctpiStoreLocationRPC

Definition MUCTPI_AthTool.h:92

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

130{this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"};

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

112{ this, "Side0LUTFile", m_DEFAULT_side0LUTFile, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_side0LUTFile

static const std::string m_DEFAULT_side0LUTFile

Definition MUCTPI_AthTool.h:98

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

113{ this, "Side1LUTFile", m_DEFAULT_side1LUTFile, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_side1LUTFile

static const std::string m_DEFAULT_side1LUTFile

Definition MUCTPI_AthTool.h:99

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

124{ this, "TGCLocID", m_DEFAULT_L1MuctpiStoreLocationTGC, "" };

LVL1MUCTPIPHASE1::MUCTPI_AthTool::m_DEFAULT_L1MuctpiStoreLocationTGC

static const std::string m_DEFAULT_L1MuctpiStoreLocationTGC

Definition MUCTPI_AthTool.h:93

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

131{this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"};

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

132{this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool", "Tool to get pass/fail of each trigger threshold"};

◆ 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()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ executeFromAOD()

◆ executeFromDigi()

◆ executeFromRDO()

◆ extraDeps_update_handler()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ 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

◆ m_theMuctpi

◆ m_trigThresholdDecisionTool

◆ m_varHandleArraysDeclared

◆ m_vhka