Muon::NSWSeed Struct Reference

#include <MuonNSWSegmentFinderTool.h>

Collaboration diagram for Muon::NSWSeed:

Classes
struct	SeedMeasurement
	Struct caching the MuonClusterOnTrack and providing the orientation of the strip in addtion. More...

Public Types
enum class	SeedOR { NoOverlap , Same , SubSet , SuperSet }
using	MeasVec = std::vector<SeedMeasurement>
	Returns the contained measurements.

Public Member Functions
	NSWSeed ()=default
	NSWSeed (const MuonNSWSegmentFinderTool *parent, const std::array< SeedMeasurement, 4 > &seed, const std::array< double, 2 > &lengths)
	NSWSeed (const MuonNSWSegmentFinderTool *parent, const SeedMeasurement &first, const SeedMeasurement &second)
	NSWSeed (const MuonNSWSegmentFinderTool *parent, const Muon::MuonSegment &seg)
	Constructor to build a seed from an existing segment.
	NSWSeed (const MuonNSWSegmentFinderTool *parent, const Amg::Vector3D &pos, const Amg::Vector3D &dir)
double	chi2 () const
size_t	size () const
	Returns the number of measurements.
const Amg::Vector3D &	pos () const
	Returns the position of the seed.
const Amg::Vector3D &	dir () const
	Returns the direction of the seed.
MeasVec	measurements () const
bool	add (SeedMeasurement meas, double max_uncert)
	Tries to add the measurement to the seeds. Returns false if the measurement is incompatible with the seed or the seed is invalid.
const Muon::MuonClusterOnTrack *	newCalibClust (std::unique_ptr< const Muon::MuonClusterOnTrack > new_clust)
	Adds a calibrated cluster to the garbage collection.
SeedOR	overlap (const NSWSeed &other) const

Private Types
using	SeedMeasCache = std::array<SeedMeasurement, 16>
	Helper pair to cache the measurements with the respective distances.

Private Member Functions
int	channel (const SeedMeasurement &meas) const
	Returns the channel of the measurement on the layer.
bool	find (const SeedMeasurement &meas) const
	Checks whether the measurement is already part of the seed.
double	distance (const SeedMeasurement &meas) const
	Calculates the minimal distance between seed and measurement.
bool	insert (const Muon::MuonClusterOnTrack *cl)
bool	insert (SeedMeasurement meas)

Private Attributes
const MuonNSWSegmentFinderTool *	m_parent {nullptr}
SeedMeasCache	m_measurements {}
	Cache the eta measurements.
SeedMeasCache	m_phiMeasurements {}
	Cache the phi measurements.
SeedMeasCache	m_padMeasurements {}
	Cache the sTGC pad measurements.
Amg::Vector3D	m_pos {Amg::Vector3D::Zero()}
	Starting position of the seed.
Amg::Vector3D	m_dir {Amg::Vector3D::Zero()}
	Seed direction.
double	m_width {0.}
	seed width
double	m_chi2 {0.}
	Chi2.
size_t	m_size {0}
	Added measurements on track.
std::set< std::shared_ptr< const Muon::MuonClusterOnTrack > >	m_calibClust {}
	Garbage container per seed.

Detailed Description

Definition at line 29 of file MuonNSWSegmentFinderTool.h.

Member Typedef Documentation

MeasVec

using Muon::NSWSeed::MeasVec = std::vector<SeedMeasurement>

Returns the contained measurements.

Definition at line 82 of file MuonNSWSegmentFinderTool.h.

SeedMeasCache

using Muon::NSWSeed::SeedMeasCache = std::array<SeedMeasurement, 16>

private

Helper pair to cache the measurements with the respective distances.

Definition at line 105 of file MuonNSWSegmentFinderTool.h.

Member Enumeration Documentation

SeedOR

enum class Muon::NSWSeed::SeedOR

strong

Enumerator
NoOverlap
Same
SubSet
SuperSet

Definition at line 89 of file MuonNSWSegmentFinderTool.h.

{ NoOverlap, Same, SubSet, SuperSet };

Constructor & Destructor Documentation

NSWSeed() [1/5]

Muon::NSWSeed::NSWSeed ( )

default

NSWSeed() [2/5]

Muon::NSWSeed::NSWSeed	(	const MuonNSWSegmentFinderTool *	parent,
		const std::array< SeedMeasurement, 4 > &	seed,
		const std::array< double, 2 > &	lengths )

Insert the measurements

