Tool to produce MDT PRDs for Run 4. More...

#include <MdtRdoToMdtPrepDataTool.h>

Inheritance diagram for MuonR4::MdtRdoToMdtPrepDataTool:

Collaboration diagram for MuonR4::MdtRdoToMdtPrepDataTool:

Classes
struct	HandleCache
	Helper cache to carry the data containers needed for the dedcoding around. More...

Public Member Functions
	~MdtRdoToMdtPrepDataTool ()=default
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	decode (const EventContext &ctx, const std::vector< IdentifierHash > &idVect) const override
	Decode method - declared in Muon::IMuonRdoToPrepDataTool.
virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override
virtual StatusCode	provideEmptyContainer (const EventContext &ctx) const override

Protected Types
using	DigitPtr_t = std::unique_ptr<MdtDigit>
	Abrivate the digit pointer.
using	TwinDigit_t = std::array<DigitPtr_t, 2>
using	DigitVec_t = std::vector<DigitPtr_t>
	Store the digits per chamber to ensure sorting.

Protected Member Functions
HandleCache	setupHandleCache (const EventContext &ctx) const

Private Member Functions
void	processDigit (const EventContext &ctx, DigitPtr_t &&digit, HandleCache &hCache) const
	Process a digit to be converted to a 1D measurement.
void	processDigit (const EventContext &ctx, TwinDigit_t &&digit, HandleCache &cache) const
StatusCode	processCsm (const EventContext &ctx, const MdtCsm *rdoColl, HandleCache &hCache) const
StatusCode	processCsmTwin (const EventContext &ctx, const MdtCsm *rdoColl, HandleCache &hCache) const
StatusCode	processPRDHashes (const EventContext &ctx, const std::vector< IdentifierHash > &chamberHashInRobs, HandleCache &hCache) const

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	tools and services
ToolHandle< IMdtCalibrationTool >	m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}
ToolHandle< Muon::IMDT_RDO_Decoder >	m_mdtDecoder {this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"}
const MuonGMR4::MuonDetectorManager *	m_detMgrR4 {nullptr}
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "Stored alignment"}
SG::ReadHandleKey< MdtCsmContainer >	m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}
SG::ReadCondHandleKey< Muon::TwinTubeMap >	m_twinTubeKey {this, "TwinTubeKey", "MdtTwinTubeMap"}
SG::ReadCondHandleKey< MuonMDT_CablingMap >	m_cablingKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}
Gaudi::Property< int >	m_adcCut {this, "AdcCut", 50, "Minimal cut on the adc to convert it into a prepdata object"}
Gaudi::Property< bool >	m_calibratePrepData {this, "CalibratePrepData", true}
	toggle on/off calibration of MdtPrepData
