Muon::MuonSegmentMatchingTool Class Reference

tool to match segments using a curved trajectory. More...

#include <MuonSegmentMatchingTool.h>

Inheritance diagram for Muon::MuonSegmentMatchingTool:

Collaboration diagram for Muon::MuonSegmentMatchingTool:

Public Member Functions
	MuonSegmentMatchingTool (const std::string &, const std::string &, const IInterface *)
	constructor
virtual	~MuonSegmentMatchingTool ()=default
	destructor
StatusCode	initialize ()
	AlgTool initilize.
StatusCode	finalize ()
	AlgTool finalize.
bool	match (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2) const
	match two segments

Private Member Functions
bool	straightLineMatch (const MuonSegment &seg1, const MuonSegment &seg2) const
	perform straight line matching using SL extrapolation
bool	curvedMatch (const MuonSegment &seg1, const MuonSegment &seg2) const
	perform curved matching
bool	overlapMatch (const EventContext &ctx, const MuonSegment &seg1, const MuonSegment &seg2) const
	perform overlap matching
bool	initializeField () const
	setup field
bool	hasStereoAngle (const Identifier &id1, const Identifier &id2) const
	check whether the two segments have a stereo angle
bool	isSLMatch (const Identifier &chid1, const Identifier &chid2) const
	check whether we should perform a straight line match
bool	suppressNoise (const MuonSegment &seg1, const MuonSegment &seg2, const bool &useTightCuts) const
	Suppress noise from cavern background/pile up using basic cuts.
bool	suppressNoisePhi (const MuonSegment &seg1, const MuonSegment &seg2, const bool &useTightCuts) const
	Suppress noise from cavern background/pile up using basic cuts in phi.
void	simpleEndcapExtrapolate (double x_segment, double y_segment, double z_segment, double theta_segment, double z_extrapolated, double &r_expected, double &theta_expected, double &rhoInv) const
	extrapolate segment in middle or outer endcap station to inner layer assuming the particle came from the IP
bool	endcapExtrapolationMatch (const MuonSegment &seg1, const MuonSegment &seg2, bool useTightCuts) const
	match an endcap middle or outer segment with an inner segment using a simple analytic extrapolation model

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
	EDM Helper tool.
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer
	EDM printer tool.
ToolHandle< Muon::IMuonSegmentInOverlapResolvingTool >	m_overlapResolvingTool
	matching tool to handle the overlaps
ToolHandle< Muon::IMuonSegmentPairMatchingTool >	m_pairMatchingTool
	matching tool to handle the pairs of segments
Gaudi::Property< bool >	m_toroidOn {this, "ToroidOn", true, "Status of toroidal B-Field"}
std::atomic_uint	m_straightLineMatches {0}
std::atomic_uint	m_straightLineMatchesGood {0}
std::atomic_uint	m_overlapMatches {0}
std::atomic_uint	m_overlapMatchesGood {0}
std::atomic_uint	m_curvedMatches {0}
std::atomic_uint	m_curvedMatchesGood {0}
std::atomic_uint	m_duplicateHitUses {0}
bool	m_isCosmics
bool	m_doOverlapMatch
bool	m_doStraightLineMatch
bool	m_doCurvedMatch
bool	m_thetaMatch
bool	m_phiMatch
bool	m_useLocalAngles {}
double	m_straightLineMatchAngleCut
double	m_straightLineMatchPositionCut
double	m_overlapMatchAngleDPhiCut
	cut of the angular difference between phi from phi match and phi from positions
double	m_overlapMatchAngleDYZCut
	cut of the angular difference between phi from phi match and phi from positions
double	m_overlapMatchPositionCut
	cut on the distance of best position from the chamber bounds
double	m_overlapMatchPositionResidualCut
	cut on the position residual for the best position match
double	m_overlapMatchPhiHitPullCut
	cut on the average pull of the phi hits with the new segment parameters
double	m_angleABCut {}
double	m_maxDistSegments {}
	cut on the maximum distance between the segments
double	m_minDistSegmentsCosmics {}
	cut on the minimum distance between the segments, if the distance is larger
double	m_matchingbibm_lphisec {}
double	m_matchingbibo_lphisec {}
double	m_matchingbmbo_lphisec {}
double	m_matchingeiem_lphisec {}
double	m_matchingeieo_lphisec {}
double	m_matchingemeo_lphisec {}
double	m_matchingbibm_sphisec {}
double	m_matchingbibo_sphisec {}
double	m_matchingbmbo_sphisec {}
double	m_matchingeiem_sphisec {}
double	m_matchingeieo_sphisec {}
double	m_matchingemeo_sphisec {}
double	m_matchingbee_sphisec {}
bool	m_onlySameSectorIfTight {}
	reject all segments in different sectors if in tight matching
bool	m_useTightCuts {}
	only apply tight selection for busy combinations
bool	m_useEndcapExtrapolationMatching {}
double	m_drExtrapRMS {}
double	m_drExtrapAlignmentOffset {}
double	m_dthetaExtrapRMS {}

Detailed Description

tool to match segments using a curved trajectory.

The tool decides whether the matching should be performed with curvature or with a straight line. Cases in which a straight line will be used:

• no magnetic field in the muon spectrometer
• endcap middle/outer combination
• small/large overlap in one station layer

Definition at line 33 of file MuonSegmentMatchingTool.h.

Constructor & Destructor Documentation

MuonSegmentMatchingTool()

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

constructor

