Muon::CSC_RawDataProviderTool Class Reference

#include <CSC_RawDataProviderTool.h>

Inheritance diagram for Muon::CSC_RawDataProviderTool:

Collaboration diagram for Muon::CSC_RawDataProviderTool:

Public Member Functions
virtual	~CSC_RawDataProviderTool ()
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	convert (const EventContext &ctx) const override
virtual StatusCode	convert (const std::vector< uint32_t > &robIds, const EventContext &ctx) const override
virtual StatusCode	convert (const std::vector< IdentifierHash > &rdoIdhVect, const EventContext &ctx) const override

Private Member Functions
StatusCode	convertIntoContainer (const ROBFragmentList &vecRobs, const EventContext &ctx) const
	function to decode the passed ROB fragments into the passed container

Private Attributes
ToolHandle< ICSC_ROD_Decoder >	m_decoder {this, "Decoder", "Muon::CscROD_Decoder/CscROD_Decoder"}
	member variables for algorithm properties:
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::WriteHandleKey< CscRawDataContainer >	m_containerKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this, "EventInfoKey", "EventInfo", ""}
CSC_Hid2RESrcID	m_hid2re
ServiceHandle< IROBDataProviderSvc >	m_robDataProvider {this, "RobProviderSvc", "ROBDataProviderSvc"}
ServiceHandle< CSCcablingSvc >	m_cabling {this, "CablingSvc", "CSCcablingSvc"}
SG::UpdateHandleKey< CscRawDataCollection_Cache >	m_rdoContainerCacheKey
	CSC container cache key.

Detailed Description

Definition at line 25 of file CSC_RawDataProviderTool.h.

Constructor & Destructor Documentation

~CSC_RawDataProviderTool()

Muon::CSC_RawDataProviderTool::~CSC_RawDataProviderTool ( )

virtualdefault

default destructor

Member Function Documentation

convert() [1/3]

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

overridevirtual

Definition at line 120 of file CSC_RawDataProviderTool.cxx.

                                                                         {
    return convert(m_hid2re.allRobIds(), ctx);
}

convert() [2/3]

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

overridevirtual

Definition at line 101 of file CSC_RawDataProviderTool.cxx.

                                                                           {
    IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
 
    ROBFragmentList vecOfRobf;
    std::vector<uint32_t> robIds;
 
    for (unsigned int i = 0; i < rdoIdhVect.size(); ++i) {
        uint32_t rob_id = 0xffff;
        m_cabling->hash2RobFull(rdoIdhVect[i], rob_id);
        robIds.push_back(rob_id);
    }
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    ATH_MSG_VERBOSE("Number of ROB fragments " << vecOfRobf.size());
 
    // This would be passed to the function which does not use the IdentifierHash further
    return convertIntoContainer(vecOfRobf, ctx);
}

convert() [3/3]

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

overridevirtual

Definition at line 124 of file CSC_RawDataProviderTool.cxx.

                                                                           {
    ROBFragmentList vecOfRobf;
 
    ATH_MSG_VERBOSE("Number of ROB ids " << robIds.size());
    // ask ROBDataProviderSvc for the vector of ROBFragment for all CSC ROBIDs
    m_robDataProvider->getROBData(ctx, robIds, vecOfRobf);
    ATH_MSG_VERBOSE("Number of ROB fragments " << vecOfRobf.size());
 
    return convertIntoContainer(vecOfRobf, ctx);
  
}

convertIntoContainer()

StatusCode Muon::CSC_RawDataProviderTool::convertIntoContainer ( const ROBFragmentList & vecRobs, const EventContext & ctx ) const

private

function to decode the passed ROB fragments into the passed container