Gaudi::Property< bool >	m_useTwin {this, "UseTwin", true}
SG::WriteHandleKey< xAOD::MdtDriftCircleContainer >	m_xAODKey {this, "xAODKey", "xMdtDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}
SG::WriteHandleKey< xAOD::MdtTwinDriftCircleContainer >	m_xAODTwinKey {this, "xAODTwinKey", "xMdtTwinDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

Detailed Description

Tool to produce MDT PRDs for Run 4.

Definition at line 38 of file MdtRdoToMdtPrepDataTool.h.

Member Typedef Documentation

◆ DigitPtr_t

using MuonR4::MdtRdoToMdtPrepDataTool::DigitPtr_t = std::unique_ptr<MdtDigit>

protected

Abrivate the digit pointer.

Definition at line 55 of file MdtRdoToMdtPrepDataTool.h.

◆ DigitVec_t

using MuonR4::MdtRdoToMdtPrepDataTool::DigitVec_t = std::vector<DigitPtr_t>

protected

Store the digits per chamber to ensure sorting.

Definition at line 58 of file MdtRdoToMdtPrepDataTool.h.

◆ TwinDigit_t

using MuonR4::MdtRdoToMdtPrepDataTool::TwinDigit_t = std::array<DigitPtr_t, 2>

protected

Definition at line 56 of file MdtRdoToMdtPrepDataTool.h.

Constructor & Destructor Documentation

◆ ~MdtRdoToMdtPrepDataTool()

MuonR4::MdtRdoToMdtPrepDataTool::~MdtRdoToMdtPrepDataTool ( )

default

default destructor

Member Function Documentation

◆ decode() [1/2]

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::decode	(	const EventContext &	ctx,
		const std::vector< IdentifierHash > &	idVect ) const

overridevirtual

Decode method - declared in Muon::IMuonRdoToPrepDataTool.

Construct the hashes from the existing RDOs

Definition at line 25 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                                                     {
        ATH_MSG_DEBUG("MdtRdoToMdtPrepDataTool for " << idVect.size() << " offline collections called");
        HandleCache cache = setupHandleCache(ctx);
        if(!cache.isValid){
            ATH_MSG_ERROR("Unable to setup valid HandleCache object");
            return StatusCode::FAILURE;
        }
        // seeded or unseeded decoding
        if (!idVect.empty()) {
            ATH_CHECK(processPRDHashes(ctx, idVect, cache));
        } else {
            std::vector<IdentifierHash> rdoHashes{};
            const MdtCsmContainer* rdoContainer{nullptr};
            ATH_CHECK(SG::get(rdoContainer, m_rdoContainerKey, ctx));
 
            if (rdoContainer->empty()) {
                return StatusCode::SUCCESS;
            }
            rdoHashes.reserve(rdoContainer->size());
            for (const MdtCsm* csm : *rdoContainer) { 
                rdoHashes.push_back(csm->identifyHash());
            }
            ATH_CHECK(processPRDHashes(ctx, rdoHashes, cache));
        }
        return StatusCode::SUCCESS;
    }

◆ decode() [2/2]

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::decode	(	const EventContext &	ctx,
		const std::vector< uint32_t > &	robIds ) const

overridevirtual

Definition at line 53 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                                               {
        const MuonMDT_CablingMap* cablingMap{nullptr};
        ATH_CHECK(SG::get(cablingMap, m_cablingKey, ctx));
        return decode(ctx, cablingMap->getMultiLayerHashVec(robIds, msgStream()));
    }

◆ initialize()

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 10 of file MdtRdoToMdtPrepDataTool.cxx.

                                                  {
        // initialize handle keys
        ATH_CHECK(m_calibrationTool.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_mdtDecoder.retrieve());
        ATH_CHECK(detStore()->retrieve(m_detMgrR4));
        ATH_CHECK(m_twinTubeKey.initialize(m_useTwin));
        ATH_CHECK(m_rdoContainerKey.initialize());
        ATH_CHECK(m_cablingKey.initialize());
        ATH_CHECK(m_xAODKey.initialize());
        ATH_CHECK(m_xAODTwinKey.initialize(m_useTwin));
        ATH_CHECK(m_geoCtxKey.initialize());
        return StatusCode::SUCCESS;
    }

◆ processCsm()

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::processCsm	(	const EventContext &	ctx,
		const MdtCsm *	rdoColl,
		HandleCache &	hCache ) const

private

MDT hit context

Definition at line 186 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                                                           {
        const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
        // first handle the case of twin tubes
        if (m_useTwin && cache.twinTubeMap->isTwinTubeLayer(rdoColl->identify())) {
            return processCsmTwin(ctx, rdoColl, cache);
        }
        ATH_MSG_DEBUG(" ***************** Start of processCsm");
        // initialise write handle
          uint16_t subdetId = rdoColl->SubDetId();
        uint16_t mrodId = rdoColl->MrodId();
        uint16_t csmId = rdoColl->CsmId();
        ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toString(id_helper.parentID(rdoColl->identify())) << " subdetId/ mrodId/ csmId = " << subdetId << " / "
                                        << mrodId << " / " << csmId);
 
        // for each Csm, loop over AmtHit, converter AmtHit to digit
        // retrieve/create digit collection, and insert digit into collection
        for (const MdtAmtHit* amtHit : *rdoColl) {          
            ATH_MSG_VERBOSE("Amt Hit, tdcId = " << amtHit->tdcId());
            DigitPtr_t newDigit{m_mdtDecoder->getDigit(ctx, *amtHit, subdetId, mrodId, csmId)};
            if (!newDigit) {
                ATH_MSG_WARNING("Found issue MDT RDO decoder for subdetId/mrodId/csmId "
                                << subdetId << "/" << mrodId << "/" << csmId << " amtHit channelId/tdcId =" << amtHit->channelId() << "/"
                                << amtHit->tdcId());
                continue;
            }
            const IdentifierHash detHash = m_idHelperSvc->detElementHash(newDigit->identify());
            cache.digitsForCnv[detHash].push_back(std::move(newDigit));
        }
        return StatusCode::SUCCESS;
    }

◆ processCsmTwin()

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::processCsmTwin	(	const EventContext &	ctx,
		const MdtCsm *	rdoColl,
		HandleCache &	hCache ) const

private

check for the twin tube id

Definition at line 218 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                                                               {
        ATH_MSG_DEBUG(" ***************** Start of processCsmTwin");
        ATH_MSG_DEBUG(" Number of AmtHit in this Csm " << rdoColl->size());
 
        uint16_t subdetId = rdoColl->SubDetId();
        uint16_t mrodId = rdoColl->MrodId();
        uint16_t csmId = rdoColl->CsmId();
        ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toStringChamber(rdoColl->identify()) 
                                        << " subdetId/ mrodId/ csmId = " << rdoColl->SubDetId()
                                        << " / " << rdoColl->MrodId() << " / " << rdoColl->CsmId());
 
        // for each Csm, loop over AmtHit, converter AmtHit to digit
        // retrieve/create digit collection, and insert digit into collection        
        std::unordered_map<Identifier, TwinDigit_t> mdtDigitColl{};
        
        for (const MdtAmtHit* amtHit : *rdoColl) {
            DigitPtr_t newDigit{m_mdtDecoder->getDigit(ctx, *amtHit, subdetId, mrodId, csmId)};
 
            if (!newDigit) {
                ATH_MSG_WARNING("Error in MDT RDO decoder for subdetId/mrodId/csmId "
                                << subdetId << "/" << mrodId << "/" << csmId << " amtHit channelId/tdcId =" << amtHit->channelId() << "/"
                                << amtHit->tdcId());
                continue;
            } else if (newDigit->isMasked()) {
                continue;
            }
            std::array<DigitPtr_t, 2> & moveTo = mdtDigitColl[newDigit->identify()];
            if (!moveTo[0]) {
                moveTo[0] = std::move(newDigit);
            } else if (!moveTo[1]) {
                moveTo[1] = std::move(newDigit);
            } else {
                ATH_MSG_VERBOSE(" TWIN TUBES: found a tertiary hit in a twin tube in one RdoCollection for "
                            << m_idHelperSvc->toString(newDigit->identify()) << " with adc  = " << newDigit->adc()
                            << "  tdc = " << newDigit->tdc());
            }
        }  // end for-loop over rdoColl
 
        for (auto &[id,  digits] : mdtDigitColl) {
            // get the twin hits from mdtDigitColl
            const Identifier twinId = cache.twinTubeMap->twinId(id);
            const IdentifierHash detHash = m_idHelperSvc->detElementHash(id);
            assert(detHash == m_idHelperSvc->detElementHash(twinId));
            if (id != twinId) {
                std::array<DigitPtr_t, 2>& twinDigits = mdtDigitColl[twinId];
                for (std::size_t k = 0 ; k < 2; ++k) {
                    if (digits[k] && twinDigits[k]) {
                        if (digits[k]->identify() > twinDigits[k]->identify()) {
                            std::swap(digits[k], twinDigits[k]);
                        }
                        cache.twinDigitsForCnv[detHash].push_back(std::array{std::move(digits[k]), std::move(twinDigits[k])});
                    } else{
                        DigitVec_t& outDigits = cache.digitsForCnv[detHash];
                        if (digits[k]) { outDigits.push_back(std::move(digits[k])); } 
                        if (twinDigits[k]) { outDigits.push_back(std::move(twinDigits[k])); }
                    }
                }
            }
        }
        return StatusCode::SUCCESS;
    }