Definition at line 16 of file MuonSegmentMatchingTool.cxx.

    : base_class(ty, na, pa) {
    declareProperty("UseCosmicsSettings", m_isCosmics = false, "Pick up settings for cosmics");
    declareProperty("DoOverlapMatch", m_doOverlapMatch = true,
                    "Perform matching for segments in a small/large overlap");
    declareProperty("DoStraightLineMatch", m_doStraightLineMatch = true,
                    "Perform matching for segments in regions without field");
    declareProperty("DoCurvedMatch", m_doCurvedMatch = true, "Perform matching for segments in a field regions");
    declareProperty("doThetaMatching", m_thetaMatch = false, "Pre-matching in theta");
    declareProperty("doPhiMatching", m_phiMatch = false, "Pre-matching in phi");
 
    declareProperty(
        "OverlapMatchAngleDPhiCut", m_overlapMatchAngleDPhiCut = 0.15,
        "Cut on the angular difference between the best phi and the one consistent with the chamber bounds");
    declareProperty(
        "OverlapMatchAngleDYZCut", m_overlapMatchAngleDYZCut = 0.05,
        "Cut on the angular difference between the best phi and the one consistent with the chamber bounds");
    declareProperty("OverlapMatchPositionCut", m_overlapMatchPositionCut = 100.,
                    "Cut on the distance of recalculated position to the tube edge");
    declareProperty("OverlapMatchPositionResidualCut", m_overlapMatchPositionResidualCut = 30.,
                    "Cut on the segment position residual after recalculation of the paramters");
    declareProperty("OverlapMatchAveragePhiHitPullCut", m_overlapMatchPhiHitPullCut = 20.,
                    "Cut on the average pull of the phi hits with the new segment parameters");
 
    declareProperty("StraightLineMatchAngleCut", m_straightLineMatchAngleCut = 0.1,
                    "Cut on the angular difference between the extrapolated segment angle and reference");
    declareProperty("StraightLineMatchPositionCut", m_straightLineMatchPositionCut = 200.,
                    "Cut on the distance of extrapolated segment position and reference");
    declareProperty("MaxDistanceBetweenSegments", m_maxDistSegments = 5000.,
                    "If the two segments are further apart than this distance, they are considered to not match");
 
    declareProperty("OnlySameSectorIfTight", m_onlySameSectorIfTight = true,
                    "Accept only segments that are in the same sector for tight matching");
    declareProperty("TightSegmentMatching", m_useTightCuts = false,
                    "Use tight selection for busy event to suppress combinatorics and improve CPU");
 
    declareProperty("DoMatchingCutsBIBM_S", m_matchingbibm_sphisec = 0.015,
                    "Cut on sumDeltaYZ, segments in BI and BM, small phi sec");
    declareProperty("DoMatchingCutsBIBO_S", m_matchingbibo_sphisec = 0.015,
                    "Cut on sumDeltaYZ, segments in BI and BO, small phi sec");
    declareProperty("DoMatchingCutsBMBO_S", m_matchingbmbo_sphisec = 0.015,
                    "Cut on sumDeltaYZ, segments in BM and BO, small phi sec");
    declareProperty("DoMatchingCutsEIEM_S", m_matchingeiem_sphisec = 0.010 * 2,
                    "Cut on sumDeltaYZ, segments in EI and EM, small phi sec");
    declareProperty("DoMatchingCutsEIEO_S", m_matchingeieo_sphisec = 0.020 * 2,
                    "Cut on sumDeltaYZ, segments in EI and EO, small phi sec");
    declareProperty("DoMatchingCutsEMEO_S", m_matchingemeo_sphisec = 0.002,
                    "Cut on sumDeltaYZ, segments in EM and EO, small phi sec");
    declareProperty("DoMatchingCutsBIBM_L", m_matchingbibm_lphisec = 0.005,
                    "Cut on sumDeltaYZ, segments in BI and BM, large phi sec");
    declareProperty("DoMatchingCutsBIBO_L", m_matchingbibo_lphisec = 0.015,
                    "Cut on sumDeltaYZ, segments in BI and BO, large phi sec");
    declareProperty("DoMatchingCutsBMBO_L", m_matchingbmbo_lphisec = 0.010,
                    "Cut on sumDeltaYZ, segments in BM and BO, large phi sec");
    declareProperty("DoMatchingCutsEIEM_L", m_matchingeiem_lphisec = 0.015 * 2,
                    "Cut on sumDeltaYZ, segments in EI and EM, large phi sec");
    declareProperty("DoMatchingCutsEIEO_L", m_matchingeieo_lphisec = 0.025 * 2,
                    "Cut on sumDeltaYZ, segments in EI and EO, large phi sec");
    declareProperty("DoMatchingCutsEMEO_L", m_matchingemeo_lphisec = 0.002,
                    "Cut on sumDeltaYZ, segments in EM and EO, large phi sec");
    declareProperty("UseEndcapExtrapolationMatching", m_useEndcapExtrapolationMatching = true);
    declareProperty("DrExtrapolationRMS", m_drExtrapRMS = 10);
    declareProperty("DThetaExtrapolationRMS", m_dthetaExtrapRMS = 0.01 * 2);
    declareProperty("DrExtrapolationAlignementOffset", m_drExtrapAlignmentOffset = 50);
}

~MuonSegmentMatchingTool()

virtual Muon::MuonSegmentMatchingTool::~MuonSegmentMatchingTool ( )

virtualdefault

destructor

Member Function Documentation

curvedMatch()

bool Muon::MuonSegmentMatchingTool::curvedMatch ( const MuonSegment & seg1, const MuonSegment & seg2 ) const

private

perform curved matching

Definition at line 191 of file MuonSegmentMatchingTool.cxx.

{
    ++m_curvedMatches;
 
    ATH_MSG_VERBOSE(" curved match ");
 
    // Suppress cavern background noise and combinatorics using both theta and phi matching
    if (m_thetaMatch)
        if (!suppressNoise(seg1, seg2, m_useTightCuts)) {
            return false;
        }
 
    // Suppress cavern background noise and combinatorics using phi matching
    if (m_phiMatch) {
        if (!suppressNoisePhi(seg1, seg2, m_useTightCuts)) return false;
    }
 
    ++m_curvedMatchesGood;
    return true;
}

endcapExtrapolationMatch()

bool Muon::MuonSegmentMatchingTool::endcapExtrapolationMatch ( const MuonSegment & seg1, const MuonSegment & seg2, bool useTightCuts ) const

private

match an endcap middle or outer segment with an inner segment using a simple analytic extrapolation model

Definition at line 762 of file MuonSegmentMatchingTool.cxx.

{
 
    if (!m_useEndcapExtrapolationMatching) return true;
 
    Identifier chid1 = m_edmHelperSvc->chamberId(seg1);
    Identifier chid2 = m_edmHelperSvc->chamberId(seg2);
    if (chid1 == chid2) return false;
 
    StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
    StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
    if (stIndex1 == stIndex2) return false;
 
    const MuonSegment* segInner = nullptr;
    if (stIndex1 == StIndex::EI) segInner = &seg1;
    if (stIndex2 == StIndex::EI) segInner = &seg2;
 
    const MuonSegment* segOuter = nullptr;
    if (stIndex1 == StIndex::EM || stIndex1 == StIndex::EO) segOuter = &seg1;
    if (stIndex2 == StIndex::EM || stIndex2 == StIndex::EO) segOuter = &seg2;
 
    if (!segInner || !segOuter) {
        return false;
    }
    const Amg::Vector3D& pos1 = segOuter->globalPosition();
    const Amg::Vector3D& dir1 = segOuter->globalDirection();
    const Amg::Vector3D& pos2 = segInner->globalPosition();
    const Amg::Vector3D& dir2 = segInner->globalDirection();
 
    // extrapolate the first segment to the inner layer
    double r_expected{0.}, theta_expected{0.}, rhoInv{0.};
    simpleEndcapExtrapolate(pos1.x(), pos1.y(), pos1.z(), dir1.theta(), pos2.z(), r_expected, theta_expected, rhoInv);
 
    if (rhoInv < 0) rhoInv *= -1.;
    double dr     = pos2.perp() - r_expected;
    double dtheta = dir2.theta() - theta_expected;
 
      
    double drCut = m_drExtrapRMS + 5.e6 * rhoInv;
    if (useTightCuts)
        drCut *= 2;
    else
        drCut *= 4;
 
    if ((stIndex1 == StIndex::EM && stIndex2 == StIndex::BI)
        || (stIndex1 == StIndex::BI && stIndex2 == StIndex::EM))
    {
        drCut += 3 * m_drExtrapAlignmentOffset;
    } else {
        drCut += m_drExtrapAlignmentOffset;
    }
 
    double dthetaCut = m_dthetaExtrapRMS + 1.5e3 * rhoInv;
    if (useTightCuts)
        dthetaCut *= 2;
    else
        dthetaCut *= 4;
 
    ATH_MSG_VERBOSE(" simple match " << m_printer->print(seg1) << std::endl
                                     << "              " << m_printer->print(seg2) << std::endl
                                     << " dr " << dr << " cut " << drCut << " dtheta " << dtheta << " cut " << dthetaCut
                                     << " rhoInv " << 1e6 * rhoInv);
 
    if (std::abs(dr) > drCut) return false;
    if (std::abs(dtheta) > dthetaCut) return false;
    return true;
}

