seeded segment finder that gets its data directly from storegate for a give set of Identifiers or IdentifierHashes More...

#include <MuonSeededSegmentFinder.h>

Inheritance diagram for Muon::MuonSeededSegmentFinder:

Collaboration diagram for Muon::MuonSeededSegmentFinder:

Public Member Functions
	MuonSeededSegmentFinder (const std::string &, const std::string &, const IInterface *)
	constructor
	~MuonSeededSegmentFinder ()=default
	destructor
StatusCode	initialize ()
	AlgTool initilize.
std::unique_ptr< Trk::SegmentCollection >	find (const EventContext &ctx, const Trk::TrackParameters &pars, const std::set< Identifier > &chIds) const
	find segments in a set of chambers starting from seeding TrackParameters
std::unique_ptr< Trk::SegmentCollection >	find (const EventContext &ctx, const Trk::TrackParameters &pars, const std::set< IdentifierHash > &chIdHs) const
	find segments in a set of chambers starting from seeding TrackParameters (version with Hashes)
std::unique_ptr< Trk::SegmentCollection >	find (const EventContext &ctx, const Trk::TrackParameters &pars, const std::vector< const MdtPrepData * > &mdtPrds) const
	find segments in a set of MdtPrepData starting from seeding TrackParameters
void	extractMdtPrdCols (const EventContext &ctx, const std::set< IdentifierHash > &chIdHs, std::vector< const MdtPrepDataCollection * > &target) const
	retrieve MDT PRD collections for the given hashes
void	extractRpcPrdCols (const EventContext &ctx, const std::set< IdentifierHash > &chIdHs, std::vector< const RpcPrepDataCollection * > &target) const
	retrieve RPC PRD collections for the given hashes
void	extractTgcPrdCols (const EventContext &ctx, const std::set< IdentifierHash > &chIdHs, std::vector< const TgcPrepDataCollection * > &target) const
	retrieve TGC PRD collections for the given hashes
void	extractCscPrdCols (const std::set< IdentifierHash > &chIdHs, std::vector< const CscPrepDataCollection * > &target) const
	retrieve CSC PRD collections for the given hashes
void	extractsTgcPrdCols (const EventContext &ctx, const std::set< IdentifierHash > &chIdHs, std::vector< const sTgcPrepDataCollection * > &target) const
	retrieve STGC PRD collections for the given hashes
void	extractMMPrdCols (const std::set< IdentifierHash > &chIdHs, std::vector< const MMPrepDataCollection * > &target) const
	retrieve MM PRD collections for the given hashes

Private Member Functions
std::vector< const MdtPrepData * >	extractPrds (const EventContext &ctx, const std::set< Identifier > &chIds) const
	retrieve the MdtPrepDataCollections for the give Identifiers
std::vector< const MdtPrepData * >	extractPrds (const EventContext &ctx, const std::set< IdentifierHash > &chIdHs) const
	retrieve the MdtPrepDataCollections for the give Identifier Hashes
void	selectAndCalibrate (const EventContext &ctx, const Trk::TrackParameters &pars, const std::vector< const MdtPrepData * > &mdtPrdCols, std::vector< const MdtDriftCircleOnTrack * > &mdtROTs, bool &doHoleSearch) const
	select a set of Mdt hits and calibrate them
const MdtDriftCircleOnTrack *	handleMdtPrd (const EventContext &ctx, const Trk::TrackParameters &pars, const MdtPrepData &mdtPrd, bool &doHoleSearch) const
	select and calibrate a single MdtPrepData

Private Attributes
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
ToolHandle< Muon::IMuonSegmentMaker >	m_segMaker
	actual segment maker with hole search
ToolHandle< Muon::IMuonSegmentMaker >	m_segMakerNoHoles
	actual segment maker no hole search
ToolHandle< Trk::IPropagator >	m_propagator
	propagator
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
	IMdtDriftCircleOnTrackCreator.
Trk::MagneticFieldProperties	m_magFieldProperties
	magnetic field properties
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer
	EDM printer tool.