◆ processDigit() [1/2]

void MuonR4::MdtRdoToMdtPrepDataTool::processDigit	(	const EventContext &	ctx,
		DigitPtr_t &&	digit,
		HandleCache &	hCache ) const

private

Process a digit to be converted to a 1D measurement.

Parameters

ctx	EventContext to access the calibration constants
digit	Pointer to the digit for conversion
hCache	Data cache handling the container to which the measurement is appended

Definition at line 74 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                          {
        const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
        Identifier channelId = digit->identify();
        const MuonGMR4::MdtReadoutElement* reEle = m_detMgrR4->getMdtReadoutElement(channelId);
        bool isValidChannel = reEle->isValid(reEle->measurementHash(channelId));
 
        if (digit->isMasked() || !isValidChannel) {
            return;
        }
        // Rescale ADC/TDC of chambers using HPTDC digitization chip
        // Must create a new digit from the old one, because MdtDigit has no methods to set ADC/TDC
        if (m_idHelperSvc->hasHPTDC(channelId)) {
            digit->setAdc(digit->adc() / 4);
            digit->setTdc(digit->tdc() / 4);
        }
        // if ADC cut too small, skip 
        if(digit->adc() < m_adcCut){
            return;
        }
 
        // calibration
        const MdtCalibInput calibIn = MdtCalibInput{*digit, *m_detMgrR4, *hCache.gctx};
        const MdtCalibOutput calibResult{m_calibrationTool->calibrate(ctx, calibIn, false)};
 
        // copying over create prep data over
        // if it doesn't match adc cut, skip!
        if(calibResult.status() == MdtDriftCircleStatus::MdtStatusUnDefined) {
            ATH_MSG_VERBOSE("Do not create calib hit for "<<m_idHelperSvc->toString(calibIn.identify())
                            <<", adc: "<<calibIn.adc()<<" vs. "<<m_adcCut<<", calibration bailed out "
                            <<(calibResult.status() == MdtDriftCircleStatus::MdtStatusUnDefined? "si": "no"));
            return;
        }
        ATH_MSG_VERBOSE("Calibrated prepdata "<<m_idHelperSvc->toString(calibIn.identify())
                        <<std::endl<<calibIn<<std::endl<<calibResult);
        double cov{0.}, driftRadius{0.};
        if (calibResult.status() == MdtDriftCircleStatus::MdtStatusDriftTime){
            driftRadius = calibResult.driftRadius();
            cov = Acts::square(calibResult.driftRadiusUncert());
        } else {
          cov = Acts::square(reEle->innerTubeRadius());
        }
 
        // setting things
        xAOD::MdtDriftCircle* dc = hCache.prdContainer->push_back(std::make_unique<xAOD::MdtDriftCircle>());
        const Identifier& id = calibIn.identify();
        dc->setTdc(calibIn.tdc());
        dc->setAdc(calibIn.adc());
        dc->setTube(id_helper.tube(id));
        dc->setLayer(id_helper.tubeLayer(id));
        dc->setStatus(calibResult.status());
        dc->setReadoutElement(reEle);
 
        xAOD::MeasVector<1> locPos{driftRadius};
        xAOD::MeasMatrix<1> locCov{cov};
        dc->setMeasurement<1>(reEle->identHash(), 
                              std::move(locPos), 
                              std::move(locCov));
        return;
    }