finalize()

StatusCode Muon::MuonSegmentMatchingTool::finalize

(

)

AlgTool finalize.

Definition at line 95 of file MuonSegmentMatchingTool.cxx.

{
    double goodOverlapMatchFraction =
        m_overlapMatches != 0 ? (double)m_overlapMatchesGood / ((double)m_overlapMatches) : 0.;
    ATH_MSG_INFO("Overlap matches:      total " << std::setw(7) << m_overlapMatches << " good " << std::setw(7)
                                                << m_overlapMatchesGood << " fraction " << goodOverlapMatchFraction);
 
    double goodStraightLineMatchFraction =
        m_straightLineMatches != 0 ? (double)m_straightLineMatchesGood / ((double)m_straightLineMatches) : 0.;
    ATH_MSG_INFO("StraightLine matches: total " << std::setw(7) << m_straightLineMatches << " good " << std::setw(7)
                                                << m_straightLineMatchesGood << " fraction "
                                                << goodStraightLineMatchFraction);
 
    double goodCurvedMatchFraction =
        m_curvedMatches != 0 ? (double)m_curvedMatchesGood / ((double)m_curvedMatches) : 0.;
    ATH_MSG_INFO("Curved matches:       total " << std::setw(7) << m_curvedMatches << " good " << std::setw(7)
                                                << m_curvedMatchesGood << " fraction " << goodCurvedMatchFraction);
 
    ATH_MSG_INFO("Segments sharing hits:       total " << std::setw(7) << m_duplicateHitUses);
 
 
    return StatusCode::SUCCESS;
}

hasStereoAngle()

bool Muon::MuonSegmentMatchingTool::hasStereoAngle ( const Identifier & id1, const Identifier & id2 ) const

private

check whether the two segments have a stereo angle

Definition at line 303 of file MuonSegmentMatchingTool.cxx.

{
 
    // check whether same phi, else stereo angle (need correction for cosmic up-down tracks)
    int phi1 = m_idHelperSvc->mdtIdHelper().stationPhi(id1);
    int phi2 = m_idHelperSvc->mdtIdHelper().stationPhi(id2);
 
    if (phi1 != phi2) return true;
 
    // check whether there is a small/large overlap
    bool isSmallChamber1 = m_idHelperSvc->isSmallChamber(id1);
    bool isSmallChamber2 = m_idHelperSvc->isSmallChamber(id2);
 
    return isSmallChamber1 != isSmallChamber2;
}

initialize()

StatusCode Muon::MuonSegmentMatchingTool::initialize

(

)

AlgTool initilize.

Definition at line 83 of file MuonSegmentMatchingTool.cxx.

{
    ATH_CHECK(AthAlgTool::initialize());
    ATH_CHECK(m_edmHelperSvc.retrieve());
    ATH_CHECK(m_printer.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_pairMatchingTool.retrieve());
    ATH_CHECK(m_overlapResolvingTool.retrieve());
    return StatusCode::SUCCESS;
}

initializeField()

bool Muon::MuonSegmentMatchingTool::initializeField ( ) const

private

setup field

isSLMatch()

bool Muon::MuonSegmentMatchingTool::isSLMatch ( const Identifier & chid1, const Identifier & chid2 ) const

private

check whether we should perform a straight line match

Definition at line 281 of file MuonSegmentMatchingTool.cxx.

{
 
    // check whether there is field
    if (!m_toroidOn) return true;
 
    StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
    StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
 
    // check whether segments in same station
    if (stIndex1 == stIndex2) return true;
 
    // check whether segments in endcap EM/EO region
    if ((stIndex1 == StIndex::EO && stIndex2 == StIndex::EM)|| 
        (stIndex1 == StIndex::EM && stIndex2 == StIndex::EO))
        return true;
 
    // all other cases should be treated with curvature
    return false;
}

match()

bool Muon::MuonSegmentMatchingTool::match	(	const EventContext &	ctx,
		const MuonSegment &	seg1,
		const MuonSegment &	seg2 ) const

match two segments

Definition at line 119 of file MuonSegmentMatchingTool.cxx.

                                                                                                              {
 
    ATH_MSG_VERBOSE(" match: segments " << std::endl << m_printer->print(seg1) << std::endl << m_printer->print(seg2));
 
    // get identifiers
    Identifier chid1 = m_edmHelperSvc->chamberId(seg1);
    Identifier chid2 = m_edmHelperSvc->chamberId(seg2);
    if (chid1 == chid2) return false;
 
    StIndex stIndex1 = m_idHelperSvc->stationIndex(chid1);
    StIndex stIndex2 = m_idHelperSvc->stationIndex(chid2);
 
    if (isSLMatch(chid1, chid2)) {
        if (!m_idHelperSvc->isMdt(chid1) || !m_idHelperSvc->isMdt(chid2)) return false;
        // if there is a stereo angle match using overlap matching tool
 
        if (stIndex1 == stIndex2) {
 
            if (hasStereoAngle(chid1, chid2)) {
                if (!m_doOverlapMatch) return true;
                const int eta1 = m_idHelperSvc->mdtIdHelper().stationEta(chid1);
                const int eta2 = m_idHelperSvc->mdtIdHelper().stationEta(chid2);
                const int phi1 = m_idHelperSvc->sector(chid1);
                const int phi2 = m_idHelperSvc->sector(chid2);
                // require that the two segments are close in eta AND are in adjecent sectors
                if (  std::abs(eta1-eta2) <=1 
                    && ( std::abs(phi1 - phi2) == 1 || (phi1 == 1 && phi2 == 16)
                        || (phi1 == 16 && phi2 == 1)))
                {
                    return overlapMatch(ctx, seg1, seg2);
                } else
                    return false;
            }
        }
        if (!m_doStraightLineMatch) return true;
 
        if (stIndex1 == stIndex2) return false;
 
        return straightLineMatch(seg1, seg2);
    }
 
    // if we get here perform a curved matching
    if (!m_doCurvedMatch) return true;
    if (stIndex1 == stIndex2) return false;
 
    return curvedMatch(seg1, seg2);
}

