#include <RPC_RawDataProviderTool.h>

Inheritance diagram for Muon::RPC_RawDataProviderTool:

Collaboration diagram for Muon::RPC_RawDataProviderTool:

Public Member Functions
virtual	~RPC_RawDataProviderTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	convert (const EventContext &) const override
	Decoding method - IMuonRawDataProviderTool interface (EventContext-based).
virtual StatusCode	convert (const std::vector< IdentifierHash > &, const EventContext &) const override
virtual StatusCode	convert (const std::vector< uint32_t > &, const EventContext &) const override

Private Member Functions
StatusCode	convertIntoContainer (const ROBFragmentList &vecRobs, const std::vector< IdentifierHash > &collections, const EventContext &ctx) const
StatusCode	convertIntoContainers (const ROBFragmentList &vecRobs, const std::vector< IdentifierHash > &collections, RpcPadContainer pad, RpcSectorLogicContainer logic, const bool &decodeSL, const EventContext &ctx) const
std::vector< IdentifierHash >	to_be_converted (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, const std::vector< IdentifierHash > &coll) const

Private Attributes
SG::ReadCondHandleKey< RpcCablingCondData >	m_readKey {this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"}
ServiceHandle< IROBDataProviderSvc >	m_robDataProvider {this, "ROBDataProviderSvc", "ROBDataProviderSvc"}
ToolHandle< IRpcROD_Decoder >	m_decoder {this, "Decoder", "Muon::RpcROD_Decoder/RpcROD_Decoder"}
SG::WriteHandleKey< RpcPadContainer >	m_containerKey {this, "RdoLocation", "RPCPAD", "Name of the RPCPAD produced by RawDataProvider"}
SG::WriteHandleKey< RpcSectorLogicContainer >	m_sec
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

Definition at line 24 of file RPC_RawDataProviderTool.h.

Constructor & Destructor Documentation

◆ ~RPC_RawDataProviderTool()

virtual Muon::RPC_RawDataProviderTool::~RPC_RawDataProviderTool ( )

virtualdefault

Member Function Documentation

◆ convert() [1/3]

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

overridevirtual

Decoding method - IMuonRawDataProviderTool interface (EventContext-based).

Definition at line 96 of file RPC_RawDataProviderTool.cxx.

                                                                         {
    const RpcCablingCondData* readCdo{nullptr};
    ATH_CHECK(SG::get(readCdo, m_readKey, ctx));
    return convert(readCdo->giveFullListOfRobIds(), ctx);
}

◆ convert() [2/3]

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

overridevirtual

Definition at line 110 of file RPC_RawDataProviderTool.cxx.

                                                                           {
    const RpcCablingCondData* readCdo{nullptr};
    ATH_CHECK(SG::get(readCdo, m_readKey, ctx));
    ROBFragmentList vecOfRobf;
    std::vector<uint32_t> robIds;
    ATH_CHECK(readCdo->giveROB_fromRDO(rdoIdhVect, robIds));
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    return convertIntoContainer(vecOfRobf, rdoIdhVect, ctx);
}

◆ convert() [3/3]

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

overridevirtual

Definition at line 102 of file RPC_RawDataProviderTool.cxx.

                                                                           {
    std::vector<IdentifierHash> collections;
    ROBFragmentList vecOfRobf;
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    return convertIntoContainer(vecOfRobf, collections, ctx);
}

◆ convertIntoContainer()

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

private

Definition at line 121 of file RPC_RawDataProviderTool.cxx.

                                                                                        {
    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
    ATH_CHECK(convertIntoContainers(vecRobs, collections, pad, logic, true, ctx));
 
    return StatusCode::SUCCESS;
}

◆ convertIntoContainers()

StatusCode Muon::RPC_RawDataProviderTool::convertIntoContainers	(	const ROBFragmentList &	vecRobs,
		const std::vector< IdentifierHash > &	collections,
		RpcPadContainer *	pad,
		RpcSectorLogicContainer *	logic,
		const bool &	decodeSL,
		const EventContext &	ctx ) const

private

Definition at line 46 of file RPC_RawDataProviderTool.cxx.

                                   {
    for (auto itFrag = vecRobs.begin(); itFrag != vecRobs.end(); itFrag++) {
        // convert only if data payload is delivered
        if ((**itFrag).rod_ndata() != 0) {
            std::vector<IdentifierHash> coll = to_be_converted(**itFrag, collections);
 
            if (m_decoder->fillCollections(ctx, **itFrag, *pad, coll, logic, decodeSL).isFailure()) {
                // store the error conditions into the StatusCode and continue
            }
        } else {
            if (msgLvl(MSG::DEBUG)) {
                uint32_t sourceId = (**itFrag).source_id();
                msg(MSG::DEBUG) << " ROB " << MSG::hex << sourceId << " is delivered with an empty payload" << MSG::dec << endmsg;
            }
            // store the error condition into the StatusCode and continue
        }
    }
 
    ATH_MSG_DEBUG("After processing, number of collections in container : " << pad->numberOfCollections());
 
    // in presence of errors return FAILURE
    return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode Muon::RPC_RawDataProviderTool::initialize ( )

overridevirtual

Definition at line 16 of file RPC_RawDataProviderTool.cxx.

                                               {
    // retrieve ROD decoder
    ATH_CHECK(m_decoder.retrieve());
 
    ATH_CHECK(m_containerKey.initialize());
    ATH_CHECK(m_sec.initialize());
 
    // get ROB data provider service
    ATH_CHECK(m_robDataProvider.retrieve());
 
    ATH_CHECK(m_readKey.initialize());
 
    // Additional initialization from MT class
    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;
}

◆ to_be_converted()

std::vector< IdentifierHash > Muon::RPC_RawDataProviderTool::to_be_converted	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &	robFrag,
		const std::vector< IdentifierHash > &	coll ) const

private

Definition at line 73 of file RPC_RawDataProviderTool.cxx.

                                                                                                                         {
    SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
    const RpcCablingCondData* readCdo{*readHandle};
 
    std::vector<IdentifierHash> to_return;
    if (coll.empty()) {
        // get SubdetectorId and ModuleId
        uint32_t source_id = robFrag.rod_source_id();
        SourceIdentifier sid(source_id);
        to_return = (readCdo->rod2hash(sid.subdetector_id(), sid.module_id()));
    } else {
        uint32_t source_id = robFrag.rod_source_id();
        std::vector<IdentifierHash>::const_iterator it = coll.begin();
        to_return.reserve(coll.size());
        for (; it != coll.end(); ++it) {
            if (source_id == readCdo->hash2source(*it)) to_return.emplace_back(*it);
        }
    }
 
    return to_return;
}

Member Data Documentation

◆ m_containerKey

SG::WriteHandleKey<RpcPadContainer> Muon::RPC_RawDataProviderTool::m_containerKey {this, "RdoLocation", "RPCPAD", "Name of the RPCPAD produced by RawDataProvider"}

private

Definition at line 61 of file RPC_RawDataProviderTool.h.

61{this, "RdoLocation", "RPCPAD", "Name of the RPCPAD produced by RawDataProvider"};

◆ m_decoder

ToolHandle<IRpcROD_Decoder> Muon::RPC_RawDataProviderTool::m_decoder {this, "Decoder", "Muon::RpcROD_Decoder/RpcROD_Decoder"}

private

Definition at line 58 of file RPC_RawDataProviderTool.h.

58{this, "Decoder", "Muon::RpcROD_Decoder/RpcROD_Decoder"};

◆ m_idHelperSvc

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

private

Definition at line 72 of file RPC_RawDataProviderTool.h.

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

◆ m_rdoContainerCacheKey

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

private

Initial value:

{this, "RpcContainerCacheKey",

"", "Optional external cache for the RPC container"}

RPC container cache key.

Definition at line 67 of file RPC_RawDataProviderTool.h.

67 {this, "RpcContainerCacheKey",

68 "", "Optional external cache for the RPC container"};

◆ m_readKey

SG::ReadCondHandleKey<RpcCablingCondData> Muon::RPC_RawDataProviderTool::m_readKey {this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"}

private

Definition at line 52 of file RPC_RawDataProviderTool.h.

52{this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"};

◆ m_robDataProvider

ServiceHandle<IROBDataProviderSvc> Muon::RPC_RawDataProviderTool::m_robDataProvider {this, "ROBDataProviderSvc", "ROBDataProviderSvc"}

private

Definition at line 55 of file RPC_RawDataProviderTool.h.

55{this, "ROBDataProviderSvc", "ROBDataProviderSvc"};

◆ m_sec

SG::WriteHandleKey<RpcSectorLogicContainer> Muon::RPC_RawDataProviderTool::m_sec

private

Initial value:

{this, "RPCSec", "RPC_SECTORLOGIC",

"Name of the RPC_SECTORLOGIC produced by RawDataProvider"}

Definition at line 63 of file RPC_RawDataProviderTool.h.

63 {this, "RPCSec", "RPC_SECTORLOGIC",

64 "Name of the RPC_SECTORLOGIC produced by RawDataProvider"};

◆ m_WriteOutRpcSectorLogic

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

private

Turn on/off RpcSectorConfig writing.

Definition at line 70 of file RPC_RawDataProviderTool.h.

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~RPC_RawDataProviderTool()

Member Function Documentation

◆ convert() [1/3]

◆ convert() [2/3]

◆ convert() [3/3]

◆ convertIntoContainer()

◆ convertIntoContainers()

◆ initialize()

◆ to_be_converted()

Member Data Documentation

◆ m_containerKey

◆ m_decoder

◆ m_idHelperSvc

◆ m_rdoContainerCacheKey

◆ m_readKey

◆ m_robDataProvider

◆ m_sec

◆ m_WriteOutRpcSectorLogic