◆ processDigit() [2/2]

void MuonR4::MdtRdoToMdtPrepDataTool::processDigit	(	const EventContext &	ctx,
		TwinDigit_t &&	digit,
		HandleCache &	cache ) const

private

Definition at line 135 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                         {
        ATH_MSG_VERBOSE("Twin digit calibration "<<m_idHelperSvc->toString(digit[0]->identify())
            <<", tdc: "<<digit[0]->tdc()<<", adc: "<<digit[0]->adc()<<" -- "
            <<m_idHelperSvc->toString(digit[1]->identify())
            <<", tdc: "<<digit[1]->tdc()<<", adc: "<<digit[1]->adc());
        MdtCalibInput mdtCalib1st = MdtCalibInput{*digit[0], *m_detMgrR4, *cache.gctx};
        MdtCalibInput mdtCalib2nd = MdtCalibInput{*digit[1], *m_detMgrR4, *cache.gctx};
                
        const MdtCalibTwinOutput twinCalib = m_calibrationTool->calibrateTwinTubes(ctx, 
                                                                                   std::move(mdtCalib1st), 
                                                                                   std::move(mdtCalib2nd));
 
        if (twinCalib.primaryAdc() < m_adcCut) {
            ATH_MSG_VERBOSE("Do not create calib hit for "<<m_idHelperSvc->toString(twinCalib.primaryID())
                <<", adc: "<<twinCalib.primaryAdc()<<" vs. "<<m_adcCut<<", calibration bailed out "
                <<(twinCalib.primaryStatus() == MdtDriftCircleStatus::MdtStatusUnDefined? "si": "no"));
           
            return;
        }
        Amg::Vector2D hitPos{twinCalib.primaryDriftR(), twinCalib.locZ()};
        AmgSymMatrix(2) cov{AmgSymMatrix(2)::Identity()};
        cov(0, 0) = Acts::square(twinCalib.uncertPrimaryR());
        cov(1, 1) = Acts::square(twinCalib.sigmaZ() );
        const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();         
        const MuonGMR4::MdtReadoutElement* descriptor = mdtCalib1st.decriptor();
        xAOD::MdtTwinDriftCircle* dc = cache.prdTwinContainer->push_back(std::make_unique<xAOD::MdtTwinDriftCircle>());
 
        const Identifier id = twinCalib.primaryID();
        const Identifier twin_id = twinCalib.twinID();
        // record things into xAOD
        dc->setTdc(twinCalib.primaryTdc());
        dc->setAdc(twinCalib.primaryAdc());
        dc->setTwinTdc(twinCalib.twinTdc());
        dc->setTwinAdc(twinCalib.twinAdc());
        dc->setTube(id_helper.tube(id));
        dc->setLayer(id_helper.tubeLayer(id));
        dc->setTwinTube(id_helper.tube(twin_id));
        dc->setTwinLayer(id_helper.tubeLayer(twin_id));
        dc->setStatus(twinCalib.primaryStatus());
        dc->setReadoutElement(descriptor);
        dc->setMeasurement<2>(descriptor->identHash(), 
                              xAOD::toStorage(hitPos), 
                              xAOD::toStorage(cov));
            
        ATH_MSG_VERBOSE(" MADE A 2D TWINPREPDATA " << m_idHelperSvc->toString(twinCalib.primaryID()) << " & "
                        << m_idHelperSvc->toString(twinCalib.twinID()) << " "<<twinCalib);
        
        ATH_MSG_VERBOSE("local pos center tube w/ TWIN INFO "<<Amg::toString(twinCalib.locZ() * Amg::Vector3D::UnitZ(), 2));
    }