overlapMatch()

bool Muon::MuonSegmentMatchingTool::overlapMatch ( const EventContext & ctx, const MuonSegment & seg1, const MuonSegment & seg2 ) const

private

perform overlap matching

Definition at line 213 of file MuonSegmentMatchingTool.cxx.

{
    ++m_overlapMatches;
 
    ATH_MSG_VERBOSE(" overlap match ");
 
    Identifier chid = m_edmHelperSvc->chamberId(seg1);
 
    // check the distance between the two segments
    const float segDist = (seg1.globalPosition() - seg2.globalPosition()).mag();
    ATH_MSG_VERBOSE(" Distance between segments " << segDist);
    if (m_isCosmics && segDist > m_minDistSegmentsCosmics) {
        ATH_MSG_DEBUG(" Too far appart, accepting ");
        return true;
    }
    if (segDist > m_maxDistSegments) return false;
   
    if (!m_idHelperSvc->isMdt(chid)) {
        ATH_MSG_DEBUG(" not a mdt segment " << m_idHelperSvc->toString(chid));
        return true;
    }
 
    IMuonSegmentInOverlapResolvingTool::SegmentMatchResult result = m_overlapResolvingTool->matchResult(ctx, seg1, seg2);
 
    ATH_MSG_VERBOSE(result.toString());
 
    if (!result.goodMatch()) {
        ATH_MSG_DEBUG(" bad match ");
        return false;
    }
 
    result.phiResult = m_overlapResolvingTool->bestPhiMatch(seg1, seg2);
    if (std::abs(result.angularDifferencePhi) > m_overlapMatchAngleDPhiCut
        || std::abs(result.phiResult.deltaYZ) > m_overlapMatchAngleDYZCut)
    {
        ATH_MSG_DEBUG(" failed angle cut: diff phi  " << result.angularDifferencePhi << "  deltaYZ "
                                                      << result.phiResult.deltaYZ);
        return false;
    }
 
    if (std::abs(result.averagePhiHitPullSegment1) > m_overlapMatchPhiHitPullCut
        || std::abs(result.averagePhiHitPullSegment2) > m_overlapMatchPhiHitPullCut)
    {
        ATH_MSG_DEBUG(" failed phi hit pull cut: seg1 " << result.averagePhiHitPullSegment1 << "  seg2 "
                                                        << result.averagePhiHitPullSegment2);
        return false;
    }
 
    if (!result.segmentResult1.inBounds(m_overlapMatchPositionCut)
        || !result.segmentResult2.inBounds(m_overlapMatchPositionCut))
    {
        ATH_MSG_DEBUG(" failed position cut ");
        return false;
    }
 
    if (std::abs(result.segmentResult1.positionResidual) > m_overlapMatchPositionResidualCut
        || std::abs(result.segmentResult2.positionResidual) > m_overlapMatchPositionResidualCut)
    {
        ATH_MSG_DEBUG(" failed position residual cut: seg1 " << result.segmentResult1.positionResidual << "  seg2 "
                                                             << result.segmentResult2.positionResidual);
        return false;
    }
 
    ++m_overlapMatchesGood;
    return true;
}

simpleEndcapExtrapolate()

void Muon::MuonSegmentMatchingTool::simpleEndcapExtrapolate ( double x_segment, double y_segment, double z_segment, double theta_segment, double z_extrapolated, double & r_expected, double & theta_expected, double & rhoInv ) const

private

extrapolate segment in middle or outer endcap station to inner layer assuming the particle came from the IP

Definition at line 833 of file MuonSegmentMatchingTool.cxx.

{
    //
    // Endcap extrapolation with a parabolic track model
    //
    //     In the region z = z start - z end of the Toroid one has:
    //        r_expected  = z tan(theta) + (z  - z start)*(z  - z start)/ rho
    //
    //        outside this region No field
    //
    //     here z start = 6 000 z end = 10 000
    //     theta = direction at the vertex rho is the effective curvature
    //
    double z_start = 7000.;
    double z_end   = 12000.;
 
    if (z_extrapolated < 0) z_start = -z_start;
    if (z_extrapolated < 0) z_end = -z_end;
 
    double r_segment = std::hypot(x_segment , y_segment);
 
    if (std::abs(z_extrapolated) > std::abs(z_segment)) {
        ATH_MSG_WARNING(" extrapolate outwards is not implemented for z " << z_extrapolated);
        r_expected     = 0;
        theta_expected = 0.;
        return;
    }
    if (std::abs(z_segment) < std::abs(z_end)) {
        ATH_MSG_WARNING(" segment before end of Toroid: SL extrapolation is used implemented " << z_segment);
    }
 
    // use SL extrapolation to go to the z_end of the Toroid
    const double tan_seg = std::tan(theta_segment);
   
    double r_end = r_segment + (z_end - z_segment) * tan_seg;
 
    double zgeo     = (z_end - z_start) * (z_end - z_start) - 2 * z_end * (z_end - z_start);
    rhoInv          = (r_end - z_end * tan_seg) / zgeo;
    double tantheta = tan_seg - 2 * (z_end - z_start) * rhoInv;
    r_expected      = z_extrapolated * tantheta + (z_extrapolated - z_start) * (z_extrapolated - z_start) * rhoInv;
    //
    // increase radius by 30% wrt straight line
    //
    double r_SL    = r_segment + (z_extrapolated - z_segment) * tan_seg;
    r_expected     = r_expected + 0.3 * (r_expected - r_SL);
    theta_expected = std::atan(tantheta + 2 * (z_extrapolated - z_start) * rhoInv);
 
    if (tan_seg < 0 && theta_expected < 0) theta_expected += M_PI;
    if (tan_seg > 0 && theta_expected < 0) theta_expected = -theta_expected;
}

straightLineMatch()

bool Muon::MuonSegmentMatchingTool::straightLineMatch ( const MuonSegment & seg1, const MuonSegment & seg2 ) const

private

perform straight line matching using SL extrapolation

Definition at line 169 of file MuonSegmentMatchingTool.cxx.

