Rec::MuidTrackIsolation Class Reference

#include <MuidTrackIsolation.h>

Inheritance diagram for Rec::MuidTrackIsolation:

Collaboration diagram for Rec::MuidTrackIsolation:

Public Member Functions
virtual	~MuidTrackIsolation ()=default
StatusCode	initialize () override
std::pair< int, double >	trackIsolation (const EventContext &ctx, double eta, double phi) const override
	IMuidTrackIsolation interface: get the number of tracks and summed momentum in a cone at the production vertex or around the muon calo intersect.

Private Member Functions
std::pair< int, double >	trackVertex (const xAOD::TrackParticleContainer *indetTracks, double eta, double phi) const
std::pair< int, double >	trackExtrapolated (const xAOD::TrackParticleContainer *indetTracks, double eta, double phi) const

Private Attributes
double	m_barrelCotTheta {}
std::unique_ptr< const Trk::Surface >	m_caloBackwardDisc
std::unique_ptr< const Trk::Surface >	m_caloCylinder
std::unique_ptr< const Trk::Surface >	m_caloForwardDisc
double	m_etaSafetyFactor {0.1}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_inDetTracksLocation {this, "InDetTracksLocation", "InDetTrackParticles", "ID tracks"}
SG::ReadDecorHandleKey< xAOD::TrackParticleContainer >	m_trackLinkKey {this, "TrackLinkKey", m_inDetTracksLocation, "trackLink"}
ToolHandle< Trk::IIntersector >	m_intersector {this, "RungeKuttaIntersector", "Trk::RungeKuttaIntersector/RungeKuttaIntersector"}
Gaudi::Property< double >	m_minPt {this, "MinPt", 1.0 * Gaudi::Units::GeV}
Gaudi::Property< double >	m_trackCone {this, "TrackCone", 0.2}
double	m_trackCone2 {0.}
Gaudi::Property< bool >	m_trackExtrapolation {this, "TrackExtrapolation", false}

Detailed Description

Definition at line 34 of file MuidTrackIsolation.h.

Constructor & Destructor Documentation

~MuidTrackIsolation()

virtual Rec::MuidTrackIsolation::~MuidTrackIsolation ( )

virtualdefault

Member Function Documentation

initialize()

StatusCode MuidTrackIsolation::initialize ( )

override

Definition at line 28 of file MuidTrackIsolation.cxx.

                                              {
        ATH_MSG_INFO("MuidTrackIsolation::initialize()");
 
        // get the Tools
        ATH_CHECK(m_intersector.retrieve());
        m_trackCone2 = m_trackCone * m_trackCone;
        // create the calo barrel surfaces (cylinder) and 2 endcap discs)
        double radius = 2.0 * Gaudi::Units::meter;
        double halfLength = 4.0 * Gaudi::Units::meter;
        Amg::Transform3D transform{Amg::Transform3D::Identity()};
        m_caloCylinder = std::make_unique<Trk::CylinderSurface>(transform, radius, halfLength);
 
        // the corresponding max barrel cotTheta
        m_barrelCotTheta = halfLength / radius;
 
        // and the forward/backward endcap disks
        Amg::Transform3D discRotation{Amg::Transform3D::Identity()};
        Amg::Vector3D forwardDiscPosition(0., 0., halfLength);
        auto transform1 = std::make_unique<Amg::Transform3D>(discRotation * forwardDiscPosition);
        m_caloForwardDisc = std::make_unique<Trk::DiscSurface>(*transform1, 0., radius);
        Amg::Vector3D backwardDiscPosition(0., 0., -halfLength);
        auto transform2 = std::make_unique<Amg::Transform3D>(discRotation * backwardDiscPosition);
        m_caloBackwardDisc = std::make_unique<Trk::DiscSurface>(*transform2, 0., radius);
 
        ATH_CHECK(m_inDetTracksLocation.initialize());
        ATH_CHECK(m_trackLinkKey.initialize());
        return StatusCode::SUCCESS;
    }

trackExtrapolated()

std::pair< int, double > MuidTrackIsolation::trackExtrapolated ( const xAOD::TrackParticleContainer * indetTracks, double eta, double phi ) const

private

Use identiy of cot (x) = tan( pi/2 - x)