Definition at line 107 of file MuonNSWSegmentFinderTool.cxx.

                                                        :
      m_parent{parent},
      m_pos{seed[0].pos() + lengths[0] * seed[0].dir()} {
 
        const Amg::Vector3D un_dir = (seed[1].pos() + lengths[1] *seed[1].dir() - m_pos);
        m_dir = un_dir.unit()*(un_dir.z() * seed[0].pos().z() > 0 ? 1 : -1);
 
        if (m_parent->msgLvl(MSG::VERBOSE))
            m_parent->msgStream() << MSG::VERBOSE << m_parent->printSeed(seed)<<" is a valid seed "<<to_string(m_pos) <<" pointing to "<<to_string(m_dir)<<"."<<endmsg;

        for (const SeedMeasurement& cl : seed) {
            insert(cl);
            m_width = std::hypot(m_width, Amg::error(cl->localCovariance(), Trk::locX));
        }
        m_width /= std::sqrt(3);
    }

NSWSeed() [3/5]

Muon::NSWSeed::NSWSeed	(	const MuonNSWSegmentFinderTool *	parent,
		const SeedMeasurement &	first,
		const SeedMeasurement &	second )

Definition at line 125 of file MuonNSWSegmentFinderTool.cxx.

                                                    :
        m_parent{parent}, m_pos{first.pos()} {
        m_dir = (second.pos() - m_pos).unit();
        m_width = std::hypot(Amg::error(first->localCovariance(), Trk::locX),
                             Amg::error(second->localCovariance(), Trk::locX)) / std::sqrt(2);
        insert(first);
        insert(second);
    }

NSWSeed() [4/5]

Muon::NSWSeed::NSWSeed	(	const MuonNSWSegmentFinderTool *	parent,
		const Muon::MuonSegment &	seg )

Constructor to build a seed from an existing segment.

Definition at line 134 of file MuonNSWSegmentFinderTool.cxx.

                                                                                       :
        m_parent{parent}, m_pos{seg.globalPosition()}, m_dir{seg.globalDirection()} {
        for (const Trk::MeasurementBase* meas : seg.containedMeasurements()) {
            const Muon::MuonClusterOnTrack* clus = dynamic_cast<const Muon::MuonClusterOnTrack*>(meas);
            if (!clus) continue;
            insert(clus);
            m_width = std::hypot(m_width, Amg::error(clus->localCovariance(), Trk::locX));
        }
        m_width /= std::sqrt(size());
    }

NSWSeed() [5/5]

Muon::NSWSeed::NSWSeed	(	const MuonNSWSegmentFinderTool *	parent,
		const Amg::Vector3D &	pos,
		const Amg::Vector3D &	dir )

Definition at line 144 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                           :
        m_parent{parent}, m_pos{pos}, m_dir{dir}, m_size{1} {}

Member Function Documentation

add()

bool Muon::NSWSeed::add	(	SeedMeasurement	meas,
		double	max_uncert )

Tries to add the measurement to the seeds. Returns false if the measurement is incompatible with the seed or the seed is invalid.

Definition at line 160 of file MuonNSWSegmentFinderTool.cxx.

                                                             {
        if (!size() || !meas) return false;
        if (find(meas)) return true;
        Trk::Intersection intersect = meas->associatedSurface().straightLineIntersection(pos(), dir(), false, false);
        Amg::Vector2D lpos_seed{Amg::Vector2D::Zero()};
        if (!meas->associatedSurface().globalToLocal(intersect.position, dir(), lpos_seed)) return false;
        // Dont allow seeds outside of active areas to create seeds
        // Happens rarely but is good protection to reduce wrong channel to track association
        if (!meas->associatedSurface().insideBounds(lpos_seed)) return false;
 
        // Dont save sTGC wires in inner Q1
        if (m_parent->isWire(meas)) {
            const sTgcPrepData* prd = static_cast<const sTgcPrepData*>(meas->prepRawData());
            if (prd->detectorElement()->isEtaZero(prd->identify(), lpos_seed)) return false;
        }
 
        if (m_parent->isPad(meas)) {
            const sTgcPrepData* prd = dynamic_cast<const sTgcPrepData*>(meas->prepRawData());
            if (!prd) return false;
            const MuonGM::MuonPadDesign* design = prd->detectorElement()->getPadDesign(prd->identify());
            if (!design) return false;
            Amg::Vector2D padDist = design->distanceToPad(lpos_seed, channel(meas));
            const double dist = std::hypot(padDist.x(), padDist.y());
            meas.setDistance(dist);
            const double uncertD = std::max(1., m_width);
            return (meas.distance() / uncertD < max_uncert) && insert(meas);
        }
        meas.setDistance(distance(meas));
        const double uncertD = std::max(1.,std::hypot(m_width, Amg::error(meas->localCovariance(), Trk::locX)));
        if (m_parent->msgLvl(MSG::VERBOSE)) {
            m_parent->msgStream() << MSG::VERBOSE << m_parent->print(meas) << " is separated  from "
                                  << to_string(pos())<<" + lambda " <<to_string(dir())<<" " << meas.distance()
                                  << ". covariance: " << (meas.distance() / uncertD) << endmsg;
        }
        return (meas.distance() / uncertD < max_uncert) && insert(meas);
    }