Definition at line 51 of file CSC_RawDataProviderTool.cxx.

                                                                   {
    std::set<uint32_t> robIdSet;
 
      SG::WriteHandle rdoContainerHandle{m_containerKey, ctx};
 
    // 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<CscRawDataContainer>(m_idHelperSvc->cscIdHelper().module_hash_max())));
        ATH_MSG_DEBUG("Created CSCRawDataContainer");
    } else {
        SG::UpdateHandle update{m_rdoContainerCacheKey, ctx};
        ATH_CHECK(update.isValid());
        ATH_CHECK(rdoContainerHandle.record(std::make_unique<CscRawDataContainer>(update.ptr())));
        ATH_MSG_DEBUG("Created container using cache for " << m_rdoContainerCacheKey.key());
    }
 
    CscRawDataContainer* container = rdoContainerHandle.ptr();
 
    if (!container) {
        ATH_MSG_ERROR("CSC RDO container pointer is null, cannot decode data");
        return StatusCode::FAILURE;
    }
    const xAOD::EventInfo* eventInfo{nullptr};
    ATH_CHECK(SG::get(eventInfo, m_eventInfoKey, ctx));
    
    ATH_MSG_DEBUG("Before processing numColls=" << container->numberOfCollections());
 
    ATH_MSG_DEBUG("vector of ROB ID to decode: size = " << vecRobs.size());
 
    for (const ROBFragment* frag : vecRobs) {
        uint32_t robid = frag->rod_source_id();
 
        // check if this ROBFragment was already decoded (EF case in ROIs
        if (!robIdSet.insert(robid).second) {
            ATH_MSG_DEBUG(" ROB Fragment with ID  " << std::hex << robid << std::dec << " already decoded, skip");
        } else {
            m_decoder->fillCollection(*eventInfo, *frag, *container);
        }
    }
 
    ATH_MSG_DEBUG("After processing numColls=" << container->numberOfCollections());
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode Muon::CSC_RawDataProviderTool::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 27 of file CSC_RawDataProviderTool.cxx.

                                               {
    ATH_CHECK(m_cabling.retrieve());
    ATH_CHECK(m_robDataProvider.retrieve());
    ATH_MSG_INFO("Retrieved service " << m_robDataProvider);
 
    ATH_CHECK(m_idHelperSvc.retrieve());
    m_hid2re.set(m_cabling.get(), &m_idHelperSvc->cscIdHelper());
 
    // Retrieve decoder
    ATH_CHECK(m_decoder.retrieve());
    ATH_MSG_INFO("Retrieved tool " << m_decoder);
 
    ATH_CHECK(m_containerKey.initialize());
    ATH_CHECK(m_eventInfoKey.initialize());
 
    // Initialise the container cache if available
    ATH_CHECK(m_rdoContainerCacheKey.initialize(!m_rdoContainerCacheKey.key().empty()));
 
    ATH_MSG_INFO("initialize() successful in " << name());
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_cabling

ServiceHandle<CSCcablingSvc> Muon::CSC_RawDataProviderTool::m_cabling {this, "CablingSvc", "CSCcablingSvc"}

private

Definition at line 57 of file CSC_RawDataProviderTool.h.

{this, "CablingSvc", "CSCcablingSvc"};

m_containerKey

SG::WriteHandleKey<CscRawDataContainer> Muon::CSC_RawDataProviderTool::m_containerKey

private

Initial value:

{this, "RdoLocation", "CSCRDO",
                                                               "Name of the CSCRDO produced by RawDataProvider"}

Definition at line 51 of file CSC_RawDataProviderTool.h.

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

m_decoder

ToolHandle<ICSC_ROD_Decoder> Muon::CSC_RawDataProviderTool::m_decoder {this, "Decoder", "Muon::CscROD_Decoder/CscROD_Decoder"}

private

member variables for algorithm properties:

Definition at line 47 of file CSC_RawDataProviderTool.h.

{this, "Decoder", "Muon::CscROD_Decoder/CscROD_Decoder"};

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> Muon::CSC_RawDataProviderTool::m_eventInfoKey {this, "EventInfoKey", "EventInfo", ""}

private

Definition at line 53 of file CSC_RawDataProviderTool.h.

{this, "EventInfoKey", "EventInfo", ""};

m_hid2re

CSC_Hid2RESrcID Muon::CSC_RawDataProviderTool::m_hid2re

private

Definition at line 54 of file CSC_RawDataProviderTool.h.

m_idHelperSvc

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

private

Definition at line 49 of file CSC_RawDataProviderTool.h.

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

m_rdoContainerCacheKey

SG::UpdateHandleKey<CscRawDataCollection_Cache> Muon::CSC_RawDataProviderTool::m_rdoContainerCacheKey

private

Initial value:

{this, "CscContainerCacheKey", "",
                                                                                 "Optional external cache for the CSC container"}

CSC container cache key.

Definition at line 60 of file CSC_RawDataProviderTool.h.

                                                                            {this, "CscContainerCacheKey", "",
                                                                                 "Optional external cache for the CSC container"};

m_robDataProvider

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

private

Definition at line 56 of file CSC_RawDataProviderTool.h.

{this, "RobProviderSvc", "ROBDataProviderSvc"};

---

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

• CSC_RawDataProviderTool.h
• CSC_RawDataProviderTool.cxx