Muon::RPC_RawDataProviderToolMT Class Reference

Tool to do decoding of RPC RAW data. More...

#include <RPC_RawDataProviderToolMT.h>

Inheritance diagram for Muon::RPC_RawDataProviderToolMT:

Collaboration diagram for Muon::RPC_RawDataProviderToolMT:

Public Member Functions
	RPC_RawDataProviderToolMT (const std::string &t, const std::string &n, const IInterface *p)
virtual	~RPC_RawDataProviderToolMT ()=default
virtual StatusCode	initialize () override
virtual StatusCode	convert (const ROBFragmentList &vecRobs) const override
	Decoding method.
virtual StatusCode	convert (const ROBFragmentList &vecRobs, const std::vector< IdentifierHash > &coll) const override
virtual StatusCode	convert () const override
	the new ones
virtual StatusCode	convert (const std::vector< IdentifierHash > &) const override
	for a selection of rdo collections
virtual StatusCode	convert (const std::vector< uint32_t > &) const override
virtual StatusCode	convert (const ROBFragmentList &, const EventContext &) const override
	EventContext ones.
virtual StatusCode	convert (const ROBFragmentList &, const std::vector< IdentifierHash > &, const EventContext &) const override
virtual StatusCode	convert (const EventContext &) const override
virtual StatusCode	convert (const std::vector< IdentifierHash > &, const EventContext &) const override
virtual StatusCode	convert (const std::vector< uint32_t > &, const EventContext &) const override

Private Attributes
SG::UpdateHandleKey< RpcPad_Cache >	m_rdoContainerCacheKey
	RPC container cache key.
Gaudi::Property< bool >	m_WriteOutRpcSectorLogic {this, "WriteOutRpcSectorLogic", true, "Turn on/off RpcSectorLogic writing"}
	Turn on/off RpcSectorConfig writing.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Detailed Description

Tool to do decoding of RPC RAW data.

This tool should be safe to use with athenaMT. It will not work with the legacy run-2 trigger code, since the tool creates a new container each time.

The main work of decoding is done in the RPC_RawDataProviderToolCore class.

Definition at line 25 of file RPC_RawDataProviderToolMT.h.

Constructor & Destructor Documentation

RPC_RawDataProviderToolMT()

Muon::RPC_RawDataProviderToolMT::RPC_RawDataProviderToolMT	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 13 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                                    :
    base_class(t, n, p) {    
}

~RPC_RawDataProviderToolMT()

virtual Muon::RPC_RawDataProviderToolMT::~RPC_RawDataProviderToolMT ( )

virtualdefault

Member Function Documentation