channel()

int Muon::NSWSeed::channel ( const SeedMeasurement & meas ) const

private

Returns the channel of the measurement on the layer.

Definition at line 146 of file MuonNSWSegmentFinderTool.cxx.

{return m_parent->channel(meas);}

chi2()

double Muon::NSWSeed::chi2 ( ) const

inline

Definition at line 73 of file MuonNSWSegmentFinderTool.h.

{return m_chi2;}

dir()

const Amg::Vector3D & Muon::NSWSeed::dir ( ) const

inline

Returns the direction of the seed.

Definition at line 79 of file MuonNSWSegmentFinderTool.h.

{ return m_dir; }

distance()

double Muon::NSWSeed::distance ( const SeedMeasurement & meas ) const

private

Calculates the minimal distance between seed and measurement.

Definition at line 147 of file MuonNSWSegmentFinderTool.cxx.

                                                              {
        const Amg::Vector3D& A = pos();
        const Amg::Vector3D& B = dir();
        const Amg::Vector3D& C = meas.pos();
        const Amg::Vector3D& D = meas.dir();
        const double BdotD = B.dot(D);
        const double divisor = (1. - std::pow(BdotD, 2));
        const Amg::Vector3D diff = C - A;
        if (std::abs(divisor) < std::numeric_limits<double>::epsilon()) return diff.mag();
        const double beta = (diff.dot(B) - diff.dot(D) * BdotD) / divisor;
        const double delta = (diff.dot(B) * BdotD - diff.dot(D)) / divisor;
        return (beta * B - delta * D - diff).mag();
    }

find()

bool Muon::NSWSeed::find ( const SeedMeasurement & meas ) const

private

Checks whether the measurement is already part of the seed.

Definition at line 248 of file MuonNSWSegmentFinderTool.cxx.

                                                        {
        const int lay = m_parent->layerNumber(meas);
        if (m_parent->isPad(meas)) return m_padMeasurements[lay] == meas;
        if (m_parent->idHelper()->measuresPhi(meas->identify())) return m_phiMeasurements[lay] == meas;
        return m_measurements[lay] == meas;
    }

insert() [1/2]

bool Muon::NSWSeed::insert ( const Muon::MuonClusterOnTrack * cl )

private

Definition at line 226 of file MuonNSWSegmentFinderTool.cxx.

                                                         {
        SeedMeasurement meas{cl};
        meas.setDistance(distance(meas));
        return insert(std::move(meas));
    }

insert() [2/2]

bool Muon::NSWSeed::insert ( SeedMeasurement meas )

private

Definition at line 231 of file MuonNSWSegmentFinderTool.cxx.

                                             {
        SeedMeasCache& seed_vec = m_parent->idHelper()->measuresPhi(meas->identify()) ?
                                 (m_parent->isPad(meas) ? m_padMeasurements : m_phiMeasurements ): m_measurements;
        SeedMeasurement& seed = seed_vec[m_parent->layerNumber(meas)];
        if (!seed || meas.distance() < seed.distance()) {
            m_size += !seed;
            m_chi2 += meas.distance() / Amg::error(meas->localCovariance(), Trk::locX);
            // From this point the measurement is now the old one
            std::swap(seed, meas);
            if (meas)  m_chi2 -= meas.distance() / Amg::error(meas->localCovariance(), Trk::locX);
            return true;
        }
        return false;
    }

measurements()

MeasVec Muon::NSWSeed::measurements

(

)

const

