Muon::MdtRdoToPrepDataToolMT Class Reference

Tool to produce MDT PRDs. More...

#include <MdtRdoToPrepDataToolMT.h>

Inheritance diagram for Muon::MdtRdoToPrepDataToolMT:

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

Public Member Functions
virtual	~MdtRdoToPrepDataToolMT ()=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	provideEmptyContainer (const EventContext &ctx) const override
virtual StatusCode	decode (const EventContext &ctx, const std::vector< uint32_t > &robIds) const override

Protected Member Functions
void	printPrepDataImpl (const Muon::MdtPrepDataContainer *mdtPrepDataContainer) const
Muon::MdtDriftCircleStatus	getMdtTwinPosition (const MdtDigit &prompt_digit, const MdtDigit &twin_digit, double &radius, double &errRadius, double &zTwin, double &errZTwin, bool &twinIsPrompt) const
	method to get the twin tube 2nd coordinate
StatusCode	processCsm (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const MdtCsm *rdoColl) const
StatusCode	processCsmTwin (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const MdtCsm *rdoColll) const
std::unique_ptr< MdtPrepData >	createPrepData (const MdtCalibInput &calibInput, const MdtCalibOutput &calibOutput, ConvCache &cache) const
	Creates the PRD object.
ConvCache	setupMdtPrepDataContainer (const EventContext &ctx) const
	Creates the prep data container to be written.
const MdtCsmContainer *	getRdoContainer (const EventContext &ctx) const
	Loads the input RDO container from StoreGate.
void	processPRDHashes (const EventContext &ctx, ConvCache &mdtPrepDataContainer, const std::vector< IdentifierHash > &chamberHashInRobs) const
bool	handlePRDHash (const EventContext &ctx, ConvCache &mdtPrepDataContainer, IdentifierHash rdoHash) const
void	initDeadChannels (const MuonGM::MdtReadoutElement *mydetEl)

Protected Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< IMdtCalibrationTool >	m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}
	MDT calibration service.
Gaudi::Property< bool >	m_useNewGeo
const MuonGMR4::MuonDetectorManager *	m_detMgrR4 {nullptr}
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "Stored alignment"}
SG::WriteHandleKey< Muon::MdtPrepDataContainer >	m_mdtPrepDataContainerKey {this, "OutputCollection", "MDT_DriftCircles"}
	MdtPrepRawData containers.
SG::ReadHandleKey< MdtCsmContainer >	m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}
Gaudi::Property< int >	m_adcCut
	member variables for algorithm properties:
Gaudi::Property< bool >	m_calibratePrepData {this, "CalibratePrepData", true}
	toggle on/off calibration of MdtPrepData
Gaudi::Property< bool >	m_decodeData {this, "DecodeData", true}
	toggle on/off the decoding of MDT RDO into MdtPrepData
bool	m_sortPrepData = false
	Toggle on/off the sorting of the MdtPrepData.
ToolHandle< Muon::IMDT_RDO_Decoder >	m_mdtDecoder {this, "Decoder", "Muon::MdtRDO_Decoder/MdtRDO_Decoder"}
bool	m_BMGpresent {false}
int	m_BMGid {-1}
Gaudi::Property< bool >	m_useTwin {this, "UseTwin", true}
Gaudi::Property< bool >	m_discardSecondaryHitTwin {this, "DiscardSecondaryHitTwin", false}
SG::ReadCondHandleKey< TwinTubeMap >	m_twinTubeKey {this, "TwinTubeKey", "MdtTwinTubeMap"}
std::unordered_set< Identifier >	m_DeadChannels {}
SG::ReadCondHandleKey< MuonMDT_CablingMap >	m_readKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey
SG::UpdateHandleKey< MdtPrepDataCollection_Cache >	m_prdContainerCacheKey
	This is the key for the cache for the MDT PRD containers, can be empty.
