Muon::MdtRdoToPrepDataToolMT::ConvCache Struct Reference

Helper struct to parse the event data around the tool. More...

#include <MdtRdoToPrepDataToolMT.h>

Collaboration diagram for Muon::MdtRdoToPrepDataToolMT::ConvCache:

Public Member Functions
	ConvCache (const Muon::IMuonIdHelperSvc *idHelperSvc)
MdtPrepDataCollection *	createCollection (const Identifier &id)
	Creates a new MdtPrepDataCollection, if it's neccessary and also possible.
StatusCode	finalize (MsgStream &msg)
	Copy the non-empty collections into the created prd container.

Public Attributes
Muon::MdtPrepDataContainer *	legacyPrd {nullptr}
xAOD::MdtDriftCircleContainer *	xAODPrd {nullptr}
xAOD::MdtTwinDriftCircleContainer *	xAODTwinPrd {nullptr}
const Muon::IMuonIdHelperSvc *	m_idHelperSvc {nullptr}
const MuonGM::MuonDetectorManager *	legacyDetMgr {nullptr}
	Detector manager from the conditions store.
const MuonGMR4::MuonDetectorManager *	r4DetMgr {nullptr}
	Detector manger from R4.
const ActsTrk::GeometryContext *	gctx {nullptr}
	Acts Geometry context.
const TwinTubeMap *	twinTubeMap {nullptr}
	Pointer to the map having the mapping of twin tube pairs.
bool	isValid {false}
	Flag set to indicate that the complete validation was successful.
std::vector< std::unique_ptr< MdtPrepDataCollection > >	addedCols {}

Detailed Description

Helper struct to parse the event data around the tool.

Definition at line 65 of file MdtRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

ConvCache()

Muon::MdtRdoToPrepDataToolMT::ConvCache::ConvCache

(

const Muon::IMuonIdHelperSvc *

idHelperSvc

)

Definition at line 61 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                     :
        m_idHelperSvc{idHelperSvc} {
        addedCols.resize(m_idHelperSvc->mdtIdHelper().module_hash_max());
    }

Member Function Documentation

createCollection()

MdtPrepDataCollection * Muon::MdtRdoToPrepDataToolMT::ConvCache::createCollection

(

const Identifier &

id

)

Creates a new MdtPrepDataCollection, if it's neccessary and also possible.

Nullptr is returned if the collection cannot be modified

Definition at line 66 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                        {
 
        IdentifierHash mdtHashId = m_idHelperSvc->moduleHash(elementId);
 
        std::unique_ptr<MdtPrepDataCollection>& coll {addedCols[mdtHashId]};
        if (!coll) {
            coll = std::make_unique<MdtPrepDataCollection>(mdtHashId);
            coll->setIdentifier(m_idHelperSvc->chamberId(elementId));
        }        
        return coll.get();
    }

finalize()

StatusCode Muon::MdtRdoToPrepDataToolMT::ConvCache::finalize

(

MsgStream &

msg

)

Copy the non-empty collections into the created prd container.

Fill the prepdata objects just at this stage

The prepdata represents an actual drift circle

That method is kind of depreciated but needed for the Acts conversion test..

Invalid drift circles have a covariance as large as the inner radius assigned

Ordinary 1D circle

