Muon::CscRdoToCscPrepDataToolMT Class Reference

This class is only used in a single-thread mode as CscRdoToCscPrepDataToolMT has the equivalent functions defined for a thread-safe setup. More...

#include <CscRdoToCscPrepDataToolMT.h>

Inheritance diagram for Muon::CscRdoToCscPrepDataToolMT:

Collaboration diagram for Muon::CscRdoToCscPrepDataToolMT:

Public Member Functions
	CscRdoToCscPrepDataToolMT (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~CscRdoToCscPrepDataToolMT ()=default
virtual StatusCode	initialize () override
virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &givenIdhs) const override
virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIDs) const override
virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override

Protected Member Functions
StatusCode	decodeImpl (Muon::CscStripPrepDataContainer *outputCollection, const CscRawDataContainer *rdoContainer, IdentifierHash givenHashId) const
StatusCode	decodeImpl (Muon::CscStripPrepDataContainer *outputCollection, const CscRawDataContainer *rdoContainer) const

Protected Attributes
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::WriteHandleKey< Muon::CscStripPrepDataContainer >	m_outputCollectionKey
	CscStripPrepRawData containers.
SG::ReadHandleKey< CscRawDataContainer >	m_rdoContainerKey {this, "RDOContainer", "CSCRDO", "CscRawDataContainer to retrieve"}
SG::UpdateHandleKey< CscStripPrepDataCollection_Cache >	m_prdContainerCacheKey
	This is the key for the cache for the CSC PRD containers, can be empty.
ToolHandle< ICscCalibTool >	m_cscCalibTool {this, "CscCalibTool", "CscCalibTool/CscCalibTool"}
	CSC Calibration tools.