SG::WriteHandleKey< xAOD::MdtDriftCircleContainer >	m_xAODKey {this, "xAODKey", "", "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", "", "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.

Definition at line 40 of file MdtRdoToPrepDataToolMT.h.

Constructor & Destructor Documentation

~MdtRdoToPrepDataToolMT()

virtual Muon::MdtRdoToPrepDataToolMT::~MdtRdoToPrepDataToolMT ( )

virtualdefault

default destructor

Member Function Documentation

createPrepData()

std::unique_ptr< MdtPrepData > Muon::MdtRdoToPrepDataToolMT::createPrepData ( const MdtCalibInput & calibInput, const MdtCalibOutput & calibOutput, ConvCache & cache ) const

protected

Creates the PRD object.

Test by how much do we break frozen Tier0

Definition at line 292 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                {
        if (calibInput.adc() < m_adcCut ||
            calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined) {
            ATH_MSG_VERBOSE("Do not create calib hit for "<<m_idHelperSvc->toString(calibInput.identify())
                            <<", adc: "<<calibInput.adc()<<" vs. "<<m_adcCut<<", calibration bailed out "
                          <<(calibOutput.status() == MdtDriftCircleStatus::MdtStatusUnDefined? "si": "no"));
            return nullptr;
        }
        const MuonGM::MdtReadoutElement* descriptor = calibInput.legacyDescriptor();
        if (!descriptor) {
            if (!cache.legacyDetMgr) {
                return nullptr;
            }
            descriptor = cache.legacyDetMgr->getMdtReadoutElement(calibInput.identify());
        }
        ATH_MSG_VERBOSE("Calibrated prepdata "<<m_idHelperSvc->toString(calibInput.identify())
                        <<std::endl<<calibInput<<std::endl<<calibOutput);
 
        Amg::Vector2D driftRadius{Amg::Vector2D::Zero()};
        Amg::MatrixX cov(1, 1);
        if (calibOutput.status() == MdtDriftCircleStatus::MdtStatusDriftTime){
            const float r =  calibOutput.driftRadius();
            const float sigR = calibOutput.driftRadiusUncert();
            driftRadius[0] = r; 
            (cov)(0, 0) = sigR * sigR;
        } else (cov)(0, 0) = std::pow(descriptor->innerTubeRadius(), 2);
        
       return std::make_unique<MdtPrepData>(calibInput.identify(), 
                                            std::move(driftRadius), 
                                            std::move(cov), 
                                            descriptor,
                                            calibInput.tdc(),
                                            calibInput.adc(), 
                                            calibOutput.status());
    }

decode() [1/2]

StatusCode Muon::MdtRdoToPrepDataToolMT::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 258 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                             {
 
        ATH_MSG_DEBUG("decodeMdtRDO for " << idVect.size() << " offline collections called");
 
        // setup output container
        ConvCache mdtPrepDataContainer = setupMdtPrepDataContainer(ctx);
        if (!mdtPrepDataContainer.isValid) { 
            return StatusCode::FAILURE; 
        }
 
      
        if (!m_decodeData) {
            ATH_MSG_DEBUG("Stored empty container. Decoding MDT RDO into MDT PrepRawData is switched off");
            return StatusCode::SUCCESS;
        }
        // seeded or unseeded decoding
        if (!idVect.empty()) {
            processPRDHashes(ctx, mdtPrepDataContainer, idVect);
        } else {
            std::vector<IdentifierHash> rdoHashes{};
            const MdtCsmContainer* rdoContainer = getRdoContainer(ctx);
            if (!rdoContainer || rdoContainer->empty()) return StatusCode::SUCCESS;
            rdoHashes.reserve(rdoContainer->size());
            for (const MdtCsm* csm : *rdoContainer) rdoHashes.push_back(csm->identifyHash());
 
            processPRDHashes(ctx, mdtPrepDataContainer, rdoHashes);
        }
        ATH_CHECK(mdtPrepDataContainer.finalize(msgStream()));
 
        return StatusCode::SUCCESS;
    }

decode() [2/2]

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

overridevirtual

Definition at line 210 of file MdtRdoToPrepDataToolMT.cxx.

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

getMdtTwinPosition()

Muon::MdtDriftCircleStatus Muon::MdtRdoToPrepDataToolMT::getMdtTwinPosition ( const MdtDigit & prompt_digit, const MdtDigit & twin_digit, double & radius, double & errRadius, double & zTwin, double & errZTwin, bool & twinIsPrompt ) const

protected

method to get the twin tube 2nd coordinate

getRdoContainer()

const MdtCsmContainer * Muon::MdtRdoToPrepDataToolMT::getRdoContainer ( const EventContext & ctx ) const

protected

Loads the input RDO container from StoreGate.

Definition at line 216 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                {
        SG::ReadHandle rdoContainerHandle{m_rdoContainerKey, ctx};
        if (rdoContainerHandle.isValid()) {
            ATH_MSG_DEBUG("MdtgetRdoContainer success");
            return rdoContainerHandle.cptr();
        }
        ATH_MSG_WARNING("Retrieval of Mdt RDO container failed !");
        return nullptr;
    }

handlePRDHash()

bool Muon::MdtRdoToPrepDataToolMT::handlePRDHash ( const EventContext & ctx, ConvCache & mdtPrepDataContainer, IdentifierHash rdoHash ) const

protected

Definition at line 237 of file MdtRdoToPrepDataToolMT.cxx.

                                                                             {
        const MdtCsmContainer* rdoContainer{getRdoContainer(ctx)};
 
        if (rdoContainer->empty()) {
            ATH_MSG_DEBUG("The container is empty");
            return true;
        }
        const MdtCsm* rdoColl = rdoContainer->indexFindPtr(rdoHash);
        if (!rdoColl) {
            ATH_MSG_DEBUG("The rdo container does not have the hash " << rdoHash);
            return true;
        }
        if (processCsm(ctx, mdtPrepDataContainer, rdoColl).isFailure()) {
            ATH_MSG_WARNING("processCsm failed for RDO id " << m_idHelperSvc->toString(rdoColl->identify()));
            return false;
        }
        return true;
    }

initDeadChannels()

void Muon::MdtRdoToPrepDataToolMT::initDeadChannels ( const MuonGM::MdtReadoutElement * mydetEl )

protected

Definition at line 549 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                    {
        PVConstLink cv = mydetEl->getMaterialGeom();  // it is "Multilayer"
        int nGrandchildren = cv->getNChildVols();
        if (nGrandchildren <= 0) return;
 
        std::vector<int> tubes;
        geoGetIds([&](int id) { tubes.push_back(id); }, &*cv);
        std::sort(tubes.begin(), tubes.end());
 
        const Identifier detElId = mydetEl->identify();
        const int ml = mydetEl->getMultilayer();
        std::vector<int>::iterator it = tubes.begin();
        for (int layer = 1; layer <= mydetEl->getNLayers(); layer++) {
            for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++) {
                int want_id = layer * maxNTubesPerLayer + tube;
                if (it != tubes.end() && *it == want_id) {
                    ++it;
                } else {
                    it = std::lower_bound(tubes.begin(), tubes.end(), want_id);
                    if (it != tubes.end() && *it == want_id) {
                        ++it;
                    } else {
                        Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(detElId, ml, layer, tube);
                        m_DeadChannels.insert(deadTubeId);
                        ATH_MSG_VERBOSE("adding dead tube "<<m_idHelperSvc->toString(deadTubeId));
                    }
                }
            }
        }
        
    }