convert() [1/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( ) const

overridevirtual

the new ones

for the entire event

Definition at line 38 of file RPC_RawDataProviderToolMT.cxx.

{ return this->convert(Gaudi::Hive::currentContext()); }

convert() [2/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const EventContext & ctx ) const

overridevirtual

Definition at line 40 of file RPC_RawDataProviderToolMT.cxx.

                                                                               {
    SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
    const RpcCablingCondData* readCdo{*readHandle};
    // CALLGRIND_START_INSTRUMENTATION
    std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
    std::vector<uint32_t> robIds = readCdo->giveFullListOfRobIds();
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    // CALLGRIND_STOP_INSTRUMENTATION
    return convert(vecOfRobf, ctx);  // using the old one
}

convert() [3/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const ROBFragmentList & vecRobs, const EventContext & ctx ) const

overridevirtual

EventContext ones.

Definition at line 56 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                               {
    // CALLGRIND_START_INSTRUMENTATION
    std::vector<IdentifierHash> collections;
    // CALLGRIND_STOP_INSTRUMENTATION
    return convert(vecRobs, collections, ctx);
}

convert() [4/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const ROBFragmentList & vecRobs, const std::vector< IdentifierHash > & collections, const EventContext & ctx ) const

overridevirtual

Definition at line 98 of file RPC_RawDataProviderToolMT.cxx.

                                                                                   {
    // CALLGRIND_START_INSTRUMENTATION
 
    SG::WriteHandle<RpcPadContainer> rdoContainerHandle(m_containerKey, ctx);
    SG::WriteHandle<RpcSectorLogicContainer> logicHandle(m_sec, ctx);
 
    // run 3 mode, here we always try to write the containers
 
    // Split the methods to have one where we use the cache and one where we just setup the container
    const bool externalCacheRDO = !m_rdoContainerCacheKey.key().empty();
    if (!externalCacheRDO) {
        ATH_CHECK(rdoContainerHandle.record(std::make_unique<RpcPadContainer>(m_idHelperSvc->rpcIdHelper().module_hash_max())));
        ATH_MSG_DEBUG("Created RpcPadContainer");
    } else {
        SG::UpdateHandle<RpcPad_Cache> update(m_rdoContainerCacheKey, ctx);
        ATH_CHECK(update.isValid());
        ATH_CHECK(rdoContainerHandle.record(std::make_unique<RpcPadContainer>(update.ptr())));
        ATH_MSG_DEBUG("Created container using cache for " << m_rdoContainerCacheKey.key());
    }
    RpcPadContainer* pad = rdoContainerHandle.ptr();
 
    RpcSectorLogicContainer* logic = nullptr;
    if (m_WriteOutRpcSectorLogic) {
        ATH_MSG_DEBUG("Writing out RpcSectorLogicContainer");
        ATH_CHECK(logicHandle.record(std::make_unique<RpcSectorLogicContainer>()));
        logic = logicHandle.ptr();
    }
 
    // pass the containers to the convertIntoContainers function in the RPC_RawDataProviderToolCore base class
    ATH_CHECK(convertIntoContainers(vecRobs, collections, pad, logic, true));
 
    return StatusCode::SUCCESS;
}

convert() [5/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const ROBFragmentList & vecRobs ) const

overridevirtual

Decoding method.

• current methods: let's keep them!

Definition at line 52 of file RPC_RawDataProviderToolMT.cxx.

                                                                                      {
    return this->convert(vecRobs, Gaudi::Hive::currentContext());
}

convert() [6/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const ROBFragmentList & vecRobs, const std::vector< IdentifierHash > & coll ) const

overridevirtual

Definition at line 94 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                                                    {
    return this->convert(vecRobs, collections, Gaudi::Hive::currentContext());
}

convert() [7/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const std::vector< IdentifierHash > & rdoIdhVect ) const

overridevirtual

for a selection of rdo collections

Definition at line 78 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                   {
    return this->convert(rdoIdhVect, Gaudi::Hive::currentContext());
}

convert() [8/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const std::vector< IdentifierHash > & rdoIdhVect, const EventContext & ctx ) const

overridevirtual

Definition at line 82 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                                            {
    SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
    const RpcCablingCondData* readCdo{*readHandle};
    // CALLGRIND_START_INSTRUMENTATION
    std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
    std::vector<uint32_t> robIds;
    CHECK(readCdo->giveROB_fromRDO(rdoIdhVect, robIds));
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    // CALLGRIND_STOP_INSTRUMENTATION
    return convert(vecOfRobf, rdoIdhVect, ctx);  // using the old one
}

convert() [9/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const std::vector< uint32_t > & robIds ) const

overridevirtual

Definition at line 64 of file RPC_RawDataProviderToolMT.cxx.

                                                                                         {
    return this->convert(robIds, Gaudi::Hive::currentContext());
}

convert() [10/10]

StatusCode Muon::RPC_RawDataProviderToolMT::convert ( const std::vector< uint32_t > & robIds, const EventContext & ctx ) const

overridevirtual

Definition at line 68 of file RPC_RawDataProviderToolMT.cxx.

                                                                                                                  {
    // CALLGRIND_START_INSTRUMENTATION
    std::vector<IdentifierHash> collections;
    std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    // CALLGRIND_STOP_INSTRUMENTATION
    return convert(vecOfRobf, collections, ctx);
}

initialize()

StatusCode Muon::RPC_RawDataProviderToolMT::initialize ( )

overridevirtual

Definition at line 17 of file RPC_RawDataProviderToolMT.cxx.

                                                     {
    ATH_CHECK(RPC_RawDataProviderToolCore::initialize());
 
    ATH_CHECK(m_rdoContainerCacheKey.initialize(!m_rdoContainerCacheKey.key().empty()));
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    // We should only turn off the sector logic when running with cached data a la trigger mode
    if (!m_rdoContainerCacheKey.key().empty() && m_WriteOutRpcSectorLogic) {
        ATH_MSG_FATAL(
            "Cannot write out RpcSectorLogic while running with cached RpcPad containers"
            " as the RpcSectorLogic is not cached at the same time and the written containers will desync."
            " Please turn off RpcSectorLogic writing when running with cached bytestream container");
        return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO("initialize() successful in " << name());
 
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::RPC_RawDataProviderToolMT::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 54 of file RPC_RawDataProviderToolMT.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_rdoContainerCacheKey

SG::UpdateHandleKey<RpcPad_Cache> Muon::RPC_RawDataProviderToolMT::m_rdoContainerCacheKey

private

Initial value:

{this,"RpcContainerCacheKey", 
                                                "", "Optional external cache for the RPC container"}

RPC container cache key.

Definition at line 49 of file RPC_RawDataProviderToolMT.h.

                                                              {this,"RpcContainerCacheKey", 
                                                "", "Optional external cache for the RPC container"};

m_WriteOutRpcSectorLogic

Gaudi::Property<bool> Muon::RPC_RawDataProviderToolMT::m_WriteOutRpcSectorLogic {this, "WriteOutRpcSectorLogic", true, "Turn on/off RpcSectorLogic writing"}

private

Turn on/off RpcSectorConfig writing.

Definition at line 52 of file RPC_RawDataProviderToolMT.h.

{this, "WriteOutRpcSectorLogic", true, "Turn on/off RpcSectorLogic writing"};

---

The documentation for this class was generated from the following files:

• RPC_RawDataProviderToolMT.h
• RPC_RawDataProviderToolMT.cxx