ToolHandle< ICSC_RDO_Decoder >	m_cscRdoDecoderTool {this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder/CscRDO_Decoder"}
ServiceHandle< CSCcablingSvc >	m_cabling {this, "CablingSvc", "CSCcablingSvc"}
Gaudi::Property< int >	m_cscOffset {this, "CSCHashIdOffset", 22000}
	Identifier hash offset.
Gaudi::Property< bool >	m_decodeData {this, "DecodeData", true}
	toggle on/off the decoding of CSC RDO into CscStripPrepData

Detailed Description

This class is only used in a single-thread mode as CscRdoToCscPrepDataToolMT has the equivalent functions defined for a thread-safe setup.

Definition at line 39 of file CscRdoToCscPrepDataToolMT.h.

Constructor & Destructor Documentation

CscRdoToCscPrepDataToolMT()

CscRdoToCscPrepDataToolMT::CscRdoToCscPrepDataToolMT	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 21 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                                                           :
    base_class(type, name, parent) {}

~CscRdoToCscPrepDataToolMT()

virtual Muon::CscRdoToCscPrepDataToolMT::~CscRdoToCscPrepDataToolMT ( )

virtualdefault

Member Function Documentation

decode() [1/2]

StatusCode CscRdoToCscPrepDataToolMT::decode ( const EventContext & ctx, const std::vector< IdentifierHash > & givenIdhs ) const

overridevirtual

Recording the PRD container in StoreGate

Definition at line 64 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                                                      {
    // WARNING : Trigger Part is not finished.
    unsigned int sizeVectorRequested = givenIdhs.size();
    ATH_MSG_DEBUG("decode for " << sizeVectorRequested << " offline collections called");
 

    SG::WriteHandle<Muon::CscStripPrepDataContainer> outputHandle(m_outputCollectionKey, ctx);
 
    // Caching of PRD container
    if (m_prdContainerCacheKey.key().empty()) {
        // without the cache we just record the container
        ATH_CHECK(outputHandle.record(std::make_unique<Muon::CscStripPrepDataContainer>(m_idHelperSvc->cscIdHelper().module_hash_max())));
        ATH_MSG_DEBUG("Created container " << m_outputCollectionKey.key());
    } else {
        // use the cache to get the container
        SG::UpdateHandle<CscStripPrepDataCollection_Cache> update(m_prdContainerCacheKey, ctx);
        if (!update.isValid()) {
            ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
            return StatusCode::FAILURE;
        }
        ATH_CHECK(outputHandle.record(std::make_unique<Muon::CscStripPrepDataContainer>(update.ptr())));
        ATH_MSG_DEBUG("Created container using cache for " << m_prdContainerCacheKey.key());
    }
    // Pass the container from the handle
    Muon::CscStripPrepDataContainer* outputCollection = outputHandle.ptr();
 
    // retrieve the pointer to the RDO container
    // this will just get the pointer from memory if the container is already recorded in SG
    // or
    // will activate the TP converter for reading from pool root the RDO container and recording it in SG
 
    auto rdoContainerHandle = SG::makeHandle(m_rdoContainerKey, ctx);
    if (!rdoContainerHandle.isValid()) {
        ATH_MSG_WARNING("No CSC RDO container in StoreGate!");
        return StatusCode::SUCCESS;
    }
    const CscRawDataContainer* rdoContainer = rdoContainerHandle.cptr();
 
    ATH_MSG_DEBUG("Retrieved " << rdoContainer->size() << " CSC RDOs.");
    // here the RDO container is in SG and its pointer rdoContainer is initialised
    // decoding
    if (sizeVectorRequested) {
        // seeded decoding
        for (unsigned int i = 0; i < sizeVectorRequested; ++i) {
            if (decodeImpl(outputCollection, rdoContainer, givenIdhs[i]).isFailure()) {
                ATH_MSG_ERROR("Unable to decode CSC RDO " << i << "th into CSC PrepRawData");
                return StatusCode::FAILURE;
            }
        }
    } else {
        // unseeded decoding
        if (decodeImpl(outputCollection, rdoContainer).isFailure()) {
            ATH_MSG_ERROR("Unable to decode CSC RDO ");
            return StatusCode::FAILURE;
        }
    }
 
    return StatusCode::SUCCESS;
}

decode() [2/2]

StatusCode CscRdoToCscPrepDataToolMT::decode ( const EventContext & ctx, const std::vector< uint32_t > & robIDs ) const

overridevirtual

Definition at line 39 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                                  { 
   ATH_MSG_FATAL("ROB based decoding is not supported....");
   return StatusCode::FAILURE;
}

decodeImpl() [1/2]

StatusCode CscRdoToCscPrepDataToolMT::decodeImpl ( Muon::CscStripPrepDataContainer * outputCollection, const CscRawDataContainer * rdoContainer ) const

protected

new CscPrepRawData

Definition at line 289 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                                {
    typedef CscRawDataContainer::const_iterator collection_iterator;
 
    IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
    // if CSC decoding is switched off stop here
    if (!m_decodeData) {
        ATH_MSG_DEBUG("Stored empty container. "
                      << "Decoding CSC RDO into CSC PrepRawData is switched off");
        return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("Decoding CSC RDO into CSC PrepRawData");
 
    collection_iterator rdoColl = rdoContainer->begin();
    collection_iterator lastRdoColl = rdoContainer->end();
    std::vector<float> charges;
    charges.reserve(4);
    std::vector<uint16_t> samples;
    samples.reserve(4);
 
    IdentifierHash cscHashId;
    for (; rdoColl != lastRdoColl; ++rdoColl) {
        if (!(*rdoColl)->empty()) {
            ATH_MSG_DEBUG(" Number of RawData in this rdo " << (*rdoColl)->size());
 
            const CscRawDataCollection* cscCollection = *rdoColl;
            unsigned int samplingTime = cscCollection->rate();
            unsigned int numSamples = cscCollection->numSamples();
            bool samplingPhase = cscCollection->samplingPhase();
 
            if (int(samplingTime) != int(m_cscCalibTool->getSamplingTime())) {
                ATH_MSG_WARNING(" CSC sampling time from Collection is NOT consistant to calibTool parameter!!!!!!! ");
            }
            // For each Rdo, loop over RawData, converter RawData to PrepRawData
            // Retrieve/create PrepRawData collection, and insert PrepRawData into collection
            CscRawDataCollection::const_iterator itD = cscCollection->begin();
            CscRawDataCollection::const_iterator itD_e = cscCollection->end();
 
            // Each RDO Collection goes into a PRD Collection, but we need to know what hash the PRD container is
            // and this is determined by the stationID, no the RDO hash ID
            ATH_MSG_DEBUG("CSC RDO ID " << (*rdoColl)->identify() << " with hashID " << (*rdoColl)->identifyHash());
            // Just use the first iterator entry as stationID does not change between data inside a single container
            Identifier stationId = m_cscRdoDecoderTool->stationIdentifier((const CscRawData*)(*itD), &m_idHelperSvc->cscIdHelper());
            if (m_idHelperSvc->cscIdHelper().get_hash(stationId, cscHashId, &cscContext)) {
                ATH_MSG_WARNING("Unable to get CSC digiti collection hash id "
                                << "context begin_index = " << cscContext.begin_index()
                                << " context end_index  = " << cscContext.end_index() << " the identifier is ");
                stationId.show();
            }
 
            ATH_MSG_DEBUG("Create CSC PRD Collection with hash " << cscHashId);
            std::unique_ptr<CscStripPrepDataCollection> collection = nullptr;
            CscStripPrepDataContainer::IDC_WriteHandle lock = outputCollection->getWriteHandle(cscHashId);
            if (lock.alreadyPresent()) {
                ATH_MSG_DEBUG("CSC PRD collection already exist with collection hash = " << cscHashId << " collection filling is skipped!");
                continue;
            } else {
                ATH_MSG_DEBUG("CSC PRD collection does not exist - creating a new one with hash = " << cscHashId);
                collection = std::make_unique<CscStripPrepDataCollection>(cscHashId);
                collection->setIdentifier(stationId);
            }
 
            // This loops over the RDO data, decodes and puts into the PRD collection
            for (; itD != itD_e; ++itD) {
                const CscRawData* data = (*itD);
                uint16_t width = data->width();
                uint16_t totalSamples = (data->samples()).size();
                uint32_t hashOffset = data->hashId();
 
                ATH_MSG_DEBUG("DecodeAll*Size of online cluster in this RawData: "
                              << " Width = " << width << " Samples = " << totalSamples << " stationId : " << stationId
                              << "  hashOffset : " << hashOffset);
 
                for (unsigned int j = 0; j < width; ++j) {
                    const Identifier channelId = m_cscRdoDecoderTool->channelIdentifier(data, &m_idHelperSvc->cscIdHelper(), j);
                    ATH_MSG_DEBUG("DecodeAll**LOOP over width  " << j << " " << channelId);
 
                    const CscReadoutElement* descriptor = muDetMgr->getCscReadoutElement(channelId);
                    // calculate local positions on the strip planes
                    if (!descriptor) {
                        ATH_MSG_WARNING("Invalid descriptor for " << m_idHelperSvc->cscIdHelper().show_to_string(channelId)
                                                                  << " Skipping channel ");
                        continue;
                    } else if (!descriptor->containsId(channelId)) {
                        ATH_MSG_WARNING("Identifier from the cabling service <"
                                        << m_idHelperSvc->cscIdHelper().show_to_string(channelId)
                                        << "> inconsistent with the geometry of detector element <"
                                        << m_idHelperSvc->cscIdHelper().show_to_string(descriptor->identify()) << ">  =>>ignore this hit");
                        continue;
                    }
 
                    float timeOfFirstSample = 0.0;
                    bool extractSamples = data->samples(j, numSamples, samples);
                    if (!extractSamples) {
                        ATH_MSG_WARNING("Unable to extract samples for strip " << j << " Online Cluster width = " << width
                                                                               << " for number of Samples = " << numSamples
                                                                               << " continuing ...");
                        continue;
                    }
 
                    IdentifierHash stripHash;
                    if (m_idHelperSvc->cscIdHelper().get_channel_hash(channelId, stripHash)) {
                        ATH_MSG_WARNING("Unable to get CSC strip hash id");
                        channelId.show();
                    }
 
                    Identifier channelIdFromHash;
                    m_idHelperSvc->cscIdHelper().get_id(stripHash, channelIdFromHash, &cscContext);
 
                    bool adctocharge = m_cscCalibTool->adcToCharge(samples, stripHash, charges);
                    if (!adctocharge) {
                        ATH_MSG_WARNING(" CSC conversion ADC to Charge failed "
                                        << "CSC PrepData not build ... skipping ");
                        continue;
                    }
                    if (samples.size() >= 4)
                        ATH_MSG_DEBUG("DecodeAll*** ADC: "
                                      << m_idHelperSvc->cscIdHelper().show_to_string(channelId) << " " << (int)stripHash << " "
                                      << m_idHelperSvc->cscIdHelper().show_to_string(channelIdFromHash) << " " << samples[0] << " "
                                      << samples[1] << " " << samples[2] << " " << samples[3] << " Charges: "
                                      << " " << charges[0] << " " << charges[1] << " " << charges[2] << " " << charges[3]);
                    if (m_idHelperSvc->cscIdHelper().get_hash(stationId, cscHashId, &cscContext)) {
                        ATH_MSG_WARNING("Unable to get CSC hash id from CSC RDO collection "
                                        << "context begin_index = " << cscContext.begin_index()
                                        << " context end_index  = " << cscContext.end_index() << " the identifier is ");
                        stationId.show();
                    }
 
                    // Check if this strip is already decoded.. Then we don't have to decode it again
                    bool IsThisStripDecoded = 0;
                    for (CscStripPrepDataCollection::const_iterator idig = collection->begin(); idig != collection->end(); ++idig) {
                        const CscStripPrepData& dig = **idig;
                        Identifier did = dig.identify();
                        if (did == channelId) {
                            IsThisStripDecoded = 1;
                            break;
                        }
                    }
                    if (IsThisStripDecoded) continue;
 
                    int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(channelId);
 
                    Amg::Vector2D localWirePos1(descriptor->xCoordinateInTrackingFrame(channelId), 0.);
 
                    int chamberLayer = m_idHelperSvc->cscIdHelper().chamberLayer(channelId);
                    float stripWidth = descriptor->cathodeReadoutPitch(chamberLayer, measuresPhi);
                    double errPos = stripWidth / sqrt(12.0);
 
                    AmgSymMatrix(2) covariance;
                    covariance.setIdentity();
                    covariance *= errPos * errPos;
                    auto errClusterPos = Amg::MatrixX(covariance);

                    CscStripPrepData* newPrepData = new CscStripPrepData(channelId, cscHashId, localWirePos1, std::move(errClusterPos),
                                                                         descriptor, charges, timeOfFirstSample, samplingTime);
 
                    if (samplingPhase) newPrepData->set_samplingPhase();
                    newPrepData->setHashAndIndex(collection->identifyHash(), collection->size());
                    collection->push_back(newPrepData);
                }
            }
            // Record the container after looping through all the RDO data in this RDO collection
            StatusCode status_lock = lock.addOrDelete(std::move(collection));
            if (status_lock.isFailure()) {
                ATH_MSG_ERROR("Could not insert CscStripPrepdataCollection into CscStripPrepdataContainer...");
                return StatusCode::FAILURE;
            }
        }
    }
    return StatusCode::SUCCESS;
}

decodeImpl() [2/2]

StatusCode CscRdoToCscPrepDataToolMT::decodeImpl ( Muon::CscStripPrepDataContainer * outputCollection, const CscRawDataContainer * rdoContainer, IdentifierHash givenHashId ) const

protected

create the CSC RDO decoder

new CscStripPrepRawData

Definition at line 125 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                   {
    IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
    const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
 
    // if CSC decoding is switched off stop here
    if (!m_decodeData) {
        ATH_MSG_DEBUG("Stored empty container; Decoding CSC RDO into CSC PrepRawData is switched off");
        return StatusCode::SUCCESS;
    }
 
    // These collections can be empty for the trigger
    if (!outputCollection || outputCollection->empty()) {
        ATH_MSG_DEBUG("Stored empty collection.");
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("Decoding CSC RDO into CSC PrepRawData");
    //**********************************************
    // retrieve specific collection for the givenID
    uint16_t idColl = 0xffff;
    m_cabling->hash2CollectionId(givenHashId, idColl);
    const CscRawDataCollection* rawCollection = rdoContainer->indexFindPtr(idColl);
    if (nullptr == rawCollection) {
        ATH_MSG_DEBUG("Specific CSC RDO collection retrieving failed for collection hash = " << idColl);
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("Retrieved " << rawCollection->size() << " CSC RDOs.");
    // return if the input raw collection is empty (can happen for seeded decoding in trigger)
    if (rawCollection->empty()) return StatusCode::SUCCESS;
 
    //************************************************
    IdentifierHash cscHashId;
 
    unsigned int samplingTime = rawCollection->rate();
    unsigned int numSamples = rawCollection->numSamples();
    bool samplingPhase = rawCollection->samplingPhase();
    std::vector<float> charges;
    charges.reserve(4);
    std::vector<uint16_t> samples;
    samples.reserve(4);
 
    if (int(samplingTime) != int(m_cscCalibTool->getSamplingTime())) {
        ATH_MSG_WARNING(" CSC sampling time from Collection is NOT consistant to calibTool parameter!!!!!!! ");
    }
 
    // For each Rdo, loop over RawData, converter RawData to PrepRawData
    // Retrieve/create PrepRawData collection, and insert PrepRawData into collection
    CscRawDataCollection::const_iterator itD = rawCollection->begin();
    CscRawDataCollection::const_iterator itD_e = rawCollection->end();
 
    // Each RDO Collection goes into a PRD Collection, but we need to know what hash the PRD container is
    // and this is determined by the stationID, no the RDO hash ID
    ATH_MSG_DEBUG("CSC RDO ID " << rawCollection->identify() << " with hashID " << rawCollection->identifyHash());
    // Just use the first iterator entry as stationID does not change between data inside a single container
    Identifier stationId = m_cscRdoDecoderTool->stationIdentifier((const CscRawData*)(*itD), &m_idHelperSvc->cscIdHelper());
    if (m_idHelperSvc->cscIdHelper().get_hash(stationId, cscHashId, &cscContext)) {
        ATH_MSG_WARNING("Unable to get CSC digiti collection hash id "
                        << "context begin_index = " << cscContext.begin_index() << " context end_index  = " << cscContext.end_index()
                        << " the identifier is ");
        stationId.show();
    }
    ATH_MSG_DEBUG("Create CSC PRD Collection with hash " << cscHashId << " (givenHashId is " << givenHashId << ")");
    std::unique_ptr<CscStripPrepDataCollection> collection = nullptr;
    CscStripPrepDataContainer::IDC_WriteHandle lock = outputCollection->getWriteHandle(cscHashId);
    // Note that if the hash check above works, we should never reach this step where the lock is present
    if (lock.alreadyPresent()) {
        ATH_MSG_DEBUG("CSC PRD collection already exist with collection hash = " << cscHashId << " collection filling is skipped!");
        return StatusCode::SUCCESS;
    } else {
        ATH_MSG_DEBUG("CSC PRD collection does not exist - creating a new one with hash = " << cscHashId);
        collection = std::make_unique<CscStripPrepDataCollection>(cscHashId);
        collection->setIdentifier(stationId);
    }
 
    for (; itD != itD_e; ++itD) {
        const CscRawData* data = (*itD);
        uint16_t width = data->width();
        uint16_t totalSamples = (data->samples()).size();
        uint32_t hashOffset = data->hashId();
 
        ATH_MSG_DEBUG(" Size of online cluster in this RawData: "
                      << " Width = " << width << " Samples = " << totalSamples << " stationId : " << stationId
                      << "  hashOffset : " << hashOffset);
 
        for (unsigned int j = 0; j < width; ++j) {
            const Identifier channelId = m_cscRdoDecoderTool->channelIdentifier(data, &m_idHelperSvc->cscIdHelper(), j);
            ATH_MSG_DEBUG("        LOOP over width  " << j << " " << channelId);
 
            const CscReadoutElement* descriptor = muDetMgr->getCscReadoutElement(channelId);
            // calculate local positions on the strip planes
            if (!descriptor) {
                ATH_MSG_WARNING("Invalid descriptor for " << m_idHelperSvc->cscIdHelper().show_to_string(channelId)
                                                          << " Skipping channel ");
                continue;
            } else if (!descriptor->containsId(channelId)) {
                ATH_MSG_WARNING("Identifier from the cabling service <"
                                << m_idHelperSvc->cscIdHelper().show_to_string(channelId)
                                << "> inconsistent with the geometry of detector element <"
                                << m_idHelperSvc->cscIdHelper().show_to_string(descriptor->identify()) << ">  =>>ignore this hit");
                continue;
            }
 
            float timeOfFirstSample = 0.0;
            bool extractSamples = data->samples(j, numSamples, samples);
            if (!extractSamples) {
                ATH_MSG_WARNING("Unable to extract samples for strip " << j << " Online Cluster width = " << width
                                                                       << " for number of Samples = " << numSamples << " continuing ...");
                continue;
            }
 
            IdentifierHash stripHash;
            if (m_idHelperSvc->cscIdHelper().get_channel_hash(channelId, stripHash)) {
                ATH_MSG_WARNING("Unable to get CSC strip hash id");
                channelId.show();
            }
 
            bool adctocharge = m_cscCalibTool->adcToCharge(samples, stripHash, charges);
            if (!adctocharge) {
                ATH_MSG_WARNING(" CSC conversion ADC to Charge failed "
                                << "CSC PrepData not build ... skipping ");
                continue;
            }
            if (samples.size() >= 4)
                ATH_MSG_DEBUG("ADC: " << m_idHelperSvc->cscIdHelper().show_to_string(channelId) << " " << samples[0] << " " << samples[1]
                                      << " " << samples[2] << " " << samples[3] << " Charges: "
                                      << " " << charges[0] << " " << charges[1] << " " << charges[2] << " " << charges[3]);
 
            int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(channelId);
 
            Amg::Vector2D localWirePos1(descriptor->xCoordinateInTrackingFrame(channelId), 0.);
 
            int chamberLayer = m_idHelperSvc->cscIdHelper().chamberLayer(channelId);
            float stripWidth = descriptor->cathodeReadoutPitch(chamberLayer, measuresPhi);
            double errPos = stripWidth / sqrt(12.0);
 
            AmgSymMatrix(2) covariance;
            covariance.setIdentity();
            covariance *= errPos * errPos;
            Amg::MatrixX errClusterPos = Amg::MatrixX(covariance);

            CscStripPrepData* newPrepData = new CscStripPrepData(channelId, cscHashId, localWirePos1, std::move(errClusterPos), descriptor,
                                                                 charges, timeOfFirstSample, samplingTime);
 
            if (samplingPhase) newPrepData->set_samplingPhase();
            newPrepData->setHashAndIndex(collection->identifyHash(), collection->size());
            collection->push_back(newPrepData);
        }
    }
    // Record the container
    StatusCode status_lock = lock.addOrDelete(std::move(collection));
    if (status_lock.isFailure()) {
        ATH_MSG_ERROR("Could not insert CscStripPrepdataCollection into CscStripPrepdataContainer...");
        return StatusCode::FAILURE;
    } 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode CscRdoToCscPrepDataToolMT::initialize ( )

overridevirtual

Definition at line 25 of file CscRdoToCscPrepDataToolMT.cxx.

                                                 {
    ATH_CHECK(m_cscCalibTool.retrieve());
    ATH_CHECK(m_cscRdoDecoderTool.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_cabling.retrieve());
 
    // initialize handle keys
    ATH_CHECK(m_rdoContainerKey.initialize());
    ATH_CHECK(m_outputCollectionKey.initialize());
    ATH_CHECK(m_muDetMgrKey.initialize());
    ATH_CHECK(m_prdContainerCacheKey.initialize(!m_prdContainerCacheKey.key().empty()));
    return StatusCode::SUCCESS;
}

provideEmptyContainer()

StatusCode CscRdoToCscPrepDataToolMT::provideEmptyContainer ( const EventContext & ctx ) const

overridevirtual

Recording the PRD container in StoreGate

Definition at line 43 of file CscRdoToCscPrepDataToolMT.cxx.

                                                                                        {
    SG::WriteHandle<Muon::CscStripPrepDataContainer> outputHandle(m_outputCollectionKey, ctx);
 
    // Caching of PRD container
    if (m_prdContainerCacheKey.key().empty()) {
        // without the cache we just record the container
        ATH_CHECK(outputHandle.record(std::make_unique<Muon::CscStripPrepDataContainer>(m_idHelperSvc->cscIdHelper().module_hash_max())));
        ATH_MSG_DEBUG("Created container " << m_outputCollectionKey.key());
    } else {
        // use the cache to get the container
        SG::UpdateHandle<CscStripPrepDataCollection_Cache> update(m_prdContainerCacheKey, ctx);
        if (!update.isValid()) {
            ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
            return StatusCode::FAILURE;
        }
        ATH_CHECK(outputHandle.record(std::make_unique<Muon::CscStripPrepDataContainer>(update.ptr())));
        ATH_MSG_DEBUG("Created container using cache for " << m_prdContainerCacheKey.key());
    }
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_cabling

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

protected

Definition at line 79 of file CscRdoToCscPrepDataToolMT.h.

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

m_cscCalibTool

ToolHandle<ICscCalibTool> Muon::CscRdoToCscPrepDataToolMT::m_cscCalibTool {this, "CscCalibTool", "CscCalibTool/CscCalibTool"}

protected

CSC Calibration tools.

Definition at line 76 of file CscRdoToCscPrepDataToolMT.h.

{this, "CscCalibTool", "CscCalibTool/CscCalibTool"};

m_cscOffset

Gaudi::Property<int> Muon::CscRdoToCscPrepDataToolMT::m_cscOffset {this, "CSCHashIdOffset", 22000}

protected

Identifier hash offset.

Definition at line 81 of file CscRdoToCscPrepDataToolMT.h.

{this, "CSCHashIdOffset", 22000};

m_cscRdoDecoderTool

ToolHandle<ICSC_RDO_Decoder> Muon::CscRdoToCscPrepDataToolMT::m_cscRdoDecoderTool {this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder/CscRDO_Decoder"}

protected

Definition at line 77 of file CscRdoToCscPrepDataToolMT.h.

{this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder/CscRDO_Decoder"};

m_decodeData

Gaudi::Property<bool> Muon::CscRdoToCscPrepDataToolMT::m_decodeData {this, "DecodeData", true}

protected

toggle on/off the decoding of CSC RDO into CscStripPrepData

Definition at line 83 of file CscRdoToCscPrepDataToolMT.h.

{this, "DecodeData", true};  

m_idHelperSvc

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

protected

Definition at line 62 of file CscRdoToCscPrepDataToolMT.h.

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

m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::CscRdoToCscPrepDataToolMT::m_muDetMgrKey

protected

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                         "Key of input MuonDetectorManager condition data"}

Definition at line 59 of file CscRdoToCscPrepDataToolMT.h.

                                                                    {this, "DetectorManagerKey", "MuonDetectorManager",
                                                                         "Key of input MuonDetectorManager condition data"};

m_outputCollectionKey

SG::WriteHandleKey<Muon::CscStripPrepDataContainer> Muon::CscRdoToCscPrepDataToolMT::m_outputCollectionKey

protected

Initial value:

{this, "OutputCollection", "CSC_Measurements",
                                                                                 "Muon::CscStripPrepDataContainer to record"}

CscStripPrepRawData containers.

Definition at line 65 of file CscRdoToCscPrepDataToolMT.h.

                                                                             {this, "OutputCollection", "CSC_Measurements",
                                                                                 "Muon::CscStripPrepDataContainer to record"};

m_prdContainerCacheKey

SG::UpdateHandleKey<CscStripPrepDataCollection_Cache> Muon::CscRdoToCscPrepDataToolMT::m_prdContainerCacheKey

protected

Initial value:

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

This is the key for the cache for the CSC PRD containers, can be empty.

Definition at line 71 of file CscRdoToCscPrepDataToolMT.h.

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

m_rdoContainerKey

SG::ReadHandleKey<CscRawDataContainer> Muon::CscRdoToCscPrepDataToolMT::m_rdoContainerKey {this, "RDOContainer", "CSCRDO", "CscRawDataContainer to retrieve"}

protected

Definition at line 68 of file CscRdoToCscPrepDataToolMT.h.

{this, "RDOContainer", "CSCRDO", "CscRawDataContainer to retrieve"};

---

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

• CscRdoToCscPrepDataToolMT.h
• CscRdoToCscPrepDataToolMT.cxx