SG::ReadHandleKey< Muon::MdtPrepDataContainer >	m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}
SG::ReadHandleKey< Muon::CscPrepDataContainer >	m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}
SG::ReadHandleKey< Muon::TgcPrepDataContainer >	m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}
SG::ReadHandleKey< Muon::RpcPrepDataContainer >	m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
SG::ReadHandleKey< Muon::sTgcPrepDataContainer >	m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}
SG::ReadHandleKey< Muon::MMPrepDataContainer >	m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}
Gaudi::Property< double >	m_adcCut {this, "AdcCut", 50}
Gaudi::Property< double >	m_maxSigma {this, "MdtSigmaFromTrack", 3}

Detailed Description

seeded segment finder that gets its data directly from storegate for a give set of Identifiers or IdentifierHashes

Definition at line 30 of file MuonSeededSegmentFinder.h.

Constructor & Destructor Documentation

◆ MuonSeededSegmentFinder()

Muon::MuonSeededSegmentFinder::MuonSeededSegmentFinder	(	const std::string &	ty,
		const std::string &	na,
		const IInterface *	pa )

constructor

Definition at line 23 of file MuonSeededSegmentFinder.cxx.

23 :

24 base_class(ty, na, pa), m_magFieldProperties(Trk::NoField) {}

Muon::MuonSeededSegmentFinder::m_magFieldProperties

Trk::MagneticFieldProperties m_magFieldProperties

magnetic field properties

Definition MuonSeededSegmentFinder.h:104

Trk::NoField

@ NoField

Field is set to 0., 0., 0.,.

Definition MagneticFieldMode.h:18

◆ ~MuonSeededSegmentFinder()

Muon::MuonSeededSegmentFinder::~MuonSeededSegmentFinder ( )

default

destructor

Member Function Documentation

◆ extractCscPrdCols()

void Muon::MuonSeededSegmentFinder::extractCscPrdCols	(	const std::set< IdentifierHash > &	chIdHs,
		std::vector< const CscPrepDataCollection * > &	target ) const

retrieve CSC PRD collections for the given hashes

Definition at line 247 of file MuonSeededSegmentFinder.cxx.

                                                                                                           {
        if (m_key_csc.empty()) {
            ATH_MSG_DEBUG("No CSC collection");
            return;
        }
        SG::ReadHandle cscPrdContainer{m_key_csc};
        if (cscPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = cscPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
 
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            // reserve space for the new PRDs
            target.push_back(collptr);
        }
    }

◆ extractMdtPrdCols()

void Muon::MuonSeededSegmentFinder::extractMdtPrdCols	(	const EventContext &	ctx,
		const std::set< IdentifierHash > &	chIdHs,
		std::vector< const MdtPrepDataCollection * > &	target ) const

retrieve MDT PRD collections for the given hashes

Definition at line 186 of file MuonSeededSegmentFinder.cxx.

                                                                                                           {
 
        if (m_key_mdt.empty()) return;
        SG::ReadHandle mdtPrdContainer{m_key_mdt, ctx};
        if (mdtPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = mdtPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            // reserve space for the new PRDs
            target.push_back(collptr);
        }
    }

◆ extractMMPrdCols()

void Muon::MuonSeededSegmentFinder::extractMMPrdCols	(	const std::set< IdentifierHash > &	chIdHs,
		std::vector< const MMPrepDataCollection * > &	target ) const

retrieve MM PRD collections for the given hashes

Definition at line 306 of file MuonSeededSegmentFinder.cxx.

                                                                                                         {
        if (m_key_mm.key().empty()) {
            ATH_MSG_DEBUG("no MM collection");
            return;
        }
 
        SG::ReadHandle<Muon::MMPrepDataContainer> h_mmPrdCont(m_key_mm);
        const Muon::MMPrepDataContainer* mmPrdContainer;
        if (h_mmPrdCont.isValid()) {
            mmPrdContainer = h_mmPrdCont.cptr();
        } else {
            ATH_MSG_WARNING("Cannot retrieve mmPrepDataContainer " << m_key_mm.key());
            return;
        }
        if (mmPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = mmPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            target.push_back(collptr);
        }
    }

◆ extractPrds() [1/2]

std::vector< const MdtPrepData * > Muon::MuonSeededSegmentFinder::extractPrds	(	const EventContext &	ctx,
		const std::set< Identifier > &	chIds ) const

private

retrieve the MdtPrepDataCollections for the give Identifiers