initialize()

StatusCode Muon::MdtRdoToPrepDataToolMT::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 153 of file MdtRdoToPrepDataToolMT.cxx.

                                                  {
        ATH_CHECK(m_calibrationTool.retrieve());
        ATH_MSG_VERBOSE("MdtCalibrationTool retrieved with pointer = " << m_calibrationTool);
        ATH_CHECK(m_prdContainerCacheKey.initialize(!m_prdContainerCacheKey.key().empty()));
        ATH_CHECK(m_idHelperSvc.retrieve());
        // Retrieve the RDO decoder
        ATH_CHECK(m_mdtDecoder.retrieve());
 
        ATH_CHECK(m_twinTubeKey.initialize(m_useTwin));
      
        m_BMGid = m_idHelperSvc->mdtIdHelper().stationNameIndex("BMG");
        m_BMGpresent = m_BMGid != -1;
        if (m_useNewGeo) {
            ATH_CHECK(detStore()->retrieve(m_detMgrR4));
        }
        if (m_BMGpresent && !m_useNewGeo) {
            const MuonGM::MuonDetectorManager* muDetMgr = nullptr;
            ATH_CHECK(detStore()->retrieve(muDetMgr));
 
            ATH_MSG_INFO("Processing configuration for layouts with BMG chambers.");
 
            for (int phi = 6; phi < 8; phi++) {                 // phi sectors
                for (int eta = 1; eta < 4; eta++) {             // eta sectors
                    for (int side = -1; side < 2; side += 2) {  // side
                        if (!muDetMgr->getMuonStation("BMG", side * eta, phi)) continue;
                        for (int roe = 1; roe <= (muDetMgr->getMuonStation("BMG", side * eta, phi))->nMuonReadoutElements();
                             roe++) {  // iterate on readout elemets
                            const MdtReadoutElement* mdtRE = dynamic_cast<const MdtReadoutElement*>(
                                (muDetMgr->getMuonStation("BMG", side * eta, phi))->getMuonReadoutElement(roe));  // has to be an MDT
                            if (mdtRE) initDeadChannels(mdtRE);
                        }
                    }
                }
            }
        } else if (m_useNewGeo) {
            std::vector<const MuonGMR4::MdtReadoutElement*> mdtRE = m_detMgrR4->getAllMdtReadoutElements();
            for (const MuonGMR4::MdtReadoutElement* re : mdtRE) {
                if (re->stationName() != m_BMGid) {
                    continue;
                }
                for (const IdentifierHash& dead : re->getParameters().removedTubes) {
                    m_DeadChannels.insert(re->measurementId(dead));
                }
            }
        }
 
        // check if initializing of DataHandle objects success
        ATH_CHECK(m_rdoContainerKey.initialize());
        ATH_CHECK(m_mdtPrepDataContainerKey.initialize());
        ATH_CHECK(m_readKey.initialize());
        ATH_CHECK(m_muDetMgrKey.initialize());
        ATH_CHECK(m_xAODKey.initialize(!m_xAODKey.empty()));
        ATH_CHECK(m_xAODTwinKey.initialize(!m_xAODTwinKey.empty()));
        ATH_CHECK(m_geoCtxKey.initialize(m_useNewGeo));
        return StatusCode::SUCCESS;
    }