{
    ++m_straightLineMatches;
 
    ATH_MSG_VERBOSE(" straight line match ");
 
    // Suppress cavern background noise and combinatorics using both theta and phi matching
    if (m_thetaMatch)
        if (!suppressNoise(seg1, seg2, m_useTightCuts)) {
            return false;
        }
 
    // Suppress cavern background noise and combinatorics using phi matching
    if (m_phiMatch) {
        if (!suppressNoisePhi(seg1, seg2, m_useTightCuts)) return false;
    }
 
    ++m_straightLineMatchesGood;
    return true;
}

suppressNoise()

bool Muon::MuonSegmentMatchingTool::suppressNoise ( const MuonSegment & seg1, const MuonSegment & seg2, const bool & useTightCuts ) const

private

Suppress noise from cavern background/pile up using basic cuts.

Definition at line 324 of file MuonSegmentMatchingTool.cxx.

{
 
    // calculate matching variables
    IMuonSegmentPairMatchingTool::SegmentMatchResult result = m_pairMatchingTool->matchResult(seg1, seg2);
 
    StIndex station_a = m_idHelperSvc->stationIndex(result.chid_a);
    StIndex station_b = m_idHelperSvc->stationIndex(result.chid_b);
 
    bool isEndcap_a = m_idHelperSvc->isEndcap(result.chid_a);
    bool isCSC_a    = m_idHelperSvc->isCsc(result.chid_a);
    bool isBEE_a    = station_a == StIndex::BE;
 
    bool isEndcap_b = m_idHelperSvc->isEndcap(result.chid_b);
    bool isCSC_b    = m_idHelperSvc->isCsc(result.chid_b);
    bool isBEE_b    = station_b == StIndex::BE;
 
 
 
 
    ATH_MSG_VERBOSE("SegmentPositionChange "
                  << " " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                  << m_idHelperSvc->chamberNameString(result.chid_b) << " " << result.phiSector_a << " "
                  << result.phiSector_b << " " << result.deltaTheta_a << " " << result.deltaTheta_b << " "
                  << result.deltaTheta << " " << result.angleAC << " " << result.angleBC << " " << result.angleAB);
 
 
    ATH_MSG_VERBOSE("matching " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                                << m_idHelperSvc->chamberNameString(result.chid_b) << " phis " << result.phiSector_a
                                << " " << result.phiSector_b << " thetas " << result.deltaTheta_a << " "
                                << result.deltaTheta_b << " thetaSum " << result.deltaTheta << " tight cuts "
                                << useTightCuts);
 
    // The difference between the segment direction in the inner and outer stations ~< 60 degrees in all cases
    if (result.angleAB > 1.0) return false;
 
 
    // First: loose selection
    if (!useTightCuts) {
        if (isCSC_a || isCSC_b) {
            ATH_MSG_VERBOSE(" check CSC result ");
            if (result.phiSector_a != result.phiSector_b) {
                return false;
            }
            if ((isCSC_a && !isEndcap_b) || (isCSC_b && !isEndcap_a)) return false;
            return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
        }
        // BEE
        else if (isBEE_a || isBEE_b)
        {
            ATH_MSG_VERBOSE(" check BEE result ");
            return result.deltaTheta <= 0.300;
        }
        // Barrel/endcap overlap
        else if (isEndcap_a != isEndcap_b)
        {
            ATH_MSG_VERBOSE(" check B-E result ");
            return result.deltaTheta <= 0.300;
        }
        // Phi-sector overlap
        else if (result.phiSector_a != result.phiSector_b)
        {
            ATH_MSG_VERBOSE(" check phiSector result ");
            if (result.deltaTheta > 0.300) {
                ATH_MSG_VERBOSE(" check phiSector reject ");
                return false;
            } else {
                return true;
            }
        }
        // Barrel inner to middle station
        else if (station_a == StIndex::BI && station_b == StIndex::BM)
        {
            ATH_MSG_VERBOSE(" check BI BM result ");
            if (result.phiSector_a % 2 == 0) {
                return result.deltaTheta <= 6.67 * m_matchingbibm_sphisec;
            } else if (result.phiSector_a % 2 == 1) {
                return result.deltaTheta <= 6.67 * m_matchingbibm_lphisec;
            }
        }
        // Barrel inner to outer station
        else if (station_a == StIndex::BI && station_b == StIndex::BO)
        {
            ATH_MSG_VERBOSE(" check BI BO result ");
            if (result.phiSector_a % 2 == 0) {
                return result.deltaTheta <= 6.67 * m_matchingbibo_sphisec;
            } else if (result.phiSector_a % 2 == 1) {
                return result.deltaTheta <= 6.67 * m_matchingbibo_lphisec;
            }
        }
 
        // Barrel middle to outer station
        else if (station_a == StIndex::BM && station_b == StIndex::BO)
        {
            ATH_MSG_VERBOSE(" check BM BO result ");
            if (result.phiSector_a % 2 == 0) {
                return result.deltaTheta <= 6.67 * m_matchingbmbo_sphisec;
            } else if (result.phiSector_a % 2 == 1) {
                return result.deltaTheta <= 6.67 * m_matchingbmbo_lphisec;
            }
        }
        // Endcap inner to middle station
        else if (station_a == StIndex::EI && (station_b == StIndex::EM))
        {
            ATH_MSG_VERBOSE(" check EI EM result ");
            if (result.phiSector_a % 2 == 0) {
                if (result.deltaTheta > 6.67 * m_matchingeiem_sphisec) {
                    ATH_MSG_VERBOSE(" reject EI EM S result ");
                    return false;
                } else {
                    return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                }
            } else if (result.phiSector_a % 2 == 1) {
                if (result.deltaTheta > 6.67 * m_matchingeiem_lphisec) {
                    ATH_MSG_VERBOSE(" reject EI EM L result ");
                    return false;
                } else {
                    return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                }
            }
        }
        // Endcap inner to outer station
        else if (station_a == StIndex::EI && (station_b == StIndex::EO))
        {
            ATH_MSG_VERBOSE(" check EI EO result ");
            if (result.phiSector_a % 2 == 0) {
                if (result.deltaTheta > 6.67 * m_matchingeieo_sphisec) {
                    ATH_MSG_VERBOSE(" reject EI EO S result ");
                    return false;
                } else {
                    return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                }
            } else if (result.phiSector_a % 2 == 1) {
                if (result.deltaTheta > 6.67 * m_matchingeieo_lphisec) {
                    ATH_MSG_VERBOSE(" reject EI EO L result ");
                    return false;
                } else {
                    return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
                }
            }
        }
        // Endcap middle to outer station
        else if (station_a == StIndex::EM && station_b == StIndex::EO)
        {
            // 5 mrad
            ATH_MSG_VERBOSE(" check EM EO result ");
            if (result.phiSector_a % 2 == 0) {
                return result.deltaTheta <= 6.67 * m_matchingemeo_sphisec;
            } else if (result.phiSector_a % 2 == 1) {
                return result.deltaTheta <= 6.67 * m_matchingemeo_lphisec;
            }
        }
 
        return true;
    }
 
    ATH_MSG_VERBOSE(" check further matching result ");
 
    // Second: tight selection if only if requested
    if (m_onlySameSectorIfTight && result.phiSector_a != result.phiSector_b) {
        ATH_MSG_VERBOSE(" rejection pair as in different sector and using tight cuts");
        return false;
    }
    if (isCSC_a || isCSC_b) {
        if (result.phiSector_a != result.phiSector_b) {
            return false;
        } else {
            if (result.deltaTheta > 0.100) {
                return false;
            } else {
                if ((isCSC_a && !isEndcap_b) || (isCSC_b && !isEndcap_a)) return false;
                return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
            }
        }
 
 
    }
    // BEE
    else if (isBEE_a || isBEE_b)
    {
        return result.deltaTheta <= 0.200;
    }
    // Looser cut for segment in two different phi sectors
    else if (result.phiSector_a != result.phiSector_b)
    {
        return result.deltaTheta <= 0.150;
    }
    // Barrel/endcap overlap
    else if (isEndcap_a != isEndcap_b)
    {
        return result.deltaTheta <= 0.150;
    }
    // Barrel inner to middle station
    else if (station_a == StIndex::BI && station_b == StIndex::BM)
    {
        if (result.phiSector_a % 2 == 0) {
            return result.deltaTheta <= m_matchingbibm_sphisec;
        } else if (result.phiSector_a % 2 == 1) {
            return result.deltaTheta <= m_matchingbibm_lphisec;
        }
    }
    // Barrel inner to outer station
    else if (station_a == StIndex::BI && station_b == StIndex::BO)
    {
        if (result.phiSector_a % 2 == 0) {
            return result.deltaTheta <= m_matchingbibo_sphisec;
        } else if (result.phiSector_a % 2 == 1) {
            return result.deltaTheta <= m_matchingbibo_lphisec;
        }
    }
    // Barrel middle to outer station
    else if (station_a == StIndex::BM && station_b == StIndex::BO)
    {
        if (result.phiSector_a % 2 == 0) {
            return result.deltaTheta <= m_matchingbmbo_sphisec;
        } else if (result.phiSector_a % 2 == 1) {
            return result.deltaTheta <= m_matchingbmbo_lphisec;
        }
    }
    // Endcap inner to middle station
    else if ((station_a == StIndex::EI || station_a == StIndex::BI)
             && station_b == StIndex::EM)
    {
        if (result.phiSector_a % 2 == 0) {
            if (result.deltaTheta > m_matchingeiem_sphisec) {
                return false;
            } else {
                return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
            }
        } else if (result.phiSector_a % 2 == 1) {
            if (result.deltaTheta > m_matchingeiem_lphisec) {
                return false;
            } else {
                return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
            }
        }
    }
    // Endcap inner to outer station
    else if (station_a == StIndex::EI && (station_b == StIndex::EO))
    {
        if (result.phiSector_a % 2 == 0) {
            if (result.deltaTheta > m_matchingeieo_sphisec) {
                return false;
            } else {
                return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
            }
        } else if (result.phiSector_a % 2 == 1) {
            if (result.deltaTheta > m_matchingeieo_lphisec) {
                return false;
            } else {
                return endcapExtrapolationMatch(seg1, seg2, useTightCuts);
            }
        }
    }
    // Endcap middle to outer station
    else if (station_a == StIndex::EM && station_b == StIndex::EO)
    {
        if (result.phiSector_a % 2 == 0) {
            return result.deltaTheta <= m_matchingemeo_sphisec;
        } else if (result.phiSector_a % 2 == 1) {
            return result.deltaTheta <= m_matchingemeo_lphisec;
        }
    }
 
    return true;
}  // if m_useLocalAngles