Definition at line 124 of file MuonSeededSegmentFinder.cxx.

                                                                                                                                     {
        SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey, ctx};
        const MuonGM::MuonDetectorManager* MuonDetMgr{*DetectorManagerHandle};
        if (MuonDetMgr == nullptr) {
            ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
            // return;
        }
 
        // set of IdHashes corresponding to these identifiers
        std::set<IdentifierHash> chIdHs;
 
        // loop over chambers and get collections
        std::set<Identifier>::const_iterator chit = chIds.begin();
        std::set<Identifier>::const_iterator chit_end = chIds.end();
        for (; chit != chit_end; ++chit) {
            if (!m_idHelperSvc->isMdt(*chit)) {
                ATH_MSG_WARNING(" Requested chamber is not an MDT:   " << m_idHelperSvc->toStringChamber(*chit));
                continue;
            }
 
            const MuonGM::MdtReadoutElement* detEl = MuonDetMgr->getMdtReadoutElement(*chit);
            if (!detEl) {
                ATH_MSG_WARNING(" Requested chamber does not exist in geometry:   " << m_idHelperSvc->toStringChamber(*chit));
                continue;
            }
            chIdHs.insert(detEl->identifyHash());
        }
 
        // vector to store pointers to collections
        std::vector<const MdtPrepData*> mdtPrds = extractPrds(ctx, chIdHs);
 
        return mdtPrds;
    }

◆ extractPrds() [2/2]

std::vector< const MdtPrepData * > Muon::MuonSeededSegmentFinder::extractPrds	(	const EventContext &	ctx,
		const std::set< IdentifierHash > &	chIdHs ) const

private

retrieve the MdtPrepDataCollections for the give Identifier Hashes

Definition at line 158 of file MuonSeededSegmentFinder.cxx.

                                                                                                                     {
        SG::ReadHandle<Muon::MdtPrepDataContainer> h_mdtPrdCont(m_key_mdt, ctx);
        const Muon::MdtPrepDataContainer* mdtPrdContainer;
        if (h_mdtPrdCont.isValid()) {
            mdtPrdContainer = h_mdtPrdCont.cptr();
        } else {
            ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt.key());
            return {};
        }
 
        // vector to store pointers to collections
        std::vector<const MdtPrepData*> mdtPrds;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = mdtPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr) { continue; }
 
            // reserve space for the new PRDs
            mdtPrds.insert(mdtPrds.end(), collptr->begin(), collptr->end());
        }
 
        return mdtPrds;
    }

◆ extractRpcPrdCols()

void Muon::MuonSeededSegmentFinder::extractRpcPrdCols	(	const EventContext &	ctx,
		const std::set< IdentifierHash > &	chIdHs,
		std::vector< const RpcPrepDataCollection * > &	target ) const

retrieve RPC PRD collections for the given hashes

Definition at line 207 of file MuonSeededSegmentFinder.cxx.

                                                                                                           {
        if (m_key_rpc.empty()) return;
        SG::ReadHandle rpcPrdContainer{m_key_rpc, ctx};
        if (rpcPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = rpcPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            // reserve space for the new PRDs
            target.push_back(collptr);
        }
    }

◆ extractsTgcPrdCols()

void Muon::MuonSeededSegmentFinder::extractsTgcPrdCols	(	const EventContext &	ctx,
		const std::set< IdentifierHash > &	chIdHs,
		std::vector< const sTgcPrepDataCollection * > &	target ) const

retrieve STGC PRD collections for the given hashes

Definition at line 274 of file MuonSeededSegmentFinder.cxx.

                                                                                                             {
        if (m_key_stgc.key().empty()) {
            ATH_MSG_DEBUG("no sTGC collection");
            return;
        }
 
        SG::ReadHandle<Muon::sTgcPrepDataContainer> h_stgcPrdCont(m_key_stgc, ctx);
        const Muon::sTgcPrepDataContainer* stgcPrdContainer;
        if (h_stgcPrdCont.isValid()) {
            stgcPrdContainer = h_stgcPrdCont.cptr();
        } else {
            ATH_MSG_WARNING("Cannot retrieve stgcPrepDataContainer " << m_key_stgc.key());
            return;
        }
        if (stgcPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = stgcPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            // reserve space for the new PRDs
            target.push_back(collptr);
        }
    }

◆ extractTgcPrdCols()