◆ processPRDHashes()

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::processPRDHashes	(	const EventContext &	ctx,
		const std::vector< IdentifierHash > &	chamberHashInRobs,
		HandleCache &	hCache ) const

private

Definition at line 280 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                  {
        // looping through each chamber
        const MdtCsmContainer* rdoContainer{nullptr};
        ATH_CHECK(SG::get(rdoContainer, m_rdoContainerKey, ctx));
        if (rdoContainer->empty()) {
             ATH_MSG_DEBUG("The container is empty");
             return StatusCode::SUCCESS;
        }
        for (const IdentifierHash& hash : multiLayerHashInRobs) {
            const MdtCsm* rdoColl = rdoContainer->indexFindPtr(hash);
            if(!rdoColl){
                ATH_MSG_DEBUG("The rdo container does not have the hash " << hash);
                continue;
            }
            ATH_CHECK(processCsm(ctx, rdoColl, cache));
        }
        for (DigitVec_t& digitPerStation : cache.digitsForCnv) {
            std::ranges::for_each(digitPerStation, 
                [&](DigitPtr_t& digit){
                    processDigit(ctx,std::move(digit),cache);
            });
        }
        for (auto& [hash, digitPerStation] : cache.twinDigitsForCnv) {
            std::ranges::for_each(digitPerStation, 
                [&](TwinDigit_t& digit){
                    processDigit(ctx,std::move(digit),cache);
            });
        }
        return StatusCode::SUCCESS;
    }

◆ provideEmptyContainer()

StatusCode MuonR4::MdtRdoToMdtPrepDataTool::provideEmptyContainer ( const EventContext & ctx ) const

overridevirtual

Definition at line 59 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                           {
        return setupHandleCache(ctx).isValid ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

◆ setupHandleCache()

MdtRdoToMdtPrepDataTool::HandleCache MuonR4::MdtRdoToMdtPrepDataTool::setupHandleCache ( const EventContext & ctx ) const

protected

Definition at line 64 of file MdtRdoToMdtPrepDataTool.cxx.

                                                                                                              {
        HandleCache cache{};
        cache.digitsForCnv.resize(m_idHelperSvc->mdtIdHelper().detectorElement_hash_max());
        cache.isValid = cache.prdContainer.record(m_xAODKey, ctx).isSuccess() &&
                        cache.prdTwinContainer.record(m_xAODTwinKey, ctx).isSuccess() &&
                        SG::get(cache.gctx, m_geoCtxKey, ctx).isSuccess() &&
                        SG::get(cache.twinTubeMap, m_twinTubeKey, ctx).isSuccess();
        return cache;
    }

Member Data Documentation

◆ m_adcCut

Gaudi::Property<int> MuonR4::MdtRdoToMdtPrepDataTool::m_adcCut {this, "AdcCut", 50, "Minimal cut on the adc to convert it into a prepdata object"}

private

Definition at line 119 of file MdtRdoToMdtPrepDataTool.h.

119{this, "AdcCut", 50, "Minimal cut on the adc to convert it into a prepdata object"};

◆ m_cablingKey

SG::ReadCondHandleKey<MuonMDT_CablingMap> MuonR4::MdtRdoToMdtPrepDataTool::m_cablingKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}

private