Definition at line 77 of file MdtRdoToPrepDataToolMT.cxx.

                                                                       {
        const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
 
        for (unsigned int moduleHash =0; moduleHash < addedCols.size(); ++moduleHash) {
            std::unique_ptr<MdtPrepDataCollection>& toInsert{addedCols[moduleHash]};
            if (!toInsert || toInsert->empty()) continue;
            if (xAODPrd) {
                std::vector<const MdtPrepData*> sortMe{toInsert->begin(), toInsert->end()};
                std::ranges::sort(sortMe, IdentifierByDetElSorter{m_idHelperSvc});
                for (const MdtPrepData* prd : sortMe) {
                    const Identifier prdId{prd->identify()};
                    xAOD::MdtDriftCircle* dc{nullptr};
                    if (!xAODTwinPrd|| !twinTubeMap || twinTubeMap->twinId(prdId) == prdId ||
                        prd->dimension() == 1) {
                        dc = xAODPrd->push_back(std::make_unique<xAOD::MdtDriftCircle>());
                    } else {
                        dc = xAODTwinPrd->push_back(std::make_unique<xAOD::MdtTwinDriftCircle>());                       
                    }
                    dc->setIdentifier(prdId.get_compact());
                    dc->setTdc(prd->tdc());
                    dc->setAdc(prd->adc());
                    dc->setTube(idHelper.tube(prdId));
                    dc->setLayer(idHelper.tubeLayer(prdId));
                    dc->setStatus(prd->status());
                    if (r4DetMgr){
                        dc->setReadoutElement(r4DetMgr->getMdtReadoutElement(prdId));
                    }
                    const IdentifierHash detHash{m_idHelperSvc->detElementHash(prdId)};
                    float driftRadius{0.f}, driftCov{0.f};
                    if (prd->status() == MdtDriftCircleStatus::MdtStatusDriftTime) {
                        driftRadius = prd->localPosition().x();
                        driftCov = prd->localCovariance()(0,0);
                    } else {
                        const float maxR = r4DetMgr ? dc->readoutElement()->innerTubeRadius() 
                                                    : prd->detectorElement()->innerTubeRadius();
                        driftCov = std::pow(maxR, 2);
                    }
                    if (dc->numDimensions() == 1) {
                        xAOD::MeasVector<1> locPos{driftRadius};
                        xAOD::MeasMatrix<1> locCov{driftCov};
                        dc->setMeasurement<1>(detHash, std::move(locPos), std::move(locCov));
                    } else {
                        xAOD::MeasMatrix<2> locCov{xAOD::MeasMatrix<2>::Identity()};
                        locCov(Trk::locR, Trk::locR) = prd->localCovariance()(Trk::locR, Trk::locR);
                        locCov(Trk::locZ, Trk::locZ) = prd->localCovariance()(Trk::locZ, Trk::locZ);
                        dc->setMeasurement<2>(detHash, xAOD::toStorage(prd->localPosition()), std::move(locCov));
                        auto* twinDC{static_cast<xAOD::MdtTwinDriftCircle*>(dc)};
                        auto* twinPRD{static_cast<const MdtTwinPrepData*>(prd)};
                        twinDC->setTwinAdc(twinPRD->adcTwin());
                        twinDC->setTwinTdc(twinPRD->tdcTwin());
                        const Identifier twinId = twinTubeMap->twinId(prdId);
                        twinDC->setTwinTube(idHelper.tube(twinId));
                        twinDC->setTwinLayer(idHelper.tubeLayer(twinId));
                    }
                }
            }
            MdtPrepDataContainer::IDC_WriteHandle lock = legacyPrd->getWriteHandle(moduleHash);
            if (lock.addOrDelete(std::move(toInsert)).isFailure()) {
                msg << MSG::ERROR << " Failed to add prep data collection " << moduleHash << endmsg;
                return StatusCode::FAILURE;
            }
        }
        if (xAODPrd) {
            xAODPrd->lock();
        }
        if (xAODTwinPrd) {
            xAODTwinPrd->lock();
        }
        return StatusCode::SUCCESS;
    }

Member Data Documentation

addedCols

std::vector<std::unique_ptr<MdtPrepDataCollection> > Muon::MdtRdoToPrepDataToolMT::ConvCache::addedCols {}

Definition at line 90 of file MdtRdoToPrepDataToolMT.h.

{};

gctx

const ActsTrk::GeometryContext* Muon::MdtRdoToPrepDataToolMT::ConvCache::gctx {nullptr}

Acts Geometry context.

Definition at line 84 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

isValid

bool Muon::MdtRdoToPrepDataToolMT::ConvCache::isValid {false}

Flag set to indicate that the complete validation was successful.

Definition at line 89 of file MdtRdoToPrepDataToolMT.h.

{false};

legacyDetMgr

const MuonGM::MuonDetectorManager* Muon::MdtRdoToPrepDataToolMT::ConvCache::legacyDetMgr {nullptr}

Detector manager from the conditions store.

Definition at line 80 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

legacyPrd

Muon::MdtPrepDataContainer* Muon::MdtRdoToPrepDataToolMT::ConvCache::legacyPrd {nullptr}

Definition at line 74 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

m_idHelperSvc

const Muon::IMuonIdHelperSvc* Muon::MdtRdoToPrepDataToolMT::ConvCache::m_idHelperSvc {nullptr}

Definition at line 78 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

r4DetMgr

const MuonGMR4::MuonDetectorManager* Muon::MdtRdoToPrepDataToolMT::ConvCache::r4DetMgr {nullptr}

Detector manger from R4.

Definition at line 82 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

twinTubeMap

const TwinTubeMap* Muon::MdtRdoToPrepDataToolMT::ConvCache::twinTubeMap {nullptr}

Pointer to the map having the mapping of twin tube pairs.

Definition at line 86 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

xAODPrd

xAOD::MdtDriftCircleContainer* Muon::MdtRdoToPrepDataToolMT::ConvCache::xAODPrd {nullptr}

Definition at line 75 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

xAODTwinPrd

xAOD::MdtTwinDriftCircleContainer* Muon::MdtRdoToPrepDataToolMT::ConvCache::xAODTwinPrd {nullptr}

Definition at line 76 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

---

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

• MdtRdoToPrepDataToolMT.h
• MdtRdoToPrepDataToolMT.cxx