printPrepDataImpl()

void Muon::MdtRdoToPrepDataToolMT::printPrepDataImpl ( const Muon::MdtPrepDataContainer * mdtPrepDataContainer ) const

protected

processCsm()

StatusCode Muon::MdtRdoToPrepDataToolMT::processCsm ( const EventContext & ctx, ConvCache & mdtPrepDataContainer, const MdtCsm * rdoColl ) const

protected

MDT hit context

Definition at line 331 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                        {
        const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
        // first handle the case of twin tubes
        if (m_useTwin) {
            if (cache.twinTubeMap->isTwinTubeLayer(rdoColl->identify())) {
                return processCsmTwin(ctx, cache, rdoColl);
            }
        }
 
        ATH_MSG_DEBUG(" ***************** Start of processCsm");

        const Identifier elementId = id_helper.parentID(rdoColl->identify());
 
        uint16_t subdetId = rdoColl->SubDetId();
        uint16_t mrodId = rdoColl->MrodId();
        uint16_t csmId = rdoColl->CsmId();
        ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toString(elementId) << " 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
        unsigned mc{0};
 
        for (const MdtAmtHit* amtHit : *rdoColl) {
            ++mc;
 
            // FIXME: Still use the digit class.
            ATH_MSG_VERBOSE("Amt Hit n. " << mc << " tdcId = " << amtHit->tdcId());
            std::unique_ptr<MdtDigit> 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;
            }
            // Do something with it
            Identifier channelId = newDigit->identify();
            if (newDigit->isMasked() || m_DeadChannels.count(channelId)) {
                continue;
            }
            // Retrieve the proper PRD container. Note that there are cases where one CSM is either split into 2 chambers (BEE / BIS78
            // legacy) or 2 CSMs are split into one chamber
            MdtPrepDataCollection* driftCircleColl = cache.createCollection(channelId);
            if (!driftCircleColl) {
                ATH_MSG_DEBUG("Corresponding multi layer " << m_idHelperSvc->toString(channelId) << " is already decoded.");
                continue;
            }
 
            // check if the module ID of this channel is different from the CSM one
            // If it's the first case, create the additional collection
 
            ATH_MSG_VERBOSE("got digit with id ext / hash " << m_idHelperSvc->toString(channelId) << " / "
                                                            << driftCircleColl->identifyHash());
 
            // 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)) {
                newDigit->setAdc(newDigit->adc() / 4);
                newDigit->setTdc(newDigit->tdc() / 4);
            }
            const MdtCalibInput calibIn = m_useNewGeo ? MdtCalibInput{*newDigit, *m_detMgrR4, *cache.gctx}: 
                                                        MdtCalibInput{*newDigit, *cache.legacyDetMgr};
            const MdtCalibOutput calibResult{m_calibrationTool->calibrate(ctx, calibIn, false)};
 
            std::unique_ptr<MdtPrepData> newPrepData = createPrepData(calibIn, calibResult, cache);
            if (!newPrepData) {
                continue;
            }
            if (driftCircleColl->size()) {
                MdtPrepData* prevPrd = driftCircleColl->at(driftCircleColl->size()-1);
                if (prevPrd->identify() == channelId) {
                    std::stringstream sstr{};
                    ATH_MSG_VERBOSE("Duplicated prep data object detected: "<<std::endl
                        <<"  **** "<<print(*prevPrd)<<std::endl
                        <<"  **** "<<print(*newPrepData));
                    if (prevPrd->status() == MdtDriftCircleStatus::MdtStatusDriftTime) {
                        ATH_MSG_VERBOSE("Prd is already good");
                    } else if (newPrepData->status() == MdtDriftCircleStatus::MdtStatusDriftTime) {
                        (*prevPrd) = std::move(*newPrepData);
                        prevPrd->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size()-1);
                    }
                    continue;
                }
            }
            ATH_MSG_VERBOSE("New prd created "<<print(*newPrepData));
            newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
            driftCircleColl->push_back(std::move(newPrepData));
        }
        return StatusCode::SUCCESS;
    }