suppressNoisePhi()

bool Muon::MuonSegmentMatchingTool::suppressNoisePhi ( const MuonSegment & seg1, const MuonSegment & seg2, const bool & useTightCuts ) const

private

Suppress noise from cavern background/pile up using basic cuts in phi.

Definition at line 592 of file MuonSegmentMatchingTool.cxx.

{
    // calculate matching variables
    IMuonSegmentPairMatchingTool::SegmentMatchResult result = m_pairMatchingTool->matchResult(seg1, seg2);
 
    StIndex station_a = m_idHelperSvc->stationIndex(result.chid_a);
    StIndex station_b = m_idHelperSvc->stationIndex(result.chid_b);
 
    bool isEndcap_a = m_idHelperSvc->isEndcap(result.chid_a);
 
    bool isEndcap_b = m_idHelperSvc->isEndcap(result.chid_b);
 
 
    ATH_MSG_VERBOSE("SegmentPositionChange Phi"
                  << " " << m_idHelperSvc->chamberNameString(result.chid_a) << " "
                  << m_idHelperSvc->chamberNameString(result.chid_b) << " deltaPhipos " << result.deltaPhipos
                  << " deltaPhidir " << result.deltaPhidir << " phiposerr_a " << result.phiposerr_a << " phiposerr_b "
                  << result.phiposerr_b << " phidirerr_a " << result.phidirerr_a << " phidirerr_b "
                  << result.phidirerr_b << " shorttube_a " << result.shorttube_a << " shorttube_b "
                  << result.shorttube_b);
 
    // Keep segments only if they are in the same or adjacent phi sectors
    if (result.phiSector_a != result.phiSector_b
        && ((result.phiSector_a != 16 && result.phiSector_b != 1)
            && (result.phiSector_a != 1 && result.phiSector_b != 16))
        && (result.phiSector_a != (result.phiSector_b + 1) && result.phiSector_a != (result.phiSector_b - 1)))
        return false;
 
    // First: loose selection
    if (!useTightCuts) {
        // cuts on second coordinate
        if (result.phiSector_a == result.phiSector_b) {
            if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
 
                if (!isEndcap_a && !isEndcap_b) {
                    return result.deltaPhipos <= 0.1;
                }
                if (isEndcap_a && isEndcap_b) {
                    // small sectors
                    if (result.phiSector_a % 2 == 0) {
                        return result.deltaPhipos <= 0.1;
                    }
                    // large sectors
                    if (result.phiSector_a % 2 == 1) {
                        return result.deltaPhipos <= 0.2;
                    }
                }
            }
        }
 
        if (result.phiSector_a != result.phiSector_b) {
            if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
                if (!isEndcap_a && !isEndcap_b) {
                    return result.deltaPhipos <= 0.1;
                }
                if (isEndcap_a && isEndcap_b) {
                    return result.deltaPhipos <= 0.2;
                }
            }
         }
 
        // cuts on distance to tube edge
        // only if in a different phi sector
        if (result.phiSector_a != result.phiSector_b) {
            // measured inner segment
            if (result.phiposerr_a < 10001.000) {
                if (station_a == StIndex::BM && station_b == StIndex::BO) {
                    return result.shorttube_a <= 800;
                }
                if (station_a == StIndex::EI && station_b == StIndex::EM) {
                    // MM or STGC have result.shorttube = 99999.
                    return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
                }
                if (station_a == StIndex::EI && station_b == StIndex::EO) {
                    return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
                }
                if (station_a == StIndex::EM && station_b == StIndex::EO) {
                    return result.shorttube_a <= 800;
                }
            }
            // measured outer segment
            if (result.phiposerr_b < 10001.000) {
                if (station_a == StIndex::BI && station_b == StIndex::BM) {
                    return result.shorttube_b <= 800;
                }
                if (station_a == StIndex::BI && station_b == StIndex::BO) {
                    return result.shorttube_b <= 800;
                }
                if (station_a == StIndex::BM && station_b == StIndex::BO) {
                    return result.shorttube_b <= 800;
                }
                if (station_a == StIndex::EI && station_b == StIndex::EM) {
                    return result.shorttube_b <= 1400;
                }
            }
        }
        return true;
    }
 
 
    // Second: tight selection if only if requested
    // cuts on second coordinate
    if (result.phiSector_a == result.phiSector_b) {
        if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
            if (!isEndcap_a && !isEndcap_b) {
                return result.deltaPhipos <= 0.1;
            }
            if (isEndcap_a && isEndcap_b) {
                // small sectors
                if (result.phiSector_a % 2 == 0) {
                    return result.deltaPhipos <= 0.08;
                }
                // large sectors
                if (result.phiSector_a % 2 == 1) {
                    return result.deltaPhipos <= 0.1;
                }
            }
        }
    }
    // cuts on distance to tube edge
    // only if in a different phi sector
    if (result.phiSector_a != result.phiSector_b) {
        if (result.phiposerr_a < 10001.000 && result.phiposerr_b < 10001.000) {
            if (!isEndcap_a && !isEndcap_b) {
                return result.deltaPhipos <= 0.05;
            }
            if (isEndcap_a && isEndcap_b) {
                return result.deltaPhipos <= 0.1;
            }
        }
        
       
        // measured inner segment
        if (result.phiposerr_a < 10001.000) {
            if (station_a == StIndex::BM && station_b == StIndex::BO) {
                return result.shorttube_a <= 600;
            }
            if (station_a == StIndex::EI && station_b == StIndex::EM) {
                return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
            }
            if (station_a == StIndex::EI && station_b == StIndex::EO) {
                return result.shorttube_a <= 3500 || result.shorttube_a == 99999.;
            }
            if (station_a == StIndex::EM && station_b == StIndex::EO) {
                return result.shorttube_a <= 500;
            }
        }
        // measured outer segment
        if (result.phiposerr_b < 10001.000) {
            if (station_a == StIndex::BI && station_b == StIndex::BM) {
                return result.shorttube_b <= 600;
            }
            if (station_a == StIndex::BI && station_b == StIndex::BO) {
                return result.shorttube_b <= 700;
            }
            if (station_a == StIndex::BM && station_b == StIndex::BO) {
                return result.shorttube_b <= 700;
            }
            if (station_a == StIndex::EI && station_b == StIndex::EM) {
                return result.shorttube_b <= 700;
            }
        }
        
    }
    return true;
}  // if m_useLocalAngles