Definition at line 121 of file MuidTrackIsolation.cxx.

                                                                                                                                          {
        // set initial state
        double sumP = 0.;
        int numberTracks = 0;
 
        // extrapolate close in eta tracks to calorimeter surface
        for (const xAOD::TrackParticle* idTrack : *inDetTracks) {
 
            const Trk::Track* id = idTrack->track();
            const Trk::Perigee& perigee = *id->perigeeParameters();
            if (id->info().trackProperties(Trk::TrackInfo::StraightTrack) || perigee.pT() < m_minPt) continue;
 
            double inDetEta = perigee.eta();
            if (std::abs(eta - inDetEta) > m_trackCone + m_etaSafetyFactor) continue;
 
            // track has sufficient momentum and is close in eta:
            // find intersection at calo surface
            double qOverP = perigee.parameters()[Trk::qOverP];
            double cotTheta = std::tan(M_PI_2 - perigee.parameters()[Trk::theta]);
            Amg::Vector3D direction(std::cos(perigee.parameters()[Trk::phi]), std::sin(perigee.parameters()[Trk::phi]), cotTheta);
            direction /= direction.mag();
 
            const Trk::TrackSurfaceIntersection idIntersection(perigee.position(), direction, 0.);
            const Trk::Surface* surface = m_caloCylinder.get();
            if (cotTheta > m_barrelCotTheta) {
                surface = m_caloForwardDisc.get();
            } else if (cotTheta < -m_barrelCotTheta) {
                surface = m_caloBackwardDisc.get();
            }
            std::optional<Trk::TrackSurfaceIntersection> caloIntersection(
                m_intersector->intersectSurface(*surface, idIntersection, qOverP));
 
            // no intersection - should never happen !
            if (!caloIntersection) {
                ATH_MSG_DEBUG(" track didn't find intersection !!! "
                              << std::setiosflags(std::ios::fixed) << " Id track: momentum " << std::setw(8) << std::setprecision(1)
                              << perigee.momentum().mag() / Gaudi::Units::GeV << "  with initial eta " << std::setw(8)
                              << std::setprecision(3) << perigee.eta() << "  and phi " << std::setw(8) << std::setprecision(3)
                              << perigee.parameters()[Trk::phi]);
 
                continue;
            }
 
            double diffEta = eta - caloIntersection->position().eta();
            double diffPhi = xAOD::P4Helpers::deltaPhi(phi, caloIntersection->position().phi());
            ATH_MSG_VERBOSE(std::endl
                            << std::setiosflags(std::ios::fixed) << " Id track: momentum " << std::setw(8) << std::setprecision(1)
                            << perigee.momentum().mag() / Gaudi::Units::GeV << "  with initial,extrapolated and calo difference for eta "
                            << std::setw(8) << std::setprecision(3) << perigee.eta() << std::setw(8) << std::setprecision(3)
                            << caloIntersection->position().eta() << std::setw(8) << std::setprecision(3) << diffEta << "  and phi "
                            << std::setw(8) << std::setprecision(3) << perigee.parameters()[Trk::phi] << std::setw(8)
                            << std::setprecision(3) << caloIntersection->position().phi() << std::setw(8) << std::setprecision(3)
                            << diffPhi);
 
            // check if inside cone
            if ((diffPhi * diffPhi + diffEta * diffEta) < m_trackCone2) {
                ++numberTracks;
                const double p = perigee.momentum().mag();
                sumP += p;
 
                ATH_MSG_VERBOSE("  inside cone, track#" << std::setw(3) << numberTracks);
            }
        }
 
        return std::make_pair(numberTracks, sumP);
    }

trackIsolation()

std::pair< int, double > MuidTrackIsolation::trackIsolation ( const EventContext & ctx, double eta, double phi ) const

override

IMuidTrackIsolation interface: get the number of tracks and summed momentum in a cone at the production vertex or around the muon calo intersect.

Definition at line 56 of file MuidTrackIsolation.cxx.

                                                                                                                 {
        // debug input quantities
        ATH_MSG_DEBUG(" MuidTrackIsolation:: " << std::setiosflags(std::ios::fixed)
                                               << (m_trackExtrapolation ? "applied after extrapolation to calo, " : "applied at perigee, ")
                                               << " for muon at calo with eta,phi " << std::setw(8) << std::setprecision(3) << eta
                                               << std::setw(8) << std::setprecision(3) << phi);
 
        // set initial state
        std::pair<int, double> isolation{0, 0.};
 
        // retrieve track collection
        const xAOD::TrackParticleContainer* inDetTracks{};
        if (!SG::get(inDetTracks, m_inDetTracksLocation, ctx).isSuccess()) {
            return std::make_pair(0, 0.);
        }
      
        // evaluate isolation according to configuration
        if (m_trackExtrapolation) {
            isolation = trackExtrapolated(inDetTracks, eta, phi);
        } else {
            isolation = trackVertex(inDetTracks, eta, phi);
        }
 
        // debug result
        ATH_MSG_DEBUG("Found " << isolation.first << std::setiosflags(std::ios::fixed) << " InDet tracks with total momentum "
                               << std::setw(8) << std::setprecision(1) << isolation.second / Gaudi::Units::GeV << " GeV");
 
        return isolation;
    }

trackVertex()

std::pair< int, double > MuidTrackIsolation::trackVertex ( const xAOD::TrackParticleContainer * indetTracks, double eta, double phi ) const

private