Definition at line 116 of file MdtRdoToMdtPrepDataTool.h.

116{this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"};

◆ m_calibratePrepData

Gaudi::Property<bool> MuonR4::MdtRdoToMdtPrepDataTool::m_calibratePrepData {this, "CalibratePrepData", true}

private

toggle on/off calibration of MdtPrepData

Definition at line 120 of file MdtRdoToMdtPrepDataTool.h.

120{this, "CalibratePrepData", true};

◆ m_calibrationTool

ToolHandle<IMdtCalibrationTool> MuonR4::MdtRdoToMdtPrepDataTool::m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}

private

Definition at line 106 of file MdtRdoToMdtPrepDataTool.h.

106{this, "CalibrationTool", "MdtCalibrationTool"};

◆ m_detMgrR4

const MuonGMR4::MuonDetectorManager* MuonR4::MdtRdoToMdtPrepDataTool::m_detMgrR4 {nullptr}

private

Definition at line 108 of file MdtRdoToMdtPrepDataTool.h.

108{nullptr};

◆ m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::MdtRdoToMdtPrepDataTool::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "Stored alignment"}

private

Definition at line 111 of file MdtRdoToMdtPrepDataTool.h.

111{this, "AlignmentKey", "ActsAlignment", "Stored alignment"};

◆ m_idHelperSvc

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

private

tools and services

Definition at line 105 of file MdtRdoToMdtPrepDataTool.h.

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

◆ m_mdtDecoder

ToolHandle<Muon::IMDT_RDO_Decoder> MuonR4::MdtRdoToMdtPrepDataTool::m_mdtDecoder {this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"}

private

Definition at line 107 of file MdtRdoToMdtPrepDataTool.h.

107{this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"};

◆ m_rdoContainerKey

SG::ReadHandleKey<MdtCsmContainer> MuonR4::MdtRdoToMdtPrepDataTool::m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}

private

Definition at line 112 of file MdtRdoToMdtPrepDataTool.h.

112{this, "RDOContainer", "MDTCSM"};

◆ m_twinTubeKey

SG::ReadCondHandleKey<Muon::TwinTubeMap> MuonR4::MdtRdoToMdtPrepDataTool::m_twinTubeKey {this, "TwinTubeKey", "MdtTwinTubeMap"}

private

Definition at line 115 of file MdtRdoToMdtPrepDataTool.h.

115{this, "TwinTubeKey", "MdtTwinTubeMap"};

◆ m_useTwin

Gaudi::Property<bool> MuonR4::MdtRdoToMdtPrepDataTool::m_useTwin {this, "UseTwin", true}

private

Definition at line 121 of file MdtRdoToMdtPrepDataTool.h.

121{this, "UseTwin", true};

◆ m_xAODKey

SG::WriteHandleKey<xAOD::MdtDriftCircleContainer> MuonR4::MdtRdoToMdtPrepDataTool::m_xAODKey {this, "xAODKey", "xMdtDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

private

Definition at line 123 of file MdtRdoToMdtPrepDataTool.h.

123{this, "xAODKey", "xMdtDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

◆ m_xAODTwinKey

SG::WriteHandleKey<xAOD::MdtTwinDriftCircleContainer> MuonR4::MdtRdoToMdtPrepDataTool::m_xAODTwinKey {this, "xAODTwinKey", "xMdtTwinDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"}

private

Definition at line 124 of file MdtRdoToMdtPrepDataTool.h.

124{this, "xAODTwinKey", "xMdtTwinDriftCircles", "If empty, do not produce xAOD, otherwise this is the key of the output xAOD MDT PRD container"};

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

Classes

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DigitPtr_t

◆ DigitVec_t

◆ TwinDigit_t

Constructor & Destructor Documentation

◆ ~MdtRdoToMdtPrepDataTool()

Member Function Documentation

◆ decode() [1/2]

◆ decode() [2/2]

◆ initialize()

◆ processCsm()

◆ processCsmTwin()

◆ processDigit() [1/2]

◆ processDigit() [2/2]

◆ processPRDHashes()

◆ provideEmptyContainer()

◆ setupHandleCache()

Member Data Documentation

◆ m_adcCut

◆ m_cablingKey

◆ m_calibratePrepData

◆ m_calibrationTool

◆ m_detMgrR4

◆ m_geoCtxKey

◆ m_idHelperSvc

◆ m_mdtDecoder

◆ m_rdoContainerKey

◆ m_twinTubeKey

◆ m_useTwin

◆ m_xAODKey

◆ m_xAODTwinKey