Member Data Documentation

m_angleABCut

double Muon::MuonSegmentMatchingTool::m_angleABCut {}

private

Definition at line 146 of file MuonSegmentMatchingTool.h.

{};

m_curvedMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_curvedMatches {0}

mutableprivate

Definition at line 120 of file MuonSegmentMatchingTool.h.

{0};

m_curvedMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_curvedMatchesGood {0}

mutableprivate

Definition at line 121 of file MuonSegmentMatchingTool.h.

{0};

m_doCurvedMatch

bool Muon::MuonSegmentMatchingTool::m_doCurvedMatch

private

Definition at line 127 of file MuonSegmentMatchingTool.h.

m_doOverlapMatch

bool Muon::MuonSegmentMatchingTool::m_doOverlapMatch

private

Definition at line 125 of file MuonSegmentMatchingTool.h.

m_doStraightLineMatch

bool Muon::MuonSegmentMatchingTool::m_doStraightLineMatch

private

Definition at line 126 of file MuonSegmentMatchingTool.h.

m_drExtrapAlignmentOffset

double Muon::MuonSegmentMatchingTool::m_drExtrapAlignmentOffset {}

private

Definition at line 170 of file MuonSegmentMatchingTool.h.

{};

m_drExtrapRMS

double Muon::MuonSegmentMatchingTool::m_drExtrapRMS {}

private

Definition at line 169 of file MuonSegmentMatchingTool.h.

{};

m_dthetaExtrapRMS

double Muon::MuonSegmentMatchingTool::m_dthetaExtrapRMS {}

private

Definition at line 171 of file MuonSegmentMatchingTool.h.

{};

m_duplicateHitUses

std::atomic_uint Muon::MuonSegmentMatchingTool::m_duplicateHitUses {0}

mutableprivate

Definition at line 122 of file MuonSegmentMatchingTool.h.

{0};

m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> Muon::MuonSegmentMatchingTool::m_edmHelperSvc

private

Initial value:

{
        this,
        "edmHelper",
        "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
        "Handle to the service providing the IMuonEDMHelperSvc interface",
    }

EDM Helper tool.

Definition at line 91 of file MuonSegmentMatchingTool.h.

                                                       {
        this,
        "edmHelper",
        "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
        "Handle to the service providing the IMuonEDMHelperSvc interface",
    };  

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonSegmentMatchingTool::m_idHelperSvc

private

Initial value:

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

Definition at line 86 of file MuonSegmentMatchingTool.h.

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

m_isCosmics

bool Muon::MuonSegmentMatchingTool::m_isCosmics

private

Definition at line 124 of file MuonSegmentMatchingTool.h.

m_matchingbee_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbee_sphisec {}

private

Definition at line 163 of file MuonSegmentMatchingTool.h.

{};

m_matchingbibm_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibm_lphisec {}

private

Definition at line 150 of file MuonSegmentMatchingTool.h.

{};

m_matchingbibm_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibm_sphisec {}

private

Definition at line 156 of file MuonSegmentMatchingTool.h.

{};

m_matchingbibo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibo_lphisec {}

private

Definition at line 151 of file MuonSegmentMatchingTool.h.

{};

m_matchingbibo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbibo_sphisec {}

private

Definition at line 157 of file MuonSegmentMatchingTool.h.