processCsmTwin()

StatusCode Muon::MdtRdoToPrepDataToolMT::processCsmTwin ( const EventContext & ctx, ConvCache & mdtPrepDataContainer, const MdtCsm * rdoColll ) const

protected

MDT hit context

Create new PrepData

check for the twin tube id

Definition at line 422 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                         {
        const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
        ATH_MSG_DEBUG(" ***************** Start of processCsmTwin");
        ATH_MSG_DEBUG(" Number of AmtHit in this Csm " << rdoColl->size());
        Identifier elementId = id_helper.parentID(rdoColl->identify());
 
        uint16_t subdetId = rdoColl->SubDetId();
        uint16_t mrodId = rdoColl->MrodId();
        uint16_t csmId = rdoColl->CsmId();
        ATH_MSG_VERBOSE("Identifier = " << m_idHelperSvc->toString(elementId) << " 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::map<Identifier, std::array<std::unique_ptr<MdtDigit>, 2>> mdtDigitColl{};
 
        for (const MdtAmtHit* amtHit : *rdoColl) {
            std::unique_ptr<MdtDigit> 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;
            }
            std::array<std::unique_ptr<MdtDigit>, 2> & moveTo = mdtDigitColl[newDigit->identify()];
            if (!moveTo[0]) {
                moveTo[0] = std::move(newDigit);
            } else if  (!moveTo[1] && !m_discardSecondaryHitTwin) {
                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
 
        auto convertTwins = [this, &cache, &ctx](std::unique_ptr<MdtDigit> digit,
                                                 std::unique_ptr<MdtDigit> digit2) {
            if (!digit || digit->isMasked() || !cache.legacyDetMgr) {
                return;
            }
 
            MdtPrepDataCollection* driftCircleColl = cache.createCollection(digit->identify());
            
            if (!digit2 || digit2->isMasked()) {
                ATH_MSG_VERBOSE("Got single digit " << m_idHelperSvc->toString(digit->identify())<<", tdc: "
                             <<digit->tdc()<<", adc: "<<digit->adc() 
                             << ", hash: "<< driftCircleColl->identifyHash());
 
                const MdtCalibInput mdtCalibIn = m_useNewGeo ? MdtCalibInput{*digit, *m_detMgrR4, *cache.gctx}: 
                                                               MdtCalibInput{*digit, *cache.legacyDetMgr};
 
                const MdtCalibOutput mdtCalibOut{m_calibrationTool->calibrate(ctx, mdtCalibIn, false)};
                    
                std::unique_ptr<MdtPrepData> newPrepData = createPrepData(mdtCalibIn, mdtCalibOut, cache);
                if (!newPrepData) return;
                
                newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
                driftCircleColl->push_back(std::move(newPrepData));                
                return;
            } 
            ATH_MSG_VERBOSE("Twin digit calibration "<<m_idHelperSvc->toString(digit->identify())
                         <<", tdc: "<<digit->tdc()<<", adc: "<<digit->adc()<<" -- "
                         <<m_idHelperSvc->toString(digit2->identify())
                         <<", tdc: "<<digit2->tdc()<<", adc: "<<digit2->adc());
            MdtCalibInput mdtCalib1st = m_useNewGeo ? MdtCalibInput{*digit, *m_detMgrR4, *cache.gctx}
                                                    : MdtCalibInput{*digit, *cache.legacyDetMgr};
                
            MdtCalibInput mdtCalib2nd = m_useNewGeo ? MdtCalibInput{*digit2, *m_detMgrR4, *cache.gctx}
                                                    : MdtCalibInput{*digit2, *cache.legacyDetMgr};
                
            updateClosestApproachTwin(mdtCalib1st);
            updateClosestApproachTwin(mdtCalib2nd);
 
            const MdtCalibTwinOutput twinCalib = m_calibrationTool->calibrateTwinTubes(ctx, 
                                                                                       std::move(mdtCalib1st), 
                                                                                       std::move(mdtCalib2nd));
 
            Amg::Vector2D hitPos{twinCalib.primaryDriftR(), twinCalib.locZ()};
            Amg::MatrixX cov(2, 2);
            cov(0, 0) = twinCalib.uncertPrimaryR() * twinCalib.uncertPrimaryR();
            cov(1, 1) = twinCalib.sigmaZ() * twinCalib.sigmaZ();
            cov(0, 1) = cov(1, 0) = 0;
                
            const MuonGM::MdtReadoutElement* descriptor = cache.legacyDetMgr->getMdtReadoutElement(digit->identify());
            auto twin_newPrepData = std::make_unique<MdtTwinPrepData>(twinCalib.primaryID(),
                                                                      std::move(hitPos),
                                                                      std::move(cov),
                                                                      descriptor,
                                                                      twinCalib.primaryTdc(),
                                                                      twinCalib.primaryAdc(),
                                                                      twinCalib.twinTdc(),
                                                                      twinCalib.twinAdc(),
                                                                      twinCalib.primaryStatus());
                        
            ATH_MSG_VERBOSE(" MADE A 2D TWINPREPDATA " << m_idHelperSvc->toString(twinCalib.primaryID()) << " & "
                                                      << m_idHelperSvc->toString(twinCalib.twinID()) << " "<<twinCalib);
       
            ATH_MSG_VERBOSE("global pos center tube  " << Amg::toString(twin_newPrepData->globalPosition(), 2) << std::endl
                        <<"local pos center tube w/ TWIN INFO "<<Amg::toString(twinCalib.locZ() * Amg::Vector3D::UnitZ(), 2)<<std::endl
                        <<"global pos w/o TWIN INFO  "<<Amg::toString(descriptor->tubePos(twinCalib.primaryID())));
 
            twin_newPrepData->setHashAndIndex(driftCircleColl->identifyHash(), driftCircleColl->size());
            driftCircleColl->push_back(std::move(twin_newPrepData));
        };
 
        // iterate over mdtDigitColl
        for (auto &[id,  digits] : mdtDigitColl) {
            // get the twin hits from mdtDigitColl
            const Identifier twinId = cache.twinTubeMap->twinId(id);
            if (id != twinId) {
                std::array<std::unique_ptr<MdtDigit>, 2>& twinDigits = mdtDigitColl[twinId];
                ATH_MSG_VERBOSE("Convert digits: "<<digits[0].get()<<" "<<twinDigits[0].get());
                convertTwins(std::move(digits[0]), std::move(twinDigits[0]));
                ATH_MSG_VERBOSE("Convert digits: "<<digits[1].get()<<" "<<twinDigits[1].get());
                convertTwins(std::move(digits[1]), std::move(twinDigits[1]));
            } else {
                convertTwins(std::move(digits[0]), nullptr);
                convertTwins(std::move(digits[1]), nullptr);
            }
        }
        return StatusCode::SUCCESS;
    }

processPRDHashes()

void Muon::MdtRdoToPrepDataToolMT::processPRDHashes ( const EventContext & ctx, ConvCache & mdtPrepDataContainer, const std::vector< IdentifierHash > & chamberHashInRobs ) const

protected

Definition at line 230 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                              {
        for (const IdentifierHash& hash : multiLayerHashInRobs) {
            if (!handlePRDHash(ctx, mdtPrepDataContainer, hash)) { ATH_MSG_DEBUG("Failed to process hash " << hash); }
        }  // ends loop over chamberhash
    }

provideEmptyContainer()

StatusCode Muon::MdtRdoToPrepDataToolMT::provideEmptyContainer ( const EventContext & ctx ) const

overridevirtual

Definition at line 226 of file MdtRdoToPrepDataToolMT.cxx.

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

setupMdtPrepDataContainer()

MdtRdoToPrepDataToolMT::ConvCache Muon::MdtRdoToPrepDataToolMT::setupMdtPrepDataContainer ( const EventContext & ctx ) const

protected

Creates the prep data container to be written.

Retrieve the Geometry context if activated

Retrieve the legacy detector mananger if activated

Definition at line 580 of file MdtRdoToPrepDataToolMT.cxx.

                                                                                                                   {
 
        ConvCache cache{m_idHelperSvc.get()};
 
        SG::WriteHandle<MdtPrepDataContainer> handle{m_mdtPrepDataContainerKey, ctx};
        // Caching of PRD container
        if (m_prdContainerCacheKey.key().empty()) {
            // without the cache we just record the container
            StatusCode status = handle.record(std::make_unique<MdtPrepDataContainer>(m_idHelperSvc->mdtIdHelper().module_hash_max()));
            if (status.isFailure() || !handle.isValid()) {
                ATH_MSG_FATAL("Could not record container of MDT PrepData Container at " << m_mdtPrepDataContainerKey.key());
                return cache;
            }
            ATH_MSG_VERBOSE("Created container " << m_mdtPrepDataContainerKey.key());
            cache.legacyPrd = handle.ptr();
        } else {
            // use the cache to get the container
            SG::UpdateHandle update{m_prdContainerCacheKey, ctx};
            if (!update.isValid()) {
                ATH_MSG_FATAL("Invalid UpdateHandle " << m_prdContainerCacheKey.key());
                return cache;
            }
            StatusCode status = handle.record(std::make_unique<MdtPrepDataContainer>(update.ptr()));
            if (status.isFailure() || !handle.isValid()) {
                ATH_MSG_FATAL("Could not record container of MDT PrepData Container using cache " << m_prdContainerCacheKey.key() << " - "
                                                                                                  << m_mdtPrepDataContainerKey.key());
                return cache;
            }
            ATH_MSG_VERBOSE("Created container using cache for " << m_prdContainerCacheKey.key());
            cache.legacyPrd = handle.ptr();
        }
        if (!m_xAODTwinKey.empty()) {
            SG::WriteHandle writeHandle{m_xAODTwinKey, ctx};
            if (!writeHandle.recordNonConst(std::make_unique<xAOD::MdtTwinDriftCircleContainer>(),
                                            std::make_unique<xAOD::MdtTwinDriftCircleAuxContainer>()).isSuccess() ||
                !writeHandle.isValid()) {
                ATH_MSG_FATAL("Failed to write xAOD::MdtPrepDataContainer "<<m_xAODTwinKey.fullKey());
                return cache;
            }
            cache.xAODTwinPrd = writeHandle.ptr();
        }
        if (!m_xAODKey.empty()) {
            SG::WriteHandle writeHandle{m_xAODKey, ctx};
            if (!writeHandle.recordNonConst(std::make_unique<xAOD::MdtDriftCircleContainer>(),
                                            std::make_unique<xAOD::MdtDriftCircleAuxContainer>()).isSuccess() ||
                !writeHandle.isValid()) {
                ATH_MSG_FATAL("Failed to write xAOD::MdtPrepDataContainer "<<m_xAODKey.fullKey());
                return cache;
            }
            cache.xAODPrd = writeHandle.ptr();
        }
        if (!m_geoCtxKey.empty()) {
            SG::ReadHandle readHandle{m_geoCtxKey, ctx};
            if (!readHandle.isPresent()) {
                ATH_MSG_FATAL("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
                return cache;
            }
            cache.gctx = readHandle.cptr();
        }
        if (!m_muDetMgrKey.empty()) {
            SG::ReadCondHandle detMgrHandle{m_muDetMgrKey, ctx};
            if (!detMgrHandle.isValid()) {
                ATH_MSG_FATAL("Failed to retrieve the detector manager from the conditions store "<<m_muDetMgrKey.fullKey());
                return cache;
            }
            cache.legacyDetMgr = detMgrHandle.cptr();
        }
        if (m_useTwin) {
            SG::ReadCondHandle twinTubeHandle{m_twinTubeKey, ctx};
            if (!twinTubeHandle.isValid()) {
                ATH_MSG_FATAL("Failed to initialize twin tube map "<<m_twinTubeKey.fullKey());
                return cache;
            }
            cache.twinTubeMap = twinTubeHandle.cptr();
        }
        cache.r4DetMgr = m_detMgrR4;
        // Pass the container from the handle
        cache.isValid = true;
        return cache;
    }

Member Data Documentation

m_adcCut

Gaudi::Property<int> Muon::MdtRdoToPrepDataToolMT::m_adcCut

protected

Initial value:

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

member variables for algorithm properties:

Definition at line 136 of file MdtRdoToPrepDataToolMT.h.

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

m_BMGid

int Muon::MdtRdoToPrepDataToolMT::m_BMGid {-1}

protected

Definition at line 145 of file MdtRdoToPrepDataToolMT.h.

{-1};

m_BMGpresent

bool Muon::MdtRdoToPrepDataToolMT::m_BMGpresent {false}

protected

Definition at line 144 of file MdtRdoToPrepDataToolMT.h.

{false};

m_calibratePrepData

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_calibratePrepData {this, "CalibratePrepData", true}

protected

toggle on/off calibration of MdtPrepData

Definition at line 138 of file MdtRdoToPrepDataToolMT.h.

{this, "CalibratePrepData", true};  

m_calibrationTool

ToolHandle<IMdtCalibrationTool> Muon::MdtRdoToPrepDataToolMT::m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}

protected

MDT calibration service.

Definition at line 119 of file MdtRdoToPrepDataToolMT.h.

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

m_DeadChannels

std::unordered_set<Identifier> Muon::MdtRdoToPrepDataToolMT::m_DeadChannels {}

protected

Definition at line 154 of file MdtRdoToPrepDataToolMT.h.

{};

m_decodeData

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

protected

toggle on/off the decoding of MDT RDO into MdtPrepData

Definition at line 139 of file MdtRdoToPrepDataToolMT.h.

{this, "DecodeData", true};  

m_detMgrR4

const MuonGMR4::MuonDetectorManager* Muon::MdtRdoToPrepDataToolMT::m_detMgrR4 {nullptr}

protected

Definition at line 125 of file MdtRdoToPrepDataToolMT.h.

{nullptr};

m_discardSecondaryHitTwin

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_discardSecondaryHitTwin {this, "DiscardSecondaryHitTwin", false}

protected

Definition at line 149 of file MdtRdoToPrepDataToolMT.h.

{this, "DiscardSecondaryHitTwin", false};

m_geoCtxKey

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

protected

Definition at line 126 of file MdtRdoToPrepDataToolMT.h.

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

m_idHelperSvc

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

protected

Definition at line 116 of file MdtRdoToPrepDataToolMT.h.

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

m_mdtDecoder

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

protected

Definition at line 142 of file MdtRdoToPrepDataToolMT.h.

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

m_mdtPrepDataContainerKey

SG::WriteHandleKey<Muon::MdtPrepDataContainer> Muon::MdtRdoToPrepDataToolMT::m_mdtPrepDataContainerKey {this, "OutputCollection", "MDT_DriftCircles"}

protected

MdtPrepRawData containers.

Definition at line 130 of file MdtRdoToPrepDataToolMT.h.

{this, "OutputCollection", "MDT_DriftCircles"};

m_muDetMgrKey

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

protected

Initial value:

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

Definition at line 159 of file MdtRdoToPrepDataToolMT.h.

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

m_prdContainerCacheKey

SG::UpdateHandleKey<MdtPrepDataCollection_Cache> Muon::MdtRdoToPrepDataToolMT::m_prdContainerCacheKey

protected

Initial value:

{this, "MdtPrdContainerCacheKey", "",
                                                                                "Optional external cache for the MDT PRD container"}

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

Definition at line 162 of file MdtRdoToPrepDataToolMT.h.

                                                                             {this, "MdtPrdContainerCacheKey", "",
                                                                                "Optional external cache for the MDT PRD container"};

m_rdoContainerKey

SG::ReadHandleKey<MdtCsmContainer> Muon::MdtRdoToPrepDataToolMT::m_rdoContainerKey {this, "RDOContainer", "MDTCSM"}

protected

Definition at line 132 of file MdtRdoToPrepDataToolMT.h.

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

m_readKey

SG::ReadCondHandleKey<MuonMDT_CablingMap> Muon::MdtRdoToPrepDataToolMT::m_readKey {this, "ReadKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"}

protected

Definition at line 157 of file MdtRdoToPrepDataToolMT.h.

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

m_sortPrepData

bool Muon::MdtRdoToPrepDataToolMT::m_sortPrepData = false

protected

Toggle on/off the sorting of the MdtPrepData.

Definition at line 140 of file MdtRdoToPrepDataToolMT.h.

m_twinTubeKey

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

protected

Definition at line 152 of file MdtRdoToPrepDataToolMT.h.

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

m_useNewGeo

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_useNewGeo

protected

Initial value:

{this, "UseR4DetMgr", false,
                                         "Switch between the legacy and the new geometry"}

Definition at line 122 of file MdtRdoToPrepDataToolMT.h.

                                       {this, "UseR4DetMgr", false,
                                         "Switch between the legacy and the new geometry"};

m_useTwin

Gaudi::Property<bool> Muon::MdtRdoToPrepDataToolMT::m_useTwin {this, "UseTwin", true}

protected

Definition at line 148 of file MdtRdoToPrepDataToolMT.h.

{this, "UseTwin", true};

m_xAODKey

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

protected

Definition at line 166 of file MdtRdoToPrepDataToolMT.h.

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

m_xAODTwinKey

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

protected

Definition at line 167 of file MdtRdoToPrepDataToolMT.h.

{this, "xAODTwinKey", "", "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:

• MdtRdoToPrepDataToolMT.h
• MdtRdoToPrepDataToolMT.cxx