void Muon::MuonSeededSegmentFinder::extractTgcPrdCols	(	const EventContext &	ctx,
		const std::set< IdentifierHash > &	chIdHs,
		std::vector< const TgcPrepDataCollection * > &	target ) const

retrieve TGC PRD collections for the given hashes

Definition at line 227 of file MuonSeededSegmentFinder.cxx.

                                                                                                           {
        if (m_key_tgc.empty()) return;
        SG::ReadHandle tgcPrdContainer{m_key_tgc, ctx};
        if (tgcPrdContainer->empty()) return;
 
        // loop over chambers and get collections
        std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
        std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
        for (; chit != chit_end; ++chit) {
            const auto* collptr = tgcPrdContainer->indexFindPtr(*chit);
            if (collptr == nullptr || collptr->empty()) { continue; }
            ATH_MSG_DEBUG(" Adding for:   " << m_idHelperSvc->toStringChamber(collptr->front()->identify()) << "  size "
                                            << collptr->size());
 
            // reserve space for the new PRDs
            target.push_back(collptr);
        }
    }

◆ find() [1/3]

std::unique_ptr< Trk::SegmentCollection > Muon::MuonSeededSegmentFinder::find	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const std::set< Identifier > &	chIds ) const

find segments in a set of chambers starting from seeding TrackParameters

Definition at line 49 of file MuonSeededSegmentFinder.cxx.

                                                                                                                 {
        // get MdtPrepData collections correspondign to the chamber Identifiers
        std::vector<const MdtPrepData*> mdtPrds = extractPrds(ctx, chIds);
 
        if (mdtPrds.empty()) {
            ATH_MSG_DEBUG(" no MdtPrepData found ");
            return {};
        }
 
        // find segments
        return find(ctx, pars, mdtPrds);
    }

◆ find() [2/3]

std::unique_ptr< Trk::SegmentCollection > Muon::MuonSeededSegmentFinder::find	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const std::set< IdentifierHash > &	chIdHs ) const

find segments in a set of chambers starting from seeding TrackParameters (version with Hashes)

Definition at line 63 of file MuonSeededSegmentFinder.cxx.

                                                                                                                      {
        // get MdtPrepData collections correspondign to the chamber Identifiers
        std::vector<const MdtPrepData*> mdtPrds = extractPrds(ctx, chIdHs);
 
        if (mdtPrds.empty()) {
            ATH_MSG_DEBUG(" no MdtPrepData found ");
            return {};
        }
 
        // find segments
        return find(ctx, pars, mdtPrds);
    }

◆ find() [3/3]

std::unique_ptr< Trk::SegmentCollection > Muon::MuonSeededSegmentFinder::find	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const std::vector< const MdtPrepData * > &	mdtPrds ) const

find segments in a set of MdtPrepData starting from seeding TrackParameters

Definition at line 77 of file MuonSeededSegmentFinder.cxx.

                                                                                                                              {
        // are we close to the chamber edge?
        bool doHoleSearch = true;
 
        // select and calibrate the MdtPrepData
        std::vector<const MdtDriftCircleOnTrack*> mdtROTs;
        mdtROTs.reserve(mdtPrds.size());
        selectAndCalibrate(ctx, pars, mdtPrds, mdtROTs, doHoleSearch);
 
        if (mdtROTs.empty()) {
            ATH_MSG_DEBUG(" no MdtDriftCircles selected ");
            return nullptr;
        }
 
        // create track road
        double roadWidthEta = 1.;
        if (pars.covariance()) {
            double trackError = Amg::error(*pars.covariance(), Trk::theta);
            ATH_MSG_DEBUG(" local track Error on theta " << trackError);
            if (trackError < 0.2) trackError = 0.2;
            roadWidthEta = 5. * trackError;
        }
        Trk::TrackRoad road(pars.position(), pars.momentum(), roadWidthEta, 1.);
 
        // create dummy vector<vector>
        std::vector<std::vector<const MdtDriftCircleOnTrack*> > mdtROTsVec;
        mdtROTsVec.push_back(mdtROTs);
        std::vector<std::vector<const MuonClusterOnTrack*> > clusterROTsVec;
 
        // call segment finder
        std::unique_ptr<Trk::SegmentCollection> segments(new Trk::SegmentCollection());
        doHoleSearch ? m_segMaker->find(road, mdtROTsVec, clusterROTsVec, segments.get(), true)
                     : m_segMakerNoHoles->find(road, mdtROTsVec, clusterROTsVec, segments.get(), true);
 
        // delete ROTs
        std::for_each(mdtROTs.begin(), mdtROTs.end(), MuonDeleteObject<const MdtDriftCircleOnTrack>());
 
        if (!segments) {
            ATH_MSG_DEBUG(" No segments found ");
        } else {
            ATH_MSG_DEBUG(" Number of segments found: " << segments->size());
        }
 
        return segments;
    }