{};

m_matchingbmbo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingbmbo_lphisec {}

private

Definition at line 152 of file MuonSegmentMatchingTool.h.

{};

m_matchingbmbo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingbmbo_sphisec {}

private

Definition at line 158 of file MuonSegmentMatchingTool.h.

{};

m_matchingeiem_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingeiem_lphisec {}

private

Definition at line 153 of file MuonSegmentMatchingTool.h.

{};

m_matchingeiem_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingeiem_sphisec {}

private

Definition at line 159 of file MuonSegmentMatchingTool.h.

{};

m_matchingeieo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingeieo_lphisec {}

private

Definition at line 154 of file MuonSegmentMatchingTool.h.

{};

m_matchingeieo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingeieo_sphisec {}

private

Definition at line 160 of file MuonSegmentMatchingTool.h.

{};

m_matchingemeo_lphisec

double Muon::MuonSegmentMatchingTool::m_matchingemeo_lphisec {}

private

Definition at line 155 of file MuonSegmentMatchingTool.h.

{};

m_matchingemeo_sphisec

double Muon::MuonSegmentMatchingTool::m_matchingemeo_sphisec {}

private

Definition at line 161 of file MuonSegmentMatchingTool.h.

{};

m_maxDistSegments

double Muon::MuonSegmentMatchingTool::m_maxDistSegments {}

private

cut on the maximum distance between the segments

Definition at line 147 of file MuonSegmentMatchingTool.h.

{};         

m_minDistSegmentsCosmics

double Muon::MuonSegmentMatchingTool::m_minDistSegmentsCosmics {}

private

cut on the minimum distance between the segments, if the distance is larger

than the cut the segments are always matched (for cosmics)

Definition at line 148 of file MuonSegmentMatchingTool.h.

{};  

m_onlySameSectorIfTight

bool Muon::MuonSegmentMatchingTool::m_onlySameSectorIfTight {}

private

reject all segments in different sectors if in tight matching

Definition at line 165 of file MuonSegmentMatchingTool.h.

{};  

m_overlapMatchAngleDPhiCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchAngleDPhiCut

private

cut of the angular difference between phi from phi match and phi from positions

Definition at line 137 of file MuonSegmentMatchingTool.h.

m_overlapMatchAngleDYZCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchAngleDYZCut

private

cut of the angular difference between phi from phi match and phi from positions

Definition at line 140 of file MuonSegmentMatchingTool.h.

m_overlapMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_overlapMatches {0}

mutableprivate

Definition at line 118 of file MuonSegmentMatchingTool.h.

{0};

m_overlapMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_overlapMatchesGood {0}

mutableprivate

Definition at line 119 of file MuonSegmentMatchingTool.h.

{0};

m_overlapMatchPhiHitPullCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPhiHitPullCut

private

cut on the average pull of the phi hits with the new segment parameters

Definition at line 143 of file MuonSegmentMatchingTool.h.

m_overlapMatchPositionCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPositionCut

private

cut on the distance of best position from the chamber bounds

Definition at line 141 of file MuonSegmentMatchingTool.h.

m_overlapMatchPositionResidualCut

double Muon::MuonSegmentMatchingTool::m_overlapMatchPositionResidualCut

private

cut on the position residual for the best position match

Definition at line 142 of file MuonSegmentMatchingTool.h.

m_overlapResolvingTool

ToolHandle<Muon::IMuonSegmentInOverlapResolvingTool> Muon::MuonSegmentMatchingTool::m_overlapResolvingTool

private

Initial value:

{
        this,
        "MuonSegmentInOverlapResolvingTool",
        "Muon::MuonSegmentInOverlapResolvingTool/MuonSegmentInOverlapResolvingTool",
    }

matching tool to handle the overlaps

Definition at line 103 of file MuonSegmentMatchingTool.h.

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

m_pairMatchingTool

ToolHandle<Muon::IMuonSegmentPairMatchingTool> Muon::MuonSegmentMatchingTool::m_pairMatchingTool

private

Initial value:

{
        this,
        "MuonSegmentPairMatchingTool",
        "Muon::MuonSegmentPairMatchingTool/MuonSegmentPairMatchingTool",
    }

matching tool to handle the pairs of segments

Definition at line 108 of file MuonSegmentMatchingTool.h.

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

m_phiMatch

bool Muon::MuonSegmentMatchingTool::m_phiMatch

private

Definition at line 129 of file MuonSegmentMatchingTool.h.

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonSegmentMatchingTool::m_printer

private

Initial value:

{
        this,
        "Printer",
        "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
    }

EDM printer tool.

Definition at line 98 of file MuonSegmentMatchingTool.h.

                                                      {
        this,
        "Printer",
        "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
    };  

m_straightLineMatchAngleCut

double Muon::MuonSegmentMatchingTool::m_straightLineMatchAngleCut

private

Definition at line 133 of file MuonSegmentMatchingTool.h.

m_straightLineMatches

std::atomic_uint Muon::MuonSegmentMatchingTool::m_straightLineMatches {0}

mutableprivate

Definition at line 116 of file MuonSegmentMatchingTool.h.

{0};

m_straightLineMatchesGood

std::atomic_uint Muon::MuonSegmentMatchingTool::m_straightLineMatchesGood {0}

mutableprivate

Definition at line 117 of file MuonSegmentMatchingTool.h.

{0};

m_straightLineMatchPositionCut

double Muon::MuonSegmentMatchingTool::m_straightLineMatchPositionCut

private

Definition at line 134 of file MuonSegmentMatchingTool.h.

m_thetaMatch

bool Muon::MuonSegmentMatchingTool::m_thetaMatch

private

Definition at line 128 of file MuonSegmentMatchingTool.h.

m_toroidOn

Gaudi::Property<bool> Muon::MuonSegmentMatchingTool::m_toroidOn {this, "ToroidOn", true, "Status of toroidal B-Field"}

private

Definition at line 114 of file MuonSegmentMatchingTool.h.

{this, "ToroidOn", true, "Status of toroidal B-Field"};

m_useEndcapExtrapolationMatching

bool Muon::MuonSegmentMatchingTool::m_useEndcapExtrapolationMatching {}

private

Definition at line 168 of file MuonSegmentMatchingTool.h.

{};

m_useLocalAngles

bool Muon::MuonSegmentMatchingTool::m_useLocalAngles {}

private

Definition at line 130 of file MuonSegmentMatchingTool.h.

{};

m_useTightCuts

bool Muon::MuonSegmentMatchingTool::m_useTightCuts {}

private

only apply tight selection for busy combinations

Definition at line 166 of file MuonSegmentMatchingTool.h.

{};           

---

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

• MuonSegmentMatchingTool.h
• MuonSegmentMatchingTool.cxx