Definition at line 86 of file MuidTrackIsolation.cxx.

                                                                                                                                    {
        // set initial state
        double sumP = 0.;
        int numberTracks = 0;
 
        // choose tracks in cone
        for (const xAOD::TrackParticle* idTrack : *inDetTracks) {
            const Trk::Track* id = idTrack->track();
            const Trk::Perigee& perigee = *id->perigeeParameters();
            if (id->info().trackProperties(Trk::TrackInfo::StraightTrack) || perigee.pT() < m_minPt) continue;
 
            double inDetPhi = perigee.parameters()[Trk::phi];
            double inDetEta = perigee.eta();
 
            double diffEta = std::abs(eta - inDetEta);
            double diffPhi = xAOD::P4Helpers::deltaPhi(phi, inDetPhi);
 
            ATH_MSG_DEBUG(std::endl
                          << std::setiosflags(std::ios::fixed) << " Id track: momentum " << std::setw(8) << std::setprecision(1)
                          << perigee.momentum().mag() / Gaudi::Units::GeV << "  with perigee eta and difference " << std::setw(8)
                          << std::setprecision(3) << perigee.eta() << std::setw(8) << std::setprecision(3) << diffEta
                          << "  and same for phi " << std::setw(8) << std::setprecision(3) << perigee.parameters()[Trk::phi] << std::setw(8)
                          << std::setprecision(3) << diffPhi);
 
            if ((diffPhi * diffPhi + diffEta * diffEta) > m_trackCone2) continue;
            ++numberTracks;
            const double p = perigee.momentum().mag();
            sumP += p;
 
            ATH_MSG_VERBOSE("inside cone, track#" << std::setw(3) << numberTracks);
        }
 
        return std::make_pair(numberTracks, sumP);
    }

Member Data Documentation

m_barrelCotTheta

double Rec::MuidTrackIsolation::m_barrelCotTheta {}

private

Definition at line 53 of file MuidTrackIsolation.h.

{};

m_caloBackwardDisc

std::unique_ptr<const Trk::Surface> Rec::MuidTrackIsolation::m_caloBackwardDisc

private

Definition at line 54 of file MuidTrackIsolation.h.

m_caloCylinder

std::unique_ptr<const Trk::Surface> Rec::MuidTrackIsolation::m_caloCylinder

private

Definition at line 55 of file MuidTrackIsolation.h.

m_caloForwardDisc

std::unique_ptr<const Trk::Surface> Rec::MuidTrackIsolation::m_caloForwardDisc

private

Definition at line 56 of file MuidTrackIsolation.h.

m_etaSafetyFactor

double Rec::MuidTrackIsolation::m_etaSafetyFactor {0.1}

private

Definition at line 57 of file MuidTrackIsolation.h.

{0.1};

m_inDetTracksLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> Rec::MuidTrackIsolation::m_inDetTracksLocation {this, "InDetTracksLocation", "InDetTrackParticles", "ID tracks"}

private

Definition at line 58 of file MuidTrackIsolation.h.

{this, "InDetTracksLocation", "InDetTrackParticles", "ID tracks"};

m_intersector

ToolHandle<Trk::IIntersector> Rec::MuidTrackIsolation::m_intersector {this, "RungeKuttaIntersector", "Trk::RungeKuttaIntersector/RungeKuttaIntersector"}

private

Definition at line 62 of file MuidTrackIsolation.h.

{this, "RungeKuttaIntersector", "Trk::RungeKuttaIntersector/RungeKuttaIntersector"};

m_minPt

Gaudi::Property<double> Rec::MuidTrackIsolation::m_minPt {this, "MinPt", 1.0 * Gaudi::Units::GeV}

private

Definition at line 63 of file MuidTrackIsolation.h.

{this, "MinPt", 1.0 * Gaudi::Units::GeV};

m_trackCone

Gaudi::Property<double> Rec::MuidTrackIsolation::m_trackCone {this, "TrackCone", 0.2}

private

Definition at line 64 of file MuidTrackIsolation.h.

{this, "TrackCone", 0.2};

m_trackCone2

double Rec::MuidTrackIsolation::m_trackCone2 {0.}

private

Definition at line 65 of file MuidTrackIsolation.h.

{0.};

m_trackExtrapolation

Gaudi::Property<bool> Rec::MuidTrackIsolation::m_trackExtrapolation {this, "TrackExtrapolation", false}

private

Definition at line 66 of file MuidTrackIsolation.h.

{this, "TrackExtrapolation", false};

m_trackLinkKey

SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> Rec::MuidTrackIsolation::m_trackLinkKey {this, "TrackLinkKey", m_inDetTracksLocation, "trackLink"}

private

Definition at line 60 of file MuidTrackIsolation.h.

{this, "TrackLinkKey", m_inDetTracksLocation, "trackLink"};

---

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

• MuidTrackIsolation.h
• MuidTrackIsolation.cxx