◆ handleMdtPrd()

const MdtDriftCircleOnTrack * Muon::MuonSeededSegmentFinder::handleMdtPrd	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const MdtPrepData &	mdtPrd,
		bool &	doHoleSearch ) const

private

select and calibrate a single MdtPrepData

Definition at line 357 of file MuonSeededSegmentFinder.cxx.

                                                                                                                            {
        // skip noise hits
        if (mdtPrd.adc() < m_adcCut) return nullptr;
 
        // get surface of PRD
        const Identifier& id = mdtPrd.identify();
        const MuonGM::MdtReadoutElement& detEl = *mdtPrd.detectorElement();
        const Trk::StraightLineSurface& surf = detEl.surface(id);
 
        // propagate segment parameters to first measurement
        // retain ownership; this code deleted the exPars before
        auto exPars = m_propagator->propagate(ctx, pars, surf, Trk::anyDirection, false, m_magFieldProperties);
        if (!exPars) {
            ATH_MSG_DEBUG(" Propagation failed!! ");
            return nullptr;
        }
 
        // calculate position on wire + error
        double distanceToWire = exPars->parameters()[Trk::locR];
        double posAlongWire = exPars->parameters()[Trk::locZ];
 
        double errorR = exPars->covariance() ? fabs(Amg::error(*exPars->covariance(), Trk::locR)) : 500.;
        double errorZ = exPars->covariance() ? fabs(Amg::error(*exPars->covariance(), Trk::locZ)) : 300.;
 
        // range check
        bool isOnSurface = surf.isOnSurface(exPars->position(), true, 5 * errorR, 5 * errorZ);
 
        // get tube length
        int layer = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
        int tube = m_idHelperSvc->mdtIdHelper().tube(id);
        double halfTubeLength = 0.5 * detEl.getActiveTubeLength(layer, tube);
        double tubeRadius = detEl.innerTubeRadius();
 
        // take into account the tube width
        double roadWidthR = 5 * errorR + 4 * tubeRadius;
        double roadWidthZ = 5 * errorZ + 100.;
 
        double driftdr = Amg::error(mdtPrd.localCovariance(), Trk::locR);
        double nSigmaFromTrack = fabs(fabs(distanceToWire) - mdtPrd.localPosition()[Trk::locR]) / sqrt(errorR * errorR + driftdr * driftdr);
 
        if (msgLvl(MSG::VERBOSE)) {
            std::string boundCheckStr = isOnSurface ? "  onSurface" : " outOfSurface";
            msg() << MSG::VERBOSE << "  " << m_idHelperSvc->toString(mdtPrd.identify()) << " r " << distanceToWire << " range "
                  << roadWidthR << " z " << posAlongWire << " range " << halfTubeLength + roadWidthZ << boundCheckStr;
        }
 
        // if( fabs(distanceToWire) > roadWidthR || fabs(posAlongWire) > halfTubeLength + roadWidthZ ){
        if (nSigmaFromTrack > m_maxSigma || fabs(posAlongWire) > halfTubeLength + roadWidthZ) {
            if (msgLvl(MSG::VERBOSE)) msg() << " --- dropped" << endmsg;
            // delete exPars;
            return nullptr;
        }
 
        // update hole search flag, set to false if we are close to the tube edge
        if (doHoleSearch && fabs(posAlongWire) < halfTubeLength + roadWidthZ) doHoleSearch = false;
 
        Amg::Vector3D momentum = exPars->momentum();
 
        // pointer to ROT
        const MdtDriftCircleOnTrack* mdtROT = m_mdtRotCreator->createRIO_OnTrack(mdtPrd, exPars->position(), &momentum);
 
        // clean up pointers
        // delete exPars;
 
        // check whether ROT is created
        if (!mdtROT) {
            ATH_MSG_DEBUG(" failed to calibrate MdtPrepData " << m_idHelperSvc->toString(mdtPrd.identify()));
            return nullptr;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            double radius = mdtROT->localParameters()[Trk::locR];
            double error = driftdr;
            double residual = radius - fabs(distanceToWire);
            double fullError = sqrt(errorR * errorR + error * error);
            double radialPull = residual / fullError;
            std::string hitType;
            if (fabs(radialPull) < 5)
                hitType = "onTrack";
            else if (fabs(radialPull) > 5 && residual > 0)
                hitType = "delta";
            else
                hitType = "outOfTime";
            msg() << " r_drift  " << radius << " res " << residual << " pull " << radialPull << " " << hitType << endmsg;
        }
        return mdtROT;
    }