Definition at line 213 of file MuonNSWSegmentFinderTool.cxx.

                                        {
        MeasVec meas;
        meas.reserve(size());
        for (size_t m = 0; m < m_measurements.size(); ++m) {
            if (m_measurements[m]) meas.push_back(m_measurements[m]);
            if (m_phiMeasurements[m]) meas.push_back(m_phiMeasurements[m]);
            if (m_padMeasurements[m]) meas.push_back(m_padMeasurements[m]);
        }
        std::sort(meas.begin(), meas.end(), [](const SeedMeasurement& a, const SeedMeasurement& b) {
            return std::abs(a->globalPosition().z()) < std::abs(b->globalPosition().z());
        });
        return meas;
    }

newCalibClust()

const Muon::MuonClusterOnTrack * Muon::NSWSeed::newCalibClust

(

std::unique_ptr< const Muon::MuonClusterOnTrack >

new_clust

)

Adds a calibrated cluster to the garbage collection.

Definition at line 245 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                              {
        return m_calibClust.emplace(std::move(new_clust)).first->get();
    }

overlap()

NSWSeed::SeedOR Muon::NSWSeed::overlap

(

const NSWSeed &

other

)

const

Definition at line 196 of file MuonNSWSegmentFinderTool.cxx.

                                                             {
        SeedOR res{SeedOR::Same};
        unsigned int only_th{0}, only_oth{0};
        for (size_t m = 0; m < m_measurements.size(); ++m) {
            if (m_measurements[m]== other.m_measurements[m] &&
                m_phiMeasurements[m] == other.m_phiMeasurements[m])
                continue;
            res = SeedOR::NoOverlap;
            if (!m_measurements[m]) ++only_oth;
            if (!m_phiMeasurements[m]) ++only_oth;
            if (!other.m_measurements[m]) ++only_th;
            if (!other.m_phiMeasurements[m]) ++only_th;
        }
        if (only_oth && !only_th) return SeedOR::SubSet;
        if (only_th && !only_oth) return SeedOR::SuperSet;
        return res;
    }

pos()

const Amg::Vector3D & Muon::NSWSeed::pos ( ) const

inline

Returns the position of the seed.

Definition at line 77 of file MuonNSWSegmentFinderTool.h.

{ return m_pos; }

size()

size_t Muon::NSWSeed::size ( ) const

inline

Returns the number of measurements.

Definition at line 75 of file MuonNSWSegmentFinderTool.h.

{ return m_size; }

Member Data Documentation

m_calibClust

std::set<std::shared_ptr<const Muon::MuonClusterOnTrack> > Muon::NSWSeed::m_calibClust {}

private

Garbage container per seed.

Definition at line 123 of file MuonNSWSegmentFinderTool.h.

{};

m_chi2

double Muon::NSWSeed::m_chi2 {0.}

private

Chi2.

Definition at line 119 of file MuonNSWSegmentFinderTool.h.

{0.};

m_dir

Amg::Vector3D Muon::NSWSeed::m_dir {Amg::Vector3D::Zero()}

private

Seed direction.

Definition at line 115 of file MuonNSWSegmentFinderTool.h.

{Amg::Vector3D::Zero()};

m_measurements

SeedMeasCache Muon::NSWSeed::m_measurements {}

private

Cache the eta measurements.

Definition at line 107 of file MuonNSWSegmentFinderTool.h.

{};

m_padMeasurements

SeedMeasCache Muon::NSWSeed::m_padMeasurements {}

private

Cache the sTGC pad measurements.

Definition at line 111 of file MuonNSWSegmentFinderTool.h.

{};

m_parent

const MuonNSWSegmentFinderTool* Muon::NSWSeed::m_parent {nullptr}

private

Definition at line 103 of file MuonNSWSegmentFinderTool.h.

{nullptr};

m_phiMeasurements

SeedMeasCache Muon::NSWSeed::m_phiMeasurements {}

private

Cache the phi measurements.

Definition at line 109 of file MuonNSWSegmentFinderTool.h.

{};

m_pos

Amg::Vector3D Muon::NSWSeed::m_pos {Amg::Vector3D::Zero()}

private

Starting position of the seed.

Definition at line 113 of file MuonNSWSegmentFinderTool.h.

{Amg::Vector3D::Zero()};

m_size

size_t Muon::NSWSeed::m_size {0}

private

Added measurements on track.

Definition at line 121 of file MuonNSWSegmentFinderTool.h.

{0};

m_width

double Muon::NSWSeed::m_width {0.}

private

seed width

Definition at line 117 of file MuonNSWSegmentFinderTool.h.

{0.};

---

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

• MuonNSWSegmentFinderTool.h
• MuonNSWSegmentFinderTool.cxx