d3/dd6/CscRdoToCscPrepDataToolMT_8cxx_source.html

/*

  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration

*/


#include "CscRdoToCscPrepDataToolMT.h"


#include "EventPrimitives/EventPrimitives.h"

#include "MuonIdHelpers/CscIdHelper.h"

#include "MuonRDO/CscRawData.h"

#include "MuonRDO/CscRawDataCollection.h"

#include "MuonRDO/CscRawDataContainer.h"

#include "MuonReadoutGeometry/CscReadoutElement.h"

#include "TrkSurfaces/Surface.h"

#include "TrkSurfaces/SurfaceBounds.h"


using namespace MuonGM;

using namespace Trk;

using namespace Muon;


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

    base_class(type, name, parent) {}


StatusCode CscRdoToCscPrepDataToolMT::initialize() {

    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;

}


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

   ATH_MSG_FATAL("ROB based decoding is not supported....");

   return StatusCode::FAILURE;

}


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

    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;

}


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

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

}


StatusCode CscRdoToCscPrepDataToolMT::decodeImpl(Muon::CscStripPrepDataContainer* outputCollection,

                                                 const CscRawDataContainer* rdoContainer,

                                                 IdentifierHash givenHashId) const {

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

    }

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

            }


            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;

}


//************** Process for all in case of Offline


StatusCode CscRdoToCscPrepDataToolMT::decodeImpl(Muon::CscStripPrepDataContainer* outputCollection,

                                                 const CscRawDataContainer* rdoContainer) const {

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

            }


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

                    }


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

                    }


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

}


ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40

ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33

ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34

ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32

ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29

CscIdHelper.h

CscRawDataCollection.h

CscRawDataContainer.h

CscRawData.h

CscRdoToCscPrepDataToolMT.h

CscReadoutElement.h

EventPrimitives.h

AmgSymMatrix
#define AmgSymMatrix(dim)
Definition EventPrimitives.h:50

data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11

lock
virtual void lock()=0
Interface to allow an object to lock itself when made const in SG.

SurfaceBounds.h

Surface.h

width
const double width
Definition TTileTripReader.cxx:24

CscRawDataCollection
Collection of CSC Raw Hits, arranged according to CSC Detector Elements Author: Ketevi A.
Definition CscRawDataCollection.h:24

CscRawDataCollection::samplingPhase
bool samplingPhase() const
Definition CscRawDataCollection.h:117

CscRawDataCollection::identifyHash
IdentifierHash identifyHash() const
Returns the OFFLINE identifier hash for this collection.
Definition CscRawDataCollection.h:110

CscRawDataCollection::identify
uint16_t identify() const
access methods
Definition CscRawDataCollection.h:107

CscRawDataCollection::numSamples
uint16_t numSamples() const
Definition CscRawDataCollection.cxx:8

CscRawDataCollection::rate
uint8_t rate() const
the rate could be 25 or 50 ns
Definition CscRawDataCollection.cxx:24

CscRawDataContainer
This container provides access to collections of CSC RDOs and a mechanism for recording them.
Definition CscRawDataContainer.h:23

CscRawData
Class to hold the electronic output for a single CSC readout channel: n sampling ADC data + the addre...
Definition CscRawData.h:21

DataVector< CscRawData >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838

DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.

DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.

DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.

DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.

IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition IdContext.h:26

IdContext::begin_index
size_type begin_index() const
Definition IdContext.h:45

IdContext::end_index
size_type end_index() const
Definition IdContext.h:46

IdentifiableContainerMT::IDC_WriteHandle
Definition IdentifiableContainerMT.h:37

IdentifiableContainerMT::const_iterator
Definition IdentifiableContainerMT.h:82

IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition IdentifiableContainerMT.h:248

IdentifiableContainerMT::indexFindPtr
virtual const T * indexFindPtr(IdentifierHash hashId) const override final
return pointer on the found entry or null if out of range using hashed index - fast version,...
Definition IdentifiableContainerMT.h:298

IdentifiableContainerMT::size
size_t size() const
Duplicate of fullSize for backwards compatability.
Definition IdentifiableContainerMT.h:209

IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition IdentifiableContainerMT.h:242

IdentifierHash
This is a "hash" representation of an Identifier.
Definition IdentifierHash.h:25

MuonGM::CscReadoutElement
Definition CscReadoutElement.h:56

MuonGM::CscReadoutElement::cathodeReadoutPitch
double cathodeReadoutPitch(int chLayer, int measuresPhi) const
Definition CscReadoutElement.cxx:147

MuonGM::CscReadoutElement::xCoordinateInTrackingFrame
double xCoordinateInTrackingFrame(const Identifier &id) const
Definition CscReadoutElement.cxx:462

MuonGM::CscReadoutElement::containsId
virtual bool containsId(const Identifier &id) const override
Definition CscReadoutElement.cxx:718

MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:51

MuonGM::MuonDetectorManager::getCscReadoutElement
const CscReadoutElement * getCscReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:237

MuonGM::MuonReadoutElement::identify
Identifier identify() const override final
Returns the ATLAS Identifier of the MuonReadOutElement.
Definition MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonReadoutElement.h:173

Muon::CscRdoToCscPrepDataToolMT::m_decodeData
Gaudi::Property< bool > m_decodeData
toggle on/off the decoding of CSC RDO into CscStripPrepData
Definition CscRdoToCscPrepDataToolMT.h:83

Muon::CscRdoToCscPrepDataToolMT::m_outputCollectionKey
SG::WriteHandleKey< Muon::CscStripPrepDataContainer > m_outputCollectionKey
CscStripPrepRawData containers.
Definition CscRdoToCscPrepDataToolMT.h:65

Muon::CscRdoToCscPrepDataToolMT::initialize
virtual StatusCode initialize() override
Definition CscRdoToCscPrepDataToolMT.cxx:24

Muon::CscRdoToCscPrepDataToolMT::m_muDetMgrKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_muDetMgrKey
Definition CscRdoToCscPrepDataToolMT.h:59

Muon::CscRdoToCscPrepDataToolMT::m_prdContainerCacheKey
SG::UpdateHandleKey< CscStripPrepDataCollection_Cache > m_prdContainerCacheKey
This is the key for the cache for the CSC PRD containers, can be empty.
Definition CscRdoToCscPrepDataToolMT.h:71

Muon::CscRdoToCscPrepDataToolMT::m_rdoContainerKey
SG::ReadHandleKey< CscRawDataContainer > m_rdoContainerKey
Definition CscRdoToCscPrepDataToolMT.h:68

Muon::CscRdoToCscPrepDataToolMT::m_cabling
ServiceHandle< CSCcablingSvc > m_cabling
Definition CscRdoToCscPrepDataToolMT.h:79

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

Muon::CscRdoToCscPrepDataToolMT::provideEmptyContainer
virtual StatusCode provideEmptyContainer(const EventContext &ctx) const override
Definition CscRdoToCscPrepDataToolMT.cxx:42

Muon::CscRdoToCscPrepDataToolMT::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition CscRdoToCscPrepDataToolMT.h:62

Muon::CscRdoToCscPrepDataToolMT::CscRdoToCscPrepDataToolMT
CscRdoToCscPrepDataToolMT(const std::string &type, const std::string &name, const IInterface *parent)
Definition CscRdoToCscPrepDataToolMT.cxx:20

Muon::CscRdoToCscPrepDataToolMT::m_cscRdoDecoderTool
ToolHandle< ICSC_RDO_Decoder > m_cscRdoDecoderTool
Definition CscRdoToCscPrepDataToolMT.h:77

Muon::CscRdoToCscPrepDataToolMT::decode
virtual StatusCode decode(const EventContext &ctx, const std::vector< IdentifierHash > &givenIdhs) const override
Definition CscRdoToCscPrepDataToolMT.cxx:63

Muon::CscRdoToCscPrepDataToolMT::m_cscCalibTool
ToolHandle< ICscCalibTool > m_cscCalibTool
CSC Calibration tools.
Definition CscRdoToCscPrepDataToolMT.h:76

Muon::CscStripPrepData
Class representing the raw data of one CSC strip (for clusters look at Muon::CscPrepData).
Definition CscStripPrepData.h:40

Muon::CscStripPrepData::set_samplingPhase
void set_samplingPhase()
set the sampling phase
Definition CscStripPrepData.h:182

SG::ReadCondHandle
Definition ReadCondHandle.h:40

SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition ReadCondHandle.h:67

SG::UpdateHandle
Definition UpdateHandle.h:91

SG::WriteHandle
Definition StoreGate/StoreGate/WriteHandle.h:73

SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.

SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.

Trk::PrepRawData::identify
Identifier identify() const
return the identifier

Trk::PrepRawData::setHashAndIndex
void setHashAndIndex(unsigned short collHash, unsigned short objIndex)
TEMP for testing: might make some classes friends later ...

Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition EventPrimitives.h:27

Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition GeoPrimitives.h:48

Identifier
Definition IdentifierFieldParser.cxx:14

MuonGM
Ensure that the Athena extensions are properly loaded.
Definition GeoMuonHits.h:27

Muon
NRpcCablingAlg reads raw condition data and writes derived condition data to the condition store.
Definition TrackSystemController.h:45

Muon::CscStripPrepDataContainer
MuonPrepDataContainerT< CscStripPrepData > CscStripPrepDataContainer
Definition MuonPrepDataContainer.h:98

SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:269

Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition FakeTrackBuilder.h:9

Trk::PrepRawDataType::CscStripPrepData
@ CscStripPrepData
Definition PrepRawData.h:47

type