◆ initialize()

StatusCode Muon::MuonSeededSegmentFinder::initialize ( )

AlgTool initilize.

Definition at line 26 of file MuonSeededSegmentFinder.cxx.

                                                   {
 
 
        ATH_CHECK(m_key_mdt.initialize(!m_key_mdt.empty()));
        ATH_CHECK(m_key_csc.initialize(!m_key_csc.empty()));  // check for layouts without CSCs
        ATH_CHECK(m_key_tgc.initialize(!m_key_tgc.empty()));
        ATH_CHECK(m_key_rpc.initialize(!m_key_rpc.empty()));
        ATH_CHECK(m_key_stgc.initialize(!m_key_stgc.empty()));  // check for layouts without STGCs
        ATH_CHECK(m_key_mm.initialize(!m_key_mm.empty()));      // check for layouts without MicroMegas
 
        ATH_CHECK(m_DetectorManagerKey.initialize());
        ATH_CHECK(m_segMaker.retrieve());
        ATH_CHECK(m_segMakerNoHoles.retrieve());
        ATH_CHECK(m_propagator.retrieve());
        ATH_CHECK(m_mdtRotCreator.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
 
 
 
        return StatusCode::SUCCESS;
    }

◆ selectAndCalibrate()

void Muon::MuonSeededSegmentFinder::selectAndCalibrate	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const std::vector< const MdtPrepData * > &	mdtPrdCols,
		std::vector< const MdtDriftCircleOnTrack * > &	mdtROTs,
		bool &	doHoleSearch ) const

private

select a set of Mdt hits and calibrate them

Definition at line 336 of file MuonSeededSegmentFinder.cxx.

                                                                                                                                 {
        ATH_MSG_VERBOSE(" in selectAndCalibrate, get PRDs  " << mdtPrdCols.size());
 
        // loop over MdtPrepDataCollections
        std::vector<const MdtPrepData*>::const_iterator mit = mdtPrdCols.begin();
        std::vector<const MdtPrepData*>::const_iterator mit_end = mdtPrdCols.end();
        for (; mit != mit_end; ++mit) {
            if (!MC::isStable(*mit)) continue;
            // calibrate MDT
            const MdtDriftCircleOnTrack* mdt = handleMdtPrd(ctx, pars, **mit, doHoleSearch);
 
            // not selected
            if (!mdt) continue;
 
            mdtROTs.push_back(mdt);
        }
        ATH_MSG_VERBOSE(" calibrated " << mdtROTs.size() << " prds out of " << mdtPrdCols.size());
    }

Member Data Documentation

◆ m_adcCut

Gaudi::Property<double> Muon::MuonSeededSegmentFinder::m_adcCut {this, "AdcCut", 50}

private

Definition at line 116 of file MuonSeededSegmentFinder.h.

116{this, "AdcCut", 50};

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MuonSeededSegmentFinder::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 93 of file MuonSeededSegmentFinder.h.

93 {this, "DetectorManagerKey", "MuonDetectorManager",

94 "Key of input MuonDetectorManager condition data"};

◆ m_idHelperSvc

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

private

Definition at line 105 of file MuonSeededSegmentFinder.h.

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

◆ m_key_csc

SG::ReadHandleKey<Muon::CscPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}

private

Definition at line 110 of file MuonSeededSegmentFinder.h.

110{this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"};

◆ m_key_mdt

SG::ReadHandleKey<Muon::MdtPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}

private

Definition at line 109 of file MuonSeededSegmentFinder.h.

109{this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"};

◆ m_key_mm

SG::ReadHandleKey<Muon::MMPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}

private

Definition at line 114 of file MuonSeededSegmentFinder.h.

114{this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"};

◆ m_key_rpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}

private

Definition at line 112 of file MuonSeededSegmentFinder.h.

112{this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"};

◆ m_key_stgc

SG::ReadHandleKey<Muon::sTgcPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}

private

Definition at line 113 of file MuonSeededSegmentFinder.h.

113{this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"};

◆ m_key_tgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> Muon::MuonSeededSegmentFinder::m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}

private

Definition at line 111 of file MuonSeededSegmentFinder.h.

111{this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"};

◆ m_magFieldProperties

Trk::MagneticFieldProperties Muon::MuonSeededSegmentFinder::m_magFieldProperties

private

magnetic field properties

Definition at line 104 of file MuonSeededSegmentFinder.h.

◆ m_maxSigma

Gaudi::Property<double> Muon::MuonSeededSegmentFinder::m_maxSigma {this, "MdtSigmaFromTrack", 3}

private

Definition at line 117 of file MuonSeededSegmentFinder.h.

117{this, "MdtSigmaFromTrack", 3};

◆ m_mdtRotCreator

ToolHandle<Muon::IMdtDriftCircleOnTrackCreator> Muon::MuonSeededSegmentFinder::m_mdtRotCreator

private

Initial value:

{

this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"}

IMdtDriftCircleOnTrackCreator.

Definition at line 102 of file MuonSeededSegmentFinder.h.

102 {

103 this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"};

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonSeededSegmentFinder::m_printer

private

Initial value:

{this, "Printer",

"Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

EDM printer tool.

Definition at line 106 of file MuonSeededSegmentFinder.h.

106 {this, "Printer",

107 "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};

◆ m_propagator

ToolHandle<Trk::IPropagator> Muon::MuonSeededSegmentFinder::m_propagator

private

Initial value:

{this, "Propagator",

"Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator"}

propagator

Definition at line 100 of file MuonSeededSegmentFinder.h.

100 {this, "Propagator",

101 "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator"};

◆ m_segMaker

ToolHandle<Muon::IMuonSegmentMaker> Muon::MuonSeededSegmentFinder::m_segMaker

private

Initial value:

{

this, "SegmentMaker", "Muon::DCMathSegmentMaker/DCMathSegmentMaker"}

actual segment maker with hole search

Definition at line 96 of file MuonSeededSegmentFinder.h.

96 {

97 this, "SegmentMaker", "Muon::DCMathSegmentMaker/DCMathSegmentMaker"};

◆ m_segMakerNoHoles

ToolHandle<Muon::IMuonSegmentMaker> Muon::MuonSeededSegmentFinder::m_segMakerNoHoles

private

Initial value:

{

this, "SegmentMakerNoHoles", "Muon::DCMathSegmentMaker/DCMathSegmentMaker"}

actual segment maker no hole search

Definition at line 98 of file MuonSeededSegmentFinder.h.

98 {

99 this, "SegmentMakerNoHoles", "Muon::DCMathSegmentMaker/DCMathSegmentMaker"};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MuonSeededSegmentFinder()

◆ ~MuonSeededSegmentFinder()

Member Function Documentation

◆ extractCscPrdCols()

◆ extractMdtPrdCols()

◆ extractMMPrdCols()

◆ extractPrds() [1/2]

◆ extractPrds() [2/2]

◆ extractRpcPrdCols()

◆ extractsTgcPrdCols()

◆ extractTgcPrdCols()

◆ find() [1/3]

◆ find() [2/3]

◆ find() [3/3]

◆ handleMdtPrd()

◆ initialize()

◆ selectAndCalibrate()

Member Data Documentation

◆ m_adcCut

◆ m_DetectorManagerKey

◆ m_idHelperSvc

◆ m_key_csc

◆ m_key_mdt

◆ m_key_mm

◆ m_key_rpc

◆ m_key_stgc

◆ m_key_tgc

◆ m_magFieldProperties

◆ m_maxSigma

◆ m_mdtRotCreator

◆ m_printer

◆ m_propagator

◆ m_segMaker

◆ m_